347 lines
9.4 KiB
C
347 lines
9.4 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2022 Unisoc (Shanghai) Technologies Co., Ltd.
|
|
*
|
|
* SPDX-License-Identifier: LicenseRef-Unisoc-General-1.0
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include "callback.h"
|
|
#include "gnss_adapter.h"
|
|
|
|
extern bool vdbg;
|
|
|
|
extern int gps_status;
|
|
extern int agps_status;
|
|
extern int ni_notification_id;
|
|
|
|
void srv_gps_location_callback(GpsLocation* location)
|
|
{
|
|
|
|
if (location && (location->flags & GPS_LOCATION_HAS_LAT_LONG)) {
|
|
char location_buf[LOCATION_BUF_SIZE];
|
|
memset(location_buf, '\0', sizeof(location_buf));
|
|
sprintf(location_buf, "%s%llu^%f^%f^", TAG_LOCATION_NAME, location->timestamp, location->latitude, location->longitude);
|
|
|
|
int write_num = -1;
|
|
if (vdbg) ALOGD("%s, %s", __func__, location_buf);
|
|
//report location to tty
|
|
if ((write_num= write(mpty, location_buf, LOCATION_BUF_SIZE)) < 0) {
|
|
ALOGE("write to mpty %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
|
|
} else {
|
|
if (vdbg) ALOGI("write to mpty %d success, ret=%d\n", mpty, write_num);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void srv_gps_status_callback(GpsStatus* status)
|
|
{
|
|
if(!status)
|
|
{
|
|
ALOGE("%s input is null", __func__);
|
|
return;
|
|
} else {
|
|
ALOGD("%s: GpsStatus->status=%d", __func__, status->status);
|
|
gps_status = status->status;
|
|
|
|
int type_array[] = { DBUS_TYPE_INT32 };
|
|
dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
|
|
GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
|
|
SIGNAL_NAME_GPS_STATUS_CHANGED,
|
|
type_array, 1, status->status);
|
|
}
|
|
}
|
|
|
|
void srv_gps_sv_status_callback(GpsSvStatus* sv_info)
|
|
{
|
|
// do nothing
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
|
|
void srv_gnss_sv_status_callback(GnssSvStatus* sv_info)
|
|
{
|
|
if(sv_info != NULL)
|
|
{
|
|
|
|
char svstatus_buf[SVSTATUS_BUF_SIZE];
|
|
char tmp_str[32];
|
|
memset(svstatus_buf, '\0', sizeof(svstatus_buf));
|
|
memset(tmp_str, '\0', sizeof(tmp_str));
|
|
sprintf(svstatus_buf, "%s", TAG_SVSTATUS_NAME);
|
|
for (int i = 0; i < sv_info->num_svs; i++) {
|
|
memset(tmp_str, 0, sizeof(tmp_str));
|
|
if(i == sv_info->num_svs -1)
|
|
sprintf(tmp_str, "%d^%f", sv_info->gnss_sv_list[i].svid, sv_info->gnss_sv_list[i].c_n0_dbhz);
|
|
else
|
|
sprintf(tmp_str, "%d^%f^", sv_info->gnss_sv_list[i].svid, sv_info->gnss_sv_list[i].c_n0_dbhz);
|
|
strcat(svstatus_buf, tmp_str);
|
|
}
|
|
|
|
int write_num = -1;
|
|
ALOGD("%s, %s", __func__, svstatus_buf);
|
|
//report location to tty
|
|
if ((write_num= write(mpty, svstatus_buf, SVSTATUS_BUF_SIZE)) < 0) {
|
|
ALOGE("write to mpty %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
|
|
}else{
|
|
ALOGD("write to mpty %d success, ret=%d\n", mpty, write_num);
|
|
}
|
|
}
|
|
}
|
|
void srv_gps_nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
|
|
{
|
|
int write_num = -1;
|
|
//just output
|
|
if (vdbg) ALOGI("nmea=%s timestamp=%lld length=%d", nmea, timestamp, length);
|
|
if(nmea != NULL )
|
|
{
|
|
//send location to Framework
|
|
if ((write_num= write(mpty, nmea, length + 1)) < 0) {
|
|
ALOGE("write to mtpy %d ERROR: %s, ret=%d\n", mpty, strerror(errno), write_num);
|
|
} else {
|
|
if (vdbg) ALOGD("write to mpty %d success, ret=%d\n", mpty, write_num);
|
|
}
|
|
}
|
|
}
|
|
void srv_gps_set_capabilities(uint32_t capabilities)
|
|
{
|
|
//do nothing
|
|
ALOGD("%s set capabilities is 0x%x", __func__, capabilities);
|
|
}
|
|
void srv_gps_acquire_wakelock()
|
|
{
|
|
// do nothing
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
void srv_gps_release_wakelock()
|
|
{
|
|
// do nothing
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
void srv_gps_request_utc_time()
|
|
{
|
|
// do nothing
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
void srv_gnss_set_system_info(const GnssSystemInfo* info)
|
|
{
|
|
// do nothing
|
|
ALOGI("%s %x", __func__, info->year_of_hw);
|
|
}
|
|
|
|
void srv_agps_status_callback(AGpsStatus* status)
|
|
{
|
|
if(!status)
|
|
{
|
|
ALOGE("%s input is null", __func__);
|
|
return;
|
|
} else {
|
|
ALOGD("%s: AgpsStatus->size=%zu", __func__, status->size);
|
|
ALOGD("%s: AgpsStatus->type=%d", __func__, status->type);
|
|
ALOGD("%s: AgpsStatus->status=%d", __func__, status->status);
|
|
ALOGD("%s: AgpsStatus->ipaddr=%d", __func__, status->ipaddr);
|
|
agps_status = status->status;
|
|
|
|
int type_array[] = { DBUS_TYPE_INT32, DBUS_TYPE_INT32, DBUS_TYPE_INT32 };
|
|
dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
|
|
GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
|
|
SIGNAL_NAME_AGPS_STATUS_CHANGED,
|
|
type_array, 3, status->type, status->status, status->ipaddr);
|
|
}
|
|
|
|
if (status->status & GPS_REQUEST_AGPS_DATA_CONN)
|
|
{
|
|
//shall active the SUPL APN and then inform the libgps ,here just inform the libgps
|
|
fetch_agps_connection();
|
|
}
|
|
else if(status->status & GPS_RELEASE_AGPS_DATA_CONN)
|
|
{
|
|
drop_agps_connection();
|
|
}
|
|
}
|
|
|
|
/*FOR NI notify callback */
|
|
void srv_gps_ni_notify_callback(GpsNiNotification *notification)
|
|
{
|
|
if (!notification) {
|
|
ALOGE("%s: GpsNiNotification is null", __func__);
|
|
return;
|
|
}
|
|
ALOGD("%s: notification id is %d", __func__, notification->notification_id);
|
|
ALOGD("%s: notification ni type is %d", __func__, notification->ni_type);
|
|
ALOGD("%s: notification flags is %d", __func__, notification->notify_flags);
|
|
ALOGD("%s: notification timeout is %d", __func__, notification->timeout);
|
|
ALOGD("%s: notification requestor id is %s", __func__, notification->requestor_id);
|
|
ALOGD("%s: notification text is %s", __func__, notification->text);
|
|
int type_array[] = {
|
|
DBUS_TYPE_INT32,
|
|
DBUS_TYPE_INT32,
|
|
DBUS_TYPE_INT32,
|
|
DBUS_TYPE_INT32,
|
|
DBUS_TYPE_STRING,
|
|
DBUS_TYPE_STRING
|
|
};
|
|
|
|
dh_sendsignal(DBUS_BUS_SYSTEM, GNSS_ADAPTER_BUS_SIGNAL_PATH,
|
|
GNSS_ADAPTER_BUS_SIGNAL_INTERFACE,
|
|
SIGNAL_NAME_NI_NOTIFICATION,
|
|
type_array, 6,
|
|
notification->notification_id,
|
|
notification->ni_type,
|
|
notification->notify_flags,
|
|
notification->timeout,
|
|
notification->requestor_id,
|
|
notification->text);
|
|
}
|
|
|
|
/*FOR RIL callback*/
|
|
void srv_agps_ril_request_set_id(uint32_t flags)
|
|
{
|
|
int rlt = feed_agps_sim_info(flags);
|
|
if(rlt == -1){
|
|
ALOGE("%s failed!",__func__);
|
|
}else{
|
|
ALOGD("%s success!",__func__);
|
|
}
|
|
}
|
|
|
|
void srv_agps_ril_request_ref_loc(uint32_t flags)
|
|
{
|
|
int rlt = 0;
|
|
rlt = feed_agps_cell_info(flags);
|
|
if(rlt == -1){
|
|
ALOGE("%s failed!",__func__);
|
|
}else{
|
|
ALOGD("%s success!",__func__);
|
|
}
|
|
}
|
|
/*FOR GPS geofence callback*/
|
|
// todo
|
|
/*FOR gnss MSR correction callback*/
|
|
void srv_gnss_set_capabilities_callback(int capabilities)
|
|
{
|
|
//do nothing
|
|
ALOGD("%s set GNSS capabilities is 0x%x", __func__, capabilities);
|
|
}
|
|
/*FOR gps MSR callback*/
|
|
void srv_gps_measurement_callback(GpsData* data)
|
|
{
|
|
// shall inform Framework
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
void srv_gnss_measurement_callback(GnssData* data)
|
|
{
|
|
// shall inform Framework
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
/* FOR visibility callback */
|
|
void srv_gnss_nfw_notify_callback(GnssNfwNotification* notification)
|
|
{
|
|
// do nothing
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
bool srv_isInEmergencySession_callback()
|
|
{
|
|
// do nothing
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
return false;
|
|
}
|
|
|
|
/*FOR navigation message callback*/
|
|
void srv_gps_navigation_message_callback(GpsNavigationMessage* message)
|
|
{
|
|
// shall inform Framework
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
void srv_gnss_navigation_message_callback(GnssNavigationMessage* message)
|
|
{
|
|
// shall inform Framework
|
|
//
|
|
ALOGI("%s ", __func__);
|
|
}
|
|
|
|
|
|
pthread_t srv_gps_create_thread(const char* name, void (*start)(void *), void* arg)
|
|
{
|
|
int ret = 0;
|
|
pthread_t threadId = 0;
|
|
pthread_attr_t attr;
|
|
|
|
pthread_attr_init(&attr);
|
|
|
|
ret = pthread_create(&threadId, &attr, (void *(*)(void *))start, arg);
|
|
if(ret != 0)
|
|
{
|
|
return -1;
|
|
}
|
|
pthread_detach(threadId);
|
|
|
|
return threadId;
|
|
}
|
|
GpsCallbacks g_gpsCallback =
|
|
{
|
|
sizeof(GpsCallbacks),
|
|
srv_gps_location_callback,
|
|
srv_gps_status_callback,
|
|
srv_gps_sv_status_callback,
|
|
srv_gps_nmea_callback,
|
|
srv_gps_set_capabilities,
|
|
srv_gps_acquire_wakelock,
|
|
srv_gps_release_wakelock,
|
|
srv_gps_create_thread,
|
|
srv_gps_request_utc_time,
|
|
srv_gnss_set_system_info,
|
|
srv_gnss_sv_status_callback
|
|
};
|
|
|
|
AGpsCallbacks g_agpsCallback =
|
|
{
|
|
srv_agps_status_callback,
|
|
srv_gps_create_thread
|
|
};
|
|
|
|
GpsNiCallbacks g_niCallback =
|
|
{
|
|
srv_gps_ni_notify_callback,
|
|
srv_gps_create_thread
|
|
};
|
|
|
|
AGpsRilCallbacks g_rilCallback =
|
|
{
|
|
srv_agps_ril_request_set_id,
|
|
srv_agps_ril_request_ref_loc,
|
|
srv_gps_create_thread
|
|
};
|
|
|
|
GpsMeasurementCallbacks g_msrCallback =
|
|
{
|
|
sizeof(GpsMeasurementCallbacks),
|
|
srv_gps_measurement_callback,
|
|
srv_gnss_measurement_callback
|
|
};
|
|
|
|
GpsNavigationMessageCallbacks g_navCallback =
|
|
{
|
|
sizeof(GpsNavigationMessageCallbacks),
|
|
srv_gps_navigation_message_callback,
|
|
srv_gnss_navigation_message_callback
|
|
};
|
|
|
|
GnssMeasurementCorrectionCallbacks g_msrCorrCallback =
|
|
{
|
|
sizeof(GnssMeasurementCorrectionCallbacks),
|
|
srv_gnss_set_capabilities_callback
|
|
};
|
|
|
|
GnssVisibilityControlCallbacks g_visCtrlCallback =
|
|
{
|
|
sizeof(GnssVisibilityControlCallbacks),
|
|
srv_gnss_nfw_notify_callback,
|
|
srv_isInEmergencySession_callback
|
|
};
|