--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file
+ * positioning_application.cpp
+ * @brief
+ * Module : POSITIONING
+ * Implements Vehicle service functionality
+ */
+
+/*---------------------------------------------------------------------------------*
+ * Include Files *
+ *---------------------------------------------------------------------------------*/
+#include <native_service/frameworkunified_application.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <native_service/frameworkunified_multithreading.h>
+#include <native_service/frameworkunified_service_protocol.h>
+#include <native_service/frameworkunified_types.h>
+#include <native_service/ns_message_center_if.h>
+#include <peripheral_service/ps_services.h>
+#include <vehicle_service/POS_sensor_API.h>
+#include <vehicle_service/POS_gps_API.h>
+#include <system_service/ss_sm_client_if.h>
+#include <vehicle_service/positioning_base_library.h>
+#include <stub/vehicle_notifications.h>
+#include <peripheral_service/communication_notifications.h>
+#include <other_service/VP_GetEnv.h>
+#include <cstdlib>
+#include <iostream>
+
+#include "SensorLog.h"
+#include "positioning_common.h"
+#include "POS_private.h"
+#include "Gps_API_private.h"
+#include "POS_common_private.h"
+#include "Vehicle_API.h"
+#include "Vehicle_API_private.h"
+#include "Sensor_API_private.h"
+#include "Naviinfo_API.h"
+#include "VehicleSensor_Thread.h"
+#include "ClockGPS_Process_Proto.h"
+#include "VehicleSens_Common.h"
+#include "VehicleSens_DataMaster.h"
+#include "VehicleSens_DeliveryCtrl.h"
+#include "VehicleUtility.h"
+#include "BackupMgrIf.h"
+#include "ClockIf.h"
+#include "CommUsbIf.h"
+#include "DevDetectSrvIf.h"
+#include "DiagSrvIf.h"
+#include "PSMShadowIf.h"
+#include "VehicleIf.h"
+#include "positioning_hal.h"
+#include "gps_hal.h"
+#include "CommonDefine.h"
+
+#include "VehicleIf.h"
+
+/*---------------------------------------------------------------------------------*
+ * Definition *
+ *---------------------------------------------------------------------------------*/
+#define DATMOD_RETRY (3) /* Number of shared memory generation retries */
+#define DATMOD_PREINIT (0) /* Shared Memory State Before Initialization */
+#define PRIM_NAME_MAX (32) /* Maximum Name Size */
+
+/* Mask for managing various notification reception conditions */
+#define NTFY_MSK_NONE (0x00)
+/* Service availability notification */
+#define NTFY_MSK_COMMUNICATION_AVAILABILITY (0x01)
+#define NTFY_MSK_PS_COMMUSB_AVAILABILITY (0x02)
+#define NTFY_MSK_PS_PSMSHADOW_AVAILABILITY (0x04)
+#define NTFY_MSK_CLOCK_AVAILABILITY (0x08)
+#define NTFY_MSK_NS_BACKUPMGR_AVAILABILITY (0x10)
+#define NTFY_MSK_SS_DEVDETSRV_AVAILABILITY (0x20)
+#define NTFY_MSK_VS_VEHICLE_AVAILABILITY (0x40)
+/* Other Notices */
+#define NTFY_MSK_PS_PSMSHADOW_INIT_COMP (0x01) /* PSMShadow startup completion notice */
+
+/* Thread state */
+#define THREAD_STS_NOEXIST (0x00)
+#define THREAD_STS_CREATING (0x01)
+#define THREAD_STS_CREATED (0x02)
+
+#define POS_SNDMSG_DTSIZE_1 1 /* SndMSG data size 1Byte */
+#define POS_SNDMSG_DTSIZE_2 2 /* SndMSG data size 2Byte */
+#define POS_SNDMSG_DTSIZE_20 20 /* SndMSG data size of 20 bytes */
+#define POS_SNDMSG_DTSIZE_132 132 /* SndMSG data size: 132 bytes */
+
+/* PositioningLogFlag */
+#define POSITIONINGLOG_FLAG_NAVI 9
+
+/* Definition for thinning out sensor log at anomaly */
+#define POSITIONINGLOG_SYS_1_ABNORMAL_DATA_NUM 3
+#define POSITIONINGLOG_SYS_2_ABNORMAL_DATA_NUM 4
+#define POSITIONINGLOG_SYS_3_ABNORMAL_DATA_NUM 4
+#define POSITIONINGLOG_SYS_4_ABNORMAL_DATA_NUM 129
+#define POSITIONINGLOG_SYS_ABNORMAL_DATA_NUM (POSITIONINGLOG_SYS_1_ABNORMAL_DATA_NUM + \
+ POSITIONINGLOG_SYS_2_ABNORMAL_DATA_NUM + \
+ POSITIONINGLOG_SYS_3_ABNORMAL_DATA_NUM + \
+ POSITIONINGLOG_SYS_4_ABNORMAL_DATA_NUM)
+#define POSITIONINGLOG_SYS_1_ABNORMAL_DATA_OFFSET 11
+#define POSITIONINGLOG_SYS_2_ABNORMAL_DATA_OFFSET 32
+#define POSITIONINGLOG_SYS_3_ABNORMAL_DATA_OFFSET 54
+#define POSITIONINGLOG_SYS_4_ABNORMAL_DATA_OFFSET 114
+#define POSITIONINGLOG_SYS_1_ABNORMAL_SET_DATA_OFFSET 0
+#define POSITIONINGLOG_SYS_2_ABNORMAL_SET_DATA_OFFSET POSITIONINGLOG_SYS_1_ABNORMAL_DATA_NUM
+#define POSITIONINGLOG_SYS_3_ABNORMAL_SET_DATA_OFFSET (POSITIONINGLOG_SYS_1_ABNORMAL_DATA_NUM + POSITIONINGLOG_SYS_2_ABNORMAL_DATA_NUM)
+#define POSITIONINGLOG_SYS_4_ABNORMAL_SET_DATA_OFFSET (POSITIONINGLOG_SYS_1_ABNORMAL_DATA_NUM + \
+ POSITIONINGLOG_SYS_2_ABNORMAL_DATA_NUM + \
+ POSITIONINGLOG_SYS_3_ABNORMAL_DATA_NUM)
+#define POSITIONINGLOG_SYS_OPC_OFFSET 9
+#define POSITIONINGLOG_SYS_PULSE_TIME_NUM_OFFSET 114
+#define POSITIONINGLOG_SYS_NORMAL_DATA 0xC1
+#define POSITIONINGLOG_SYS_FST_DATA 0xF4
+#define _pb_strcat(pdest, psrc, size) (strncat(pdest, psrc, size) , (0))
+
+// Vehicle sensor information notification message
+typedef struct {
+ uint32_t did; // Data ID corresponding to vehicle sensor information
+ uint16_t size; // Data size of vehicle sensor information
+ uint8_t rcv_flag; // Vehicle sensor information reception flag
+ uint8_t reserve; // Reserved
+ uint8_t data[VEHICLE_VSINFO_DSIZE]; // Vehicle sensor information
+} VEHICLE_UNIT_MSG_VSINFO_DAT;
+
+// Vehicle sensor information notification message
+typedef struct {
+ VEHICLE_UNIT_MSG_VSINFO_DAT data; // Message data
+} VEHICLE_UNIT_MSG_VSINFO;
+/*---------------------------------------------------------------------------------*
+ * Structre *
+ *---------------------------------------------------------------------------------*/
+/*!
+ @brief Structure to create shared data
+*/
+typedef struct {
+ char share_data_name[PRIM_NAME_MAX]; /**< Shared data name */
+ u_int32 data_size; /**< Shared data size */
+} ST_SHAREDATA;
+
+/*!
+ @brief Thread management information
+*/
+typedef struct {
+ EnumTID_POS id; /**< Thread ID */
+ const int8_t* p_name; /**< Thread name */
+ PNO pno; /**< Process number */
+ CbFuncPtr routine; /**< Start Routine */
+ uint8_t msk_available; /**< Dependent services Availability */
+ uint8_t msk_ntfy; /**< Dependency notification */
+ uint8_t msk_thread; /**< Dependent threads */
+ BOOL is_depended; /**< Positioning/Availability->TRUE change dependency */
+ uint8_t status; /**< Thread activation state */
+ uint8_t order; /**< Boot Sequence(Performance) */
+ uint8_t reserve[2];
+} ST_THREAD_CREATE_INFO;
+
+
+/* GPS fix count information */
+typedef struct {
+ uint32_t ul3d; /* 3D */
+ uint32_t ul2d; /* 2D */
+ uint32_t ul_else; /* Not fix */
+ uint8_t dummy[4]; /* Dummy */
+} ST_GPS_FIX_CNT;
+
+/*!
+ @brief Structure that stores the time set by the time setting or the time updated(For GRADE1)
+*/
+typedef struct {
+ u_int16 year; /* Year */
+ u_int8 month; /* Month */
+ u_int8 date; /* Day */
+ u_int8 hour; /* Hour */
+ u_int8 minute;/* Minutes */
+ u_int8 second;/* Minutes */
+ u_int8 flag; /* Whether or not the time is set */
+} ST_GPS_SET_TIME;
+
+/*---------------------------------------------------------------------------------*
+ * Local Function Prototype *
+ *---------------------------------------------------------------------------------*/
+static EFrameworkunifiedStatus PositioningOnStartImpl(const HANDLE hApp, const EPWR_SC_WAKEUP_TYPE wakeupType,
+ const ESMDataResetModeInfo dataResetMode);
+static EFrameworkunifiedStatus PosNotifyCommunicationAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyCommUSBAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyPSMShadowAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyPSMShadowInitComp(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyClockAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyNSBackupMgrAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyDevDetectSrvAvailability(HANDLE h_app);
+static EFrameworkunifiedStatus PosNotifyVehicleAvailability(HANDLE h_app);
+
+static EFrameworkunifiedStatus PosStopThreadDummy(HANDLE h_app);
+static void PosCreateSharedMemory(void);
+static void PosCreateThread(HANDLE h_app);
+static void PosStopThread(void);
+static void PosBackupDataInit(void);
+
+/* Message Dispatching Functions */
+static EFrameworkunifiedStatus PosThreadCreateComp(HANDLE h_app);
+static EFrameworkunifiedStatus PosThreadStopComp(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifRegisterListenerPkgSensorData(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifRegisterListenerSensorData(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifReqGpsSetting(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifSetGpsInfo(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifGetGpsInfo(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifSetData(HANDLE h_app);
+static EFrameworkunifiedStatus PosPosifReqGpsReset(HANDLE h_app);
+static EFrameworkunifiedStatus PosVehicleInfoRcv(HANDLE h_app);
+static uint32_t PosGetMsg(HANDLE h_app, void** p_buf, uint32_t size);
+static RET_API PosSndMsg(PNO pno, CID cid, void* p_msg_body, uint32_t size);
+static void PosOutputDebugDumpLog(uint8_t* p_buf);
+
+/* Function scan for device insertion detection */
+static EFrameworkunifiedStatus PosOnDevDetectOpenSessionAck(HANDLE h_app);
+static EFrameworkunifiedStatus PosOnDevDetectCloseSessionAck(HANDLE h_app);
+static EFrameworkunifiedStatus PosOnDevDetectEvent(HANDLE h_app);
+
+/*---------------------------------------------------------------------------------*
+ * Grobal Value *
+ *---------------------------------------------------------------------------------*/
+/* Thread name */
+static const int8_t kThreadNamePosMain[15] = "POS_Main";
+static const int8_t kThreadNamePosSens[15] = "POS_Sens";
+static const int8_t kThreadNamePosGps[15] = "POS_Gps";
+static const int8_t kThreadNamePosGpsRecv[15] = "POS_Gps_Recv";
+static const int8_t kThreadNamePosGpsRollover[15] = "POS_Gps_Rolovr";
+
+/** Shared memory generation table */
+static ST_SHAREDATA g_sharedata_tbl[] = {
+ /* Shared data name to be generated, Shared data size */
+ { {VEHICLE_SHARE_NAME}, 512 * 11 }, /* Vehicle sensor information acquisition */
+#if 0 /* Less than 0.1 SBU,Not used in _CWORD71_ */
+ { {"SENSOR_SHARE_MEMORY"}, 512 * 11 }, /* Vehicle sensor information Pkg acquisition */
+ { {"GPS_INT_SIGNAL_SHARE_MEMORY"}, 4 }, /* GPS Interrupt Signal Acquisition */
+ { {"LOG_SETTING_SHARE_MEMORY"}, 36 }, /* DR feature log acquisition */
+ { {"GYRO_CONNECT_STTS_SHARE_MEMORY"}, 4 }, /* Get Gyro Connection Status */
+ { {"EPHEMERIS_NUM_SHARE_MEMORY"}, 4 }, /* For acquiring effective ephemeris count at shutdown */
+ { {"LOCALTIME_SHARE_MEMORY"}, 12 }, /* Local time acquisition at shutdown */
+ { {"LONLAT_SHARE_MEMORY"}, 8 }, /* Location acquisition at shutdown */
+#endif
+ { {'\0'}, 0 } /* Termination */
+};
+
+/** Sub-thread creation table
+ (1) Thread ID (Locally defined Enumeration)
+ (2) Thread name
+ (3) Process number
+ (4) Start Routine
+ (5) Dependent Availability
+ (6) Dependency notification
+ (7) Dependent threads * If there are dependent threads, do not create them until those threads are created.
+ (8) Positioning/Availability->TRUE depending on change
+ (9) Thread activation state (THREAD_STS_NOEXIST:Not started,THREAD_STS_CREATING:Starting,THREAD_STS_CREATED:Completion of the activation)
+ (10) Boot Sequence(Performance) (0,1,2, ... Note : 0 = Initial value(Not started)) Time of termination,Be destroyed in the reverse order of startup
+ */
+static ST_THREAD_CREATE_INFO g_pos_thread_create_info_Grade1[] = { // LCOV_EXCL_BR_LINE 11: unexpected branch
+ { /* Pos_main */
+ ETID_POS_MAIN, /* (1) */
+ kThreadNamePosMain, /* (2) */
+ PNO_VEHICLE_SENSOR, /* (3) */
+ &VehicleSensThread, /* (4) */
+ (NTFY_MSK_NONE), /* (5) */
+ (NTFY_MSK_NONE), /* (6) */
+ 0, /* (7) */
+ TRUE, /* (8) */
+ THREAD_STS_NOEXIST, /* (9) */
+ 0 /* (10) */
+ },
+ { /* Pos_sens */
+ ETID_POS_SENS, /* (1) */
+ kThreadNamePosSens, /* (2) */
+ PNO_LINE_SENS_DRV, /* (3) */
+ &StartLineSensorThreadPositioning, /* (4) */
+ (NTFY_MSK_PS_PSMSHADOW_AVAILABILITY), /* (5) */
+ (NTFY_MSK_NONE), /* (6) */
+ THREAD_STS_MSK_POS_MAIN, /* (7) */
+ FALSE, /* (8) */
+ THREAD_STS_NOEXIST, /* (9) */
+ 0 /* (10) */
+ },
+ { /* Pos_gps */
+ ETID_POS_GPS, /* (1) */
+ kThreadNamePosGps, /* (2) */
+ PNO_NAVI_GPS_MAIN, /* (3) */
+ &StartGpsMainThreadPositioning, /* (4) */
+ (NTFY_MSK_NONE), /* (5) */
+ (NTFY_MSK_NONE), /* (6) */
+ THREAD_STS_MSK_POS_MAIN, /* (7) */
+ TRUE, /* (8) */
+ THREAD_STS_NOEXIST, /* (9) */
+ 0 /* (10) */
+ },
+ { /* Pos_gps_recv */
+ ETID_POS_GPS_RECV, /* (1) */
+ kThreadNamePosGpsRecv, /* (2) */
+ PNO_NAVI_GPS_RCV, /* (3) */
+ &StartGpsRecvThreadPositioning, /* (4) */
+ (NTFY_MSK_NONE), /* (5) */
+ (NTFY_MSK_NONE), /* (6) */
+ THREAD_STS_MSK_POS_GPS, /* (7) */
+ FALSE, /* (8) */
+ THREAD_STS_NOEXIST, /* (9) */
+ 0 /* (10) */
+ },
+ { /* Pos_gps_rollover */
+ ETID_POS_GPS_ROLLOVER, /* (1) */
+ kThreadNamePosGpsRollover, /* (2) */
+ PNO_CLK_GPS, /* (3) */
+ &StartGpsRolloverThreadPositioning, /* (4) */
+ (NTFY_MSK_NS_BACKUPMGR_AVAILABILITY), /* (5) */
+ (NTFY_MSK_NONE), /* (6) */
+ THREAD_STS_MSK_POS_GPS, /* (7) */
+ FALSE, /* (8) */
+ THREAD_STS_NOEXIST, /* (9) */
+ 0 /* (10) */
+ },
+ { /* Termination */
+ ETID_POS_MAX, NULL, 0, NULL, NTFY_MSK_NONE, NTFY_MSK_NONE, 0, FALSE, THREAD_STS_NOEXIST, 0
+ },
+};
+
+/* State Management Variables */
+static bool g_start_flg = false; /** Start Processed Flag */
+static EnumExeSts_POS g_exe_sts; /** Positioning running status */
+static EnumSetupMode_POS g_setup_mode; /** Thread activation mode */
+static uint8_t g_last_thread_sts; /** Latest internal thread activation state */
+static uint8_t g_last_srv_sts; /** Latest service availability */
+static uint8_t g_last_ntfy_sts; /** Receive state of latest notification */
+static uint8_t g_last_num_of_thread; /** Number of Current Startup Threads */
+
+/** Sub-thread creation table */
+static ST_THREAD_CREATE_INFO* g_pos_thread_create_info;
+
+/** Interprocess message receive buffer */
+static uint8_t g_rcv_msg_buf[MAX_MSG_BUF_SIZE];
+
+/** Dispatcher Registration Callback Table */
+static const FrameworkunifiedProtocolCallbackHandler kPositioningPcbhs[] = { // LCOV_EXCL_BR_LINE 11: unexpected branch
+ {CID_THREAD_CREATE_COMP, &PosThreadCreateComp }, /* Thread start completion notification */
+ {CID_THREAD_STOP_COMP, &PosThreadStopComp }, /* Thread stop completion notice */
+ {CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT, &PosPosifRegisterListenerPkgSensorData},
+ {CID_VEHICLEIF_DELIVERY_ENTRY, &PosPosifRegisterListenerSensorData },
+ {CID_SENSORIF__CWORD82__REQUEST, &PosPosifReqGpsSetting },
+ {CID_NAVIINFO_DELIVER, &PosPosifSetGpsInfo },
+ {CID_VEHICLEIF_GET_VEHICLE_DATA, &PosPosifGetGpsInfo },
+ {CID_POSIF_SET_DATA, &PosPosifSetData },
+ {CID_GPS_REQRESET, &PosPosifReqGpsReset },
+};
+
+static const FrameworkunifiedProtocolCallbackHandler kPositioningPcbhsVehicle[] = { // LCOV_EXCL_BR_LINE 11: unexpected branch
+ {CID_VEHICLESENS_VEHICLE_INFO, &PosVehicleInfoRcv},
+};
+
+/** Dispatcher unregister command ID table */
+static uint32_t g_positioning_cids[] = {
+ CID_THREAD_CREATE_COMP,
+ CID_THREAD_STOP_COMP,
+ CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT,
+ CID_VEHICLEIF_DELIVERY_ENTRY,
+ CID_SENSORIF__CWORD82__REQUEST,
+ CID_NAVIINFO_DELIVER,
+ CID_VEHICLEIF_GET_VEHICLE_DATA,
+ CID_POSIF_SET_DATA,
+ CID_GPS_REQRESET,
+};
+
+static uint32_t g_positioning_cids_vehicle[] = {
+ CID_VEHICLESENS_VEHICLE_INFO,
+};
+
+
+
+/** Stop request flag for GPS reception thread */
+BOOL g_thread_stop_req;
+
+/*---------------------------------------------------------------------------------*
+ * Function *
+ *---------------------------------------------------------------------------------*/
+/**
+ * @brief
+ * FrameworkunifiedOnInitialization<br>
+ * Sends message to Notification Service
+ *
+ * Mm 21 API perform initialization.<br>
+ * Generatings shared memories used by Vehicle function block..<br>
+ * Creates a sub-thread of the Vehicle feature block..
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ * eFrameworkunifiedStatusFail ABENDs
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnInitialization(HANDLE h_app) {
+ RET_API ret_api;
+ EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK;
+ uint8_t* p_last_srv_sts = &g_last_srv_sts;
+ uint8_t* p_last_thread_sts = &g_last_thread_sts;
+ uint8_t* p_last_ntfy_sts = &g_last_ntfy_sts;
+ ST_THREAD_CREATE_INFO** pp_thr_cre_info = &g_pos_thread_create_info;
+ uint8_t* p_last_num_thr = &g_last_num_of_thread;
+ BOOL* p_thr_stop_req = &g_thread_stop_req;
+ EnumExeSts_POS* p_exe_sts = &g_exe_sts;
+ EnumSetupMode_POS* pe_mode = &g_setup_mode;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ /* Global variable initialization */
+ *p_last_srv_sts = 0;
+ *p_last_thread_sts = 0;
+ *p_last_ntfy_sts = 0;
+ *pp_thr_cre_info = g_pos_thread_create_info_Grade1;
+ *p_last_num_thr = 0;
+ *p_thr_stop_req = FALSE;
+ *p_exe_sts = EPOS_EXE_STS_STOP;
+ *pe_mode = EPOS_SETUP_MODE_NORMAL;
+
+ /* null check */
+ if (h_app == NULL) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "h_app is NULL");
+ e_status = eFrameworkunifiedStatusFail;
+ } else {
+ /* Positioning Base API initialization */
+ ret_api = _pb_Setup_CWORD64_API(h_app);
+ if (ret_api != RET_NORMAL) { // LCOV_EXCL_BR_LINE 4: can not return error
+ // LCOV_EXCL_START 8: invalid
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "_pb_Setup_CWORD64_API ERROR!! [ret_api = %d]",
+ ret_api);
+
+ e_status = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ } else {
+ /* Availability at Positioning startup,Set internal thread activation state */
+ if (ChkUnitType(UNIT_TYPE_GRADE1) == true) { /* GRADE1 environment */
+ *pp_thr_cre_info = g_pos_thread_create_info_Grade1;
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__,
+ "*pp_thr_cre_info = g_pos_thread_create_info_Grade1");
+ } else if (ChkUnitType(UNIT_TYPE_GRADE2) == true) {
+ /*
+ * Note.
+ * This feature branches processing depending on the unit type.
+ */
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "_pb_ChkUnitType UNKNOWN!!");
+ }
+
+ /* Shared Memory Creation */
+ PosCreateSharedMemory();
+
+ if (e_status == eFrameworkunifiedStatusOK) {
+ /* Register callback functions for Positioning internals */
+ e_status = FrameworkunifiedAttachCallbacksToDispatcher(h_app,
+ "NS_ANY_SRC",
+ kPositioningPcbhs,
+ _countof(kPositioningPcbhs)); // LCOV_EXCL_BR_LINE 4:nsfw error
+ if (e_status != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedAttachCallbacksToDispatcher ERROR!! [e_status = %d]", e_status);
+ }
+
+ (void)VehicleIfAttachCallbacksToDispatcher(kPositioningPcbhsVehicle,
+ _countof(kPositioningPcbhsVehicle));
+ }
+
+ if (e_status == eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ /* Positioning/Availability registration */
+ e_status = FrameworkunifiedRegisterServiceAvailabilityNotification(h_app, POS_AVAILABILITY);
+ if (eFrameworkunifiedStatusOK != e_status) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedRegisterServiceAvailabilityNotification ERROR!! [e_status = %d]", e_status);
+ }
+ }
+
+ if (e_status == eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ /* Positioning/Availability -> FALSE */
+ e_status = FrameworkunifiedPublishServiceAvailability(h_app, FALSE);
+ if (eFrameworkunifiedStatusOK != e_status) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedPublishServiceAvailability ERROR!! [e_status = %d]", e_status);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "Positioning/Availability -> FALSE");
+ }
+ }
+
+ /* Communication/Availability Changing notification registration */
+ FrameworkunifiedSubscribeNotificationWithCallback(h_app, NTFY_Communication_Availability, &PosNotifyCommunicationAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* PS_CommUSB/Availability Changing notification registration */
+ (void)CommUsbIfNotifyOnCommUSBAvailability(&PosNotifyCommUSBAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* PS_PSMShadow/Availability Changing notification registration */
+ (void)PSMShadowIfNotifyOnPSMShadowAvailability(&PosNotifyPSMShadowAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+ /* PS_PSMShadow Startup completion notification registration */
+ (void)PSMShadowIfNotifyOnPSMShadowInitComp(&PosNotifyPSMShadowInitComp); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* Clock/Availability Changing notification registration */
+ (void)ClockIfNotifyOnClockAvailability(&PosNotifyClockAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* NS_BackupMgr/Availability Changing notification registration */
+ (void)BackupMgrIfNotifyOnBackupMgrAvailability(&PosNotifyNSBackupMgrAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* Regist Vehilce Availability Notification */
+ (void)VehicleIfNotifyOnVehicleAvailability(&PosNotifyVehicleAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+
+ /* DeviceDetectionServiceIf initialization */
+ if (DevDetectSrvIfInitialize() == eFrameworkunifiedStatusOK) {
+ /* SS_DevDetectSrv/Availability Changing notification registration */
+ (void)DevDetectSrvIfNotifyOnDeviceDetectionAvailability(&PosNotifyDevDetectSrvAvailability); // LCOV_EXCL_BR_LINE 6: not a branch // NOLINT(whitespace/line_length)
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return e_status;
+}
+
+/**
+ * @brief
+ * PositioningOnStartImpl
+ */
+static EFrameworkunifiedStatus PositioningOnStartImpl(const HANDLE hApp, const EPWR_SC_WAKEUP_TYPE wakeupType,
+ const ESMDataResetModeInfo dataResetMode) {
+ EnumExeSts_POS* p_exe_sts = &g_exe_sts;
+ EnumSetupMode_POS* pe_mode = &g_setup_mode;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ if (g_start_flg == false) {
+ g_start_flg = true;
+
+ /* Running */
+ *p_exe_sts = EPOS_EXE_STS_RUNNING;
+
+ /* Cold start */
+ if (wakeupType == epsstCOLDSTART) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "wakeupType:COLDSTART");
+
+ *p_exe_sts = EPOS_EXE_STS_RUNNING_COLDSTART;
+
+ /* Initialize GPS time setting information */
+ PosBackupDataInit();
+ } else { /* Time of warm start */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "wakeupType:WARMSTART");
+ }
+
+ /* Time of factory initialization */
+ if (dataResetMode == e_SS_SM_DATA_RESET_MODE_FACTORY) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "dataResetMode:FACTORYRESET");
+
+ /* Set thread start mode to ""data reset start"" */
+ *pe_mode = EPOS_SETUP_MODE_DATA_RESET;
+
+ /* Initialize GPS time setting information */
+ PosBackupDataInit();
+ }
+
+ PosCreateThread(hApp);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnStart
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnStart(HANDLE hApp) {
+ EFrameworkunifiedStatus ret = eFrameworkunifiedStatusFail;
+ uint32_t size;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ size = PosGetMsg(hApp, reinterpret_cast<void**>(&g_rcv_msg_buf), MAX_MSG_BUF_SIZE);
+ if (size != 0) {
+ T_SS_SM_START_DataStructType* p_start_data;
+ p_start_data = reinterpret_cast<T_SS_SM_START_DataStructType*>(g_rcv_msg_buf);
+
+ ret = PositioningOnStartImpl(hApp, p_start_data->wakeupType, p_start_data->dataResetMode);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return ret;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnStop
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ * eFrameworkunifiedStatusFail ABENDs
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnStop(HANDLE h_app) {
+ EFrameworkunifiedStatus e_status;
+ EnumExeSts_POS* p_exe_sts = &g_exe_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ /* null check */
+ if (h_app == NULL) { // LCOV_EXCL_BR_LINE 200: can not NULL
+ // LCOV_EXCL_START 8: invalid
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "h_app is NULL");
+ // LCOV_EXCL_STOP
+ } else {
+ *p_exe_sts = EPOS_EXE_STS_STOP;
+
+ e_status = FrameworkunifiedPublishServiceAvailability(h_app, FALSE);
+ if (eFrameworkunifiedStatusOK != e_status) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedPublishServiceAvailability ERROR!! [e_status = %d]",
+ e_status);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "Positioning/Availability -> FALSE");
+ }
+
+ PosStopThread();
+
+ g_start_flg = false;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ /* Return end response to SM at timing after completion of internal thread stop */
+ return eFrameworkunifiedStatusFail;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnPreStart
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnPreStart(HANDLE hApp) {
+ EFrameworkunifiedStatus ret = eFrameworkunifiedStatusFail;
+ uint32_t size;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ size = PosGetMsg(hApp, reinterpret_cast<void**>(&g_rcv_msg_buf), MAX_MSG_BUF_SIZE);
+ if (size != 0) {
+ T_SS_SM_START_DataStructType* p_start_data;
+ p_start_data = reinterpret_cast<T_SS_SM_START_DataStructType*>(g_rcv_msg_buf);
+
+ ret = PositioningOnStartImpl(hApp, p_start_data->wakeupType, p_start_data->dataResetMode);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return ret;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnPreStop
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnPreStop(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnBackgroundStart
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStart(HANDLE hApp) {
+ EFrameworkunifiedStatus ret = eFrameworkunifiedStatusFail;
+ uint32_t size;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ size = PosGetMsg(hApp, reinterpret_cast<void**>(&g_rcv_msg_buf), MAX_MSG_BUF_SIZE);
+ if (size != 0) {
+ T_SS_SM_START_DataStructType* p_start_data;
+ p_start_data = reinterpret_cast<T_SS_SM_START_DataStructType*>(g_rcv_msg_buf);
+
+ ret = PositioningOnStartImpl(hApp, p_start_data->wakeupType, p_start_data->dataResetMode);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return ret;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnBackgroundStop
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStop(HANDLE hApp) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * FrameworkunifiedOnDestroy (Not mounted)
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ * eFrameworkunifiedStatusFail ABENDs
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnDestroy(HANDLE h_app) { // LCOV_EXCL_START 14 Resident process, not called by NSFW
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+/**
+ * @brief
+ * FrameworkunifiedOnDebugDump
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ * eFrameworkunifiedStatusFail ABENDs
+ */
+EFrameworkunifiedStatus FrameworkunifiedOnDebugDump(HANDLE h_app) { // LCOV_EXCL_START 7: debug code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ static uint8_t buf_tmp[256];
+ static uint8_t buf_proc[128];
+ static uint8_t buf_thread[512];
+ static uint8_t buf_message[4][DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_mutex[3][DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_timer[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_event[9][DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_memory[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_other[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_nand[256];
+ static uint8_t buf_ram[256];
+ static uint8_t buf_gps_format_fail[512];
+ static uint8_t buf_antenna[256];
+ static uint8_t buf_gps_info[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_navi_info[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_deli_ctrl_tbl[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_deli_ctrl_tbl_mng[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_pkg_deli_tbl_mng[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_deli_pno_tbl[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t buf_sys[128];
+ int32_t i;
+ ST_THREAD_CREATE_INFO* p_thr_cre_info = g_pos_thread_create_info;
+ ST_GPS_FIX_CNT st_gps_fix_cnt;
+ ST_GPS_SET_TIME st_gps_set_time;
+ uint8_t len_msg = 4;
+ uint8_t len_mtx = 3;
+ uint8_t len_evt = 9;
+ EFrameworkunifiedStatus e_status;
+ BOOL b_is_available;
+ UNIT_TYPE e_type = UNIT_TYPE_NONE;
+ u_int8 sys_recv_flg;
+ uint16_t wkn_rollover;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ memset(&buf_proc[0], 0x00, sizeof(buf_proc));
+ memset(&buf_thread[0], 0x00, sizeof(buf_thread));
+ memset(&buf_nand[0], 0x00, sizeof(buf_nand));
+ memset(&buf_ram[0], 0x00, sizeof(buf_ram));
+ memset(&buf_gps_format_fail[0], 0x00, sizeof(buf_gps_format_fail));
+ memset(&buf_antenna[0], 0x00, sizeof(buf_antenna));
+ memset(&buf_gps_info[0], 0x00, sizeof(buf_gps_info));
+ memset(&buf_navi_info[0], 0x00, sizeof(buf_navi_info));
+ memset(&buf_deli_ctrl_tbl[0], 0x00, sizeof(buf_deli_ctrl_tbl));
+ memset(&buf_deli_ctrl_tbl_mng[0], 0x00, sizeof(buf_deli_ctrl_tbl_mng));
+ memset(&buf_pkg_deli_tbl_mng[0], 0x00, sizeof(buf_pkg_deli_tbl_mng));
+ memset(&buf_deli_pno_tbl[0], 0x00, sizeof(buf_deli_pno_tbl));
+ memset(&buf_sys[0], 0x00, sizeof(buf_sys));
+
+ for (i = 0; i < len_msg; i++) {
+ memset(&buf_message[i][0], 0x00, sizeof(buf_message[i]));
+ }
+ for (i = 0; i < len_mtx; i++) {
+ memset(&buf_mutex[i][0], 0x00, sizeof(buf_mutex[i]));
+ }
+ memset(&buf_timer[0], 0x00, sizeof(buf_timer));
+ for (i = 0; i < len_evt; i++) {
+ memset(&buf_event[i][0], 0x00, sizeof(buf_event[i]));
+ }
+ memset(&buf_memory[0], 0x00, sizeof(buf_memory));
+ memset(&buf_other[0], 0x00, sizeof(buf_other));
+ e_type = GetEnvSupportInfo();
+
+ /* Availability status of related processes */
+ snprintf(reinterpret_cast<char *>(&buf_proc[0]), sizeof(buf_proc),
+ "Availability\n thread:0x%02x, srv:0x%02x, ntfy:0x%02x",
+ g_last_thread_sts, /* Latest internal thread activation state */
+ g_last_srv_sts, /* Latest service availability */
+ g_last_ntfy_sts); /* Receive state of latest notification */
+
+ /* Internal thread activation state */
+ snprintf(reinterpret_cast<char *>(&buf_thread[0]), sizeof(buf_thread), "Thread");
+ for (i = 0; i < ETID_POS_MAX; i++) {
+ memset(&buf_tmp[0], 0x00, sizeof(buf_tmp));
+ snprintf(reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp),
+ "\n [%d]id:%d, pno:0x%04x, name:%16s, sts:0x%02x, order:%d",
+ i,
+ p_thr_cre_info->id, /* Thread ID */
+ p_thr_cre_info->pno, /* Process number */
+ p_thr_cre_info->p_name, /* Thread name */
+ p_thr_cre_info->status, /* Thread activation state */
+ p_thr_cre_info->order); /* Boot Sequence */
+ _pb_strcat(reinterpret_cast<char *>(&buf_thread[0]), reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp));
+ p_thr_cre_info++;
+ }
+
+ /* BASE API control data */
+ /* Message */
+ (void)_pb_GetDebugMsgMngTbl(&buf_message[0][0], &len_msg);
+ /* Mutex */
+ (void)_pb_GetDebugMutexMngTbl(&buf_mutex[0][0], &len_mtx);
+ /* Timer */
+ (void)_pb_GetDebugTimerMngTbl(&buf_timer[0]);
+ /* Event */
+ (void)_pb_GetDebugEventMngTbl(&buf_event[0][0], &len_evt);
+ /* Shared Memory */
+ (void)_pb_GetDebugMemoryMngTbl(&buf_memory[0]);
+ /* Other */
+ (void)_pb_GetDebugOtherMngTbl(&buf_other[0]);
+
+ /* NAND data */
+ snprintf(reinterpret_cast<char *>(&buf_nand[0]), sizeof(buf_nand), "NAND");
+ /* GPS fix count */
+ memset(&buf_tmp[0], 0x00, sizeof(buf_tmp));
+ memset(&st_gps_fix_cnt, 0x00, sizeof(st_gps_fix_cnt));
+
+ e_status = BackupMgrIfBackupDataRd(D_BK_ID_POS_GPS_FIX_CNT,
+ 0,
+ &st_gps_fix_cnt,
+ sizeof(st_gps_fix_cnt), &b_is_available);
+ snprintf(reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp),
+ "\n %20s rd:0x%08x av:%d, 3d:%d, 2d:%d, else:%d, dmy:0x%02x%02x%02x%02x",
+ "GPS_FIX_CNT",
+ e_status,
+ b_is_available,
+ st_gps_fix_cnt.ul3d,
+ st_gps_fix_cnt.ul2d,
+ st_gps_fix_cnt.ul_else,
+ st_gps_fix_cnt.dummy[0], st_gps_fix_cnt.dummy[1], st_gps_fix_cnt.dummy[2], st_gps_fix_cnt.dummy[3]);
+ _pb_strcat(reinterpret_cast<char *>(&buf_nand[0]), reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp));
+
+ /* Data of the backup RAM */
+ snprintf(reinterpret_cast<char *>(&buf_ram[0]), sizeof(buf_ram), "BackupRAM");
+ /* Set GPS date and time(Information) */
+ memset(&buf_tmp[0], 0x00, sizeof(buf_tmp));
+ (void)memset( reinterpret_cast<void *>(&st_gps_set_time), 0, (size_t)sizeof(st_gps_set_time) );
+
+ e_status = BackupMgrIfBackupDataRd(D_BK_ID_POS_GPS_TIME_SET_INFO,
+ 0,
+ &st_gps_set_time,
+ sizeof(st_gps_set_time),
+ &b_is_available);
+ snprintf(reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp),
+ "\n %20s rd:0x%08x av:%d, %d/%d/%d %d:%d:%d flag:0x%02x",
+ "GPS_TIME_SET_INFO",
+ e_status,
+ b_is_available,
+ st_gps_set_time.year,
+ st_gps_set_time.month,
+ st_gps_set_time.date,
+ st_gps_set_time.hour,
+ st_gps_set_time.minute,
+ st_gps_set_time.second,
+ st_gps_set_time.flag);
+ _pb_strcat(reinterpret_cast<char *>(&buf_ram[0]), reinterpret_cast<char *>(&buf_tmp[0]), sizeof(buf_tmp));
+
+ if (e_type == UNIT_TYPE_GRADE1) {
+ /* GPS format anomaly counter */ /* There is no lock control. */
+ (void)DEVGpsGetDebugGpsFormatFailCnt(&buf_gps_format_fail[0]);
+
+ /* GPS antenna connection status */ /* There is no lock control. */
+ VEHICLESENS_DATA_MASTER st_sns_data = {0};
+ (void)VehicleSensGetGpsAntenna(&st_sns_data, VEHICLESENS_GETMETHOD_LINE);
+ snprintf(reinterpret_cast<char *>(&buf_antenna[0]), sizeof(buf_antenna),
+ "Antenna\n sts:0x%02x",
+ st_sns_data.uc_data[0]);
+
+ /* GPS position time */ /* There is no lock control. */
+ (void)VehicleSensGetDebugPosDate(&buf_gps_info[0], VEHICLESENS_GETMETHOD_GPS);
+ }
+
+ if (e_type == UNIT_TYPE_GRADE1) {
+ /* Navigation position time */ /* There is no lock control. */
+ (void)VehicleSensGetDebugPosDate(&buf_navi_info[0], VEHICLESENS_GETMETHOD_NAVI);
+ }
+
+ /* Delivery table */ /* There is no lock control. */
+ (void)VehicleSensGetDebugDeliveryCtrlTbl(&buf_deli_ctrl_tbl[0]);
+ (void)VehicleSensGetDebugDeliveryCtrlTblMng(&buf_deli_ctrl_tbl_mng[0]);
+ (void)VehicleSensGetDebugPkgDeliveryTblMng(&buf_pkg_deli_tbl_mng[0]);
+ (void)VehicleSensGetDebugDeliveryPnoTbl(&buf_deli_pno_tbl[0]);
+
+ /* Initial Sensor Data Status from Sys */
+ sys_recv_flg = LineSensDrvGetSysRecvFlag();
+ snprintf(reinterpret_cast<char *>(&buf_sys[0]), sizeof(buf_sys),
+ "Rx 1st Sensor Data %d\n", sys_recv_flg);
+
+ /* Dump Information Out */
+ PosOutputDebugDumpLog(&buf_proc[0]);
+ PosOutputDebugDumpLog(&buf_thread[0]);
+ for (i = 0; i < len_msg; i++) {
+ PosOutputDebugDumpLog(&buf_message[i][0]);
+ }
+ for (i = 0; i < len_mtx; i++) {
+ PosOutputDebugDumpLog(&buf_mutex[i][0]);
+ }
+ PosOutputDebugDumpLog(&buf_timer[0]);
+ for (i = 0; i < len_evt; i++) {
+ PosOutputDebugDumpLog(&buf_event[i][0]);
+ }
+ PosOutputDebugDumpLog(&buf_memory[0]);
+ PosOutputDebugDumpLog(&buf_other[0]);
+ PosOutputDebugDumpLog(&buf_nand[0]);
+ PosOutputDebugDumpLog(&buf_ram[0]);
+ if (e_type == UNIT_TYPE_GRADE1) {
+ PosOutputDebugDumpLog(&buf_gps_format_fail[0]);
+ PosOutputDebugDumpLog(&buf_antenna[0]);
+ PosOutputDebugDumpLog(&buf_gps_info[0]);
+ }
+ if (e_type == UNIT_TYPE_GRADE1) {
+ PosOutputDebugDumpLog(&buf_navi_info[0]);
+ }
+ PosOutputDebugDumpLog(&buf_deli_ctrl_tbl[0]);
+ PosOutputDebugDumpLog(&buf_deli_ctrl_tbl_mng[0]);
+ PosOutputDebugDumpLog(&buf_pkg_deli_tbl_mng[0]);
+ PosOutputDebugDumpLog(&buf_deli_pno_tbl[0]);
+ PosOutputDebugDumpLog(&buf_sys[0]);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+/**
+ * @brief
+ * FrameworkunifiedCreateStateMachine (Not mounted)
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ * eFrameworkunifiedStatusFail ABENDs
+ */
+EFrameworkunifiedStatus FrameworkunifiedCreateStateMachine(HANDLE h_app) { // LCOV_EXCL_START 8 : dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * @brief
+ * Common processing after thread startup
+ *
+ * Thread naming,Create Message Queue,Thread activation response
+ *
+ * @param[in] h_app Application handle
+ * @param[in] e_tid Thread ID
+ *
+ * @return Thread activation mode
+ */
+EnumSetupMode_POS PosSetupThread(HANDLE h_app, EnumTID_POS e_tid) {
+ RET_API ret;
+ ST_THREAD_CREATE_INFO* p_thr_cre_info = g_pos_thread_create_info;
+ ST_THREAD_CREATE_INFO* p_info;
+ ST_THREAD_SETUP_INFO st_setup_info;
+ ST_THREAD_SETUP_INFO* pst_setup_info = &st_setup_info;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ p_info = p_thr_cre_info + e_tid;
+
+ /* Application handle setting */
+ _pb_SetAppHandle(h_app);
+
+ /* Create Message Queue */
+ _pb_CreateMsg(p_info->pno);
+
+ /* Get Thread Startup Information */
+ pst_setup_info->e_mode = EPOS_SETUP_MODE_NORMAL;
+ (void)PosGetMsg(h_app, reinterpret_cast<void**>(&pst_setup_info), sizeof(ST_THREAD_SETUP_INFO));
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "[e_mode = %d]", pst_setup_info->e_mode);
+
+ /* Issue thread creation completion notice */
+ ret = _pb_SndMsg_Ext(POS_THREAD_NAME, CID_THREAD_CREATE_COMP, sizeof(EnumTID_POS), (const void*)&e_tid, 0);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SndMsg_Ext ERROR!! [ret = %d]", ret);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return pst_setup_info->e_mode;
+}
+
+/**
+ * @brief
+ * Common Processing at Thread Stop
+ *
+ * Thread stop response,Thread destruction
+ *
+ * @param[in] e_tid Thread ID
+ */
+void PosTeardownThread(EnumTID_POS e_tid) {
+ RET_API ret;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ /* Issue thread stop completion notice */
+ ret = _pb_SndMsg_Ext(POS_THREAD_NAME, CID_THREAD_STOP_COMP, sizeof(EnumTID_POS), (const void*)&e_tid, 0);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SndMsg_Ext ERROR!! [ret = %d]", ret);
+ }
+
+ /* Thread destruction */
+ _pb_ExitThread((DWORD)0);
+
+ /* don't arrive here */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ return; // LCOV_EXCL_LINE 8 : cannot reach here
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/**
+ * @brief
+ * FrameworkunifiedCreateChildThread dummy functions
+ *
+ * @param[in] Application handle
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosStopThreadDummy(HANDLE h_app) { // LCOV_EXCL_START 8 : dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+// LCOV_EXCL_STOP
+
+/*---------------------------------------------------------------------------------*
+ * Local Function *
+ *---------------------------------------------------------------------------------*/
+/**
+ * @brief
+ * Communication services Availability notification callback functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosNotifyCommunicationAvailability(HANDLE h_app) {
+ BOOL isAvailable;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+ if (isAvailable == TRUE) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Communication/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_COMMUNICATION_AVAILABILITY;
+
+ PosCreateThread(h_app);
+
+ /* Sensor Log Initial Processing(First)*/
+ SensLogInitialize(NULL);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Communication/Availability -> FALSE");
+
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_COMMUNICATION_AVAILABILITY);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * CommUSB services Availability notification callback functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosNotifyCommUSBAvailability(HANDLE h_app) {
+ BOOL isAvailable;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+ if (isAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PS_CommUSB/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_PS_COMMUSB_AVAILABILITY;
+
+ PosCreateThread(h_app);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PS_CommUSB/Availability -> FALSE");
+
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_PS_COMMUSB_AVAILABILITY);
+ }
+
+ /* Update CommUSB I/F availability */
+ CommUsbIfSetAvailability(isAvailable);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * PSMShadow services Availability notification callback functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosNotifyPSMShadowAvailability(HANDLE h_app) {
+ BOOL isAvailable;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+ if (isAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PS_PSMShadow/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_PS_PSMSHADOW_AVAILABILITY;
+
+ PosCreateThread(h_app);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PS_PSMShadow/Availability -> FALSE");
+
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_PS_PSMSHADOW_AVAILABILITY);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * PSMShadow services Callback function for notifying completion of startup
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosNotifyPSMShadowInitComp(HANDLE h_app) {
+ uint8_t* pLastNtfySts = &g_last_ntfy_sts;
+ ST_THREAD_CREATE_INFO* pThrCreInfo = g_pos_thread_create_info;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ *pLastNtfySts |= NTFY_MSK_PS_PSMSHADOW_INIT_COMP;
+
+ /* When the Pos_Sens thread is started */
+ if (((pThrCreInfo + ETID_POS_SENS)->status) == THREAD_STS_CREATED) {
+ /* External pin status request */
+ LineSensDrvExtTermStsReq();
+ }
+
+ PosCreateThread(h_app);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Clock Services Availability Notification Callback Functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosNotifyClockAvailability(HANDLE h_app) {
+ BOOL isAvailable;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+ if (isAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Clock/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_CLOCK_AVAILABILITY;
+
+ PosCreateThread(h_app);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Clock/Availability -> FALSE");
+
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_CLOCK_AVAILABILITY);
+ }
+
+ /* Update Clock I/F availability */
+ ClockIfSetAvailability(isAvailable);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * NS_BackupMgr service Availability notification callback function
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosNotifyNSBackupMgrAvailability(HANDLE h_app) {
+ EnumExeSts_POS* pExeSts = &g_exe_sts;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+ ST_THREAD_CREATE_INFO* pThrCreInfo = g_pos_thread_create_info;
+ EnumSetupMode_POS* peMode = &g_setup_mode;
+ BOOL bIsAvailable;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ bIsAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+
+ /* Update BackupMgr I/F availability */
+ BackupMgrIfSetAvailability(bIsAvailable);
+
+ if (bIsAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "NS_BackupMgr/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_NS_BACKUPMGR_AVAILABILITY;
+
+ /* Executing after cold start or during factory initialization*/
+ if ((*pExeSts == EPOS_EXE_STS_RUNNING_COLDSTART) ||
+ (*peMode == EPOS_SETUP_MODE_DATA_RESET)) {
+ /* Backup RAM initialization */
+ PosBackupDataInit();
+ }
+
+ /* When the GPS management thread is started */
+ if (((pThrCreInfo + ETID_POS_GPS)->status) == THREAD_STS_CREATED) {
+ if ((*pExeSts == EPOS_EXE_STS_RUNNING_COLDSTART) ||
+ (*peMode == EPOS_SETUP_MODE_DATA_RESET)) {
+ // GPS reset request.
+ SENSOR_INTERNAL_MSG_BUF msg_buf = {};
+ T_APIMSG_MSGBUF_HEADER *msg_hdr = &msg_buf.hdr;
+ msg_hdr->hdr.cid = CID_GPS_REQRESET;
+ msg_hdr->hdr.msgbodysize = sizeof(POS_RESETINFO);
+ POS_RESETINFO *msg_data = reinterpret_cast<POS_RESETINFO *>(&msg_buf.data);
+ msg_data->mode = GPS_RST_COLDSTART;
+
+ RET_API ret = _pb_SndMsg(PNO_NAVI_GPS_MAIN, sizeof(msg_buf), &msg_buf, 0);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "_pb_SndMsg ERROR!! [ret=%d]", ret);
+ }
+ }
+
+ /* Backup data read request to GSP management thread */
+ (void)DEVGpsSndBackupDataLoadReq();
+ }
+ /* Enable Diag Code Writing */
+ DiagSrvIfSetRegistrationPermission(TRUE);
+
+ PosCreateThread(h_app);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "NS_BackupMgr/Availability -> FALSE");
+
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_NS_BACKUPMGR_AVAILABILITY);
+ /* Write prohibited dialog code */
+ DiagSrvIfSetRegistrationPermission(FALSE);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * SS_DevDetectSrv service Availability Callback Functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosNotifyDevDetectSrvAvailability(HANDLE h_app) {
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ BOOL isAvailable;
+ BOOL bDummy;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+
+ /* Update DevDetectSrv I/F availability */
+ DevDetectSrvIfSetAvailability(isAvailable);
+
+ if (isAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "SS_DevDetectSrv/Availability -> TRUE");
+ *pLastSrvSts |= NTFY_MSK_SS_DEVDETSRV_AVAILABILITY;
+
+ eStatus = DevDetectSrvIfOpenSessionRequest(&bDummy);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf OpenSession ERROR!! [eStatus = %d]", eStatus);
+ } else {
+ eStatus = DevDetectSrvIfNotifyOnOpenSessionAck(&PosOnDevDetectOpenSessionAck, &bDummy);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf NotifyOnOpenSessionAck ERROR!! [eStatus = %d]", eStatus);
+ }
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "SS_DevDetectSrv/Availability -> FALSE");
+ *pLastSrvSts = static_cast<uint8_t>(*pLastSrvSts & ~NTFY_MSK_SS_DEVDETSRV_AVAILABILITY);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+
+/**
+ * @brief
+ * Vehicle Availability notification callback functions
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ *
+ */
+static EFrameworkunifiedStatus PosNotifyVehicleAvailability(HANDLE h_app) {
+ BOOL isAvailable;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ isAvailable = FrameworkunifiedIsServiceAvailable(h_app);
+
+ /* Update Vechile I/F Abailability */
+ VehicleIf_SetAvailability(isAvailable);
+
+ if (isAvailable == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Vehicle/Availability -> TRUE");
+
+ *pLastSrvSts |= NTFY_MSK_VS_VEHICLE_AVAILABILITY;
+
+ if (eFrameworkunifiedStatusFail == VehicleIfDeliveryEntry(VEHICLE_DID_SPEED)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleIfDeliveryEntry SPEED ERROR");
+ }
+
+ if (eFrameworkunifiedStatusFail == VehicleIfDeliveryEntry(VEHICLE_DID_REV)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleIfDeliveryEntry REV ERROR");
+ }
+
+ if (eFrameworkunifiedStatusFail == VehicleIfDeliveryEntry(VEHICLE_DID_SPEED_PULSE_VEHICLE)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleIfDeliveryEntry SPEED PULSE ERROR");
+ }
+
+ PosCreateThread(h_app);
+
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Vehicle/Availability -> FALSE");
+
+ *pLastSrvSts &= ~NTFY_MSK_VS_VEHICLE_AVAILABILITY;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Shared Memory Creation for Positioning Function
+ *
+ * @return RET_NORMAL Normal completion
+ * RET_ERROR ABENDs
+ */
+static void PosCreateSharedMemory(void) {
+ RET_API ret_api = RET_NORMAL;
+ void *mod_exec_dmy; /* Module data pointer(dummy) */
+ int retry; /* Retry counter */
+ ST_SHAREDATA *p_shm_tbl;
+
+ /* Configure Shared Data Generating Tables */
+ p_shm_tbl = g_sharedata_tbl;
+
+ while ( *(p_shm_tbl->share_data_name) != '\0' ) {
+ for ( retry = 0; retry < DATMOD_RETRY; retry++ ) {
+ /* Shared Memory Generation */
+ ret_api = _pb_CreateShareData(p_shm_tbl->share_data_name, p_shm_tbl->data_size, &mod_exec_dmy);
+ if (ret_api == RET_NORMAL) { /* If successful */
+ /* Set the shared memory status flag to ""Before initialization (0)"" */
+ *reinterpret_cast<u_int32 *>(mod_exec_dmy) = DATMOD_PREINIT;
+
+ break;
+ } else { /* In the event of failure */
+ /* Error Handling */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "_pb_CreateShareData ERROR [ret_api:%d]",
+ ret_api);
+ }
+ }
+
+ if (retry >= DATMOD_RETRY) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_CreateShareData failed more %d times.",
+ DATMOD_RETRY);
+
+ _pb_Exit();
+ /* don't arrive here. */
+ }
+
+ /* Next shared memory generation */
+ p_shm_tbl++;
+ }
+
+ return;
+}
+
+/**
+ * @brief
+ * Positioning in-process thread creation
+ *
+ * @param[in] hApp application handles
+ */
+static void PosCreateThread(HANDLE h_app) {
+ HANDLE threadHandle;
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ EnumSetupMode_POS* peMode = &g_setup_mode;
+ int32_t i;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+ uint8_t* pLastThreadSts = &g_last_thread_sts;
+ uint8_t* pLastNtfySts = &g_last_ntfy_sts;
+ EnumExeSts_POS* pExeSts = &g_exe_sts;
+ ST_THREAD_CREATE_INFO* pThrCreInfo = g_pos_thread_create_info;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ for (i = 0; i < ETID_POS_MAX; i++) {
+ if ((pThrCreInfo->status == THREAD_STS_NOEXIST) && (pThrCreInfo->routine != NULL)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__,
+ "i=%d, mskThread=0x%02x, *pLastThreadSts=0x%02x,"\
+ "mskAvailable=0x%02x, *pLastSrvSts=0x%02x, mskNtfy=0x%02x, *pLastNtfySts=0x%02x",
+ i,
+ pThrCreInfo->msk_thread,
+ *pLastThreadSts,
+ pThrCreInfo->msk_available,
+ *pLastSrvSts,
+ pThrCreInfo->msk_ntfy,
+ *pLastNtfySts);
+
+ if ((*pExeSts != EPOS_EXE_STS_STOP)
+ && ((((pThrCreInfo->msk_thread) & (*pLastThreadSts)) == pThrCreInfo->msk_thread)
+ || (pThrCreInfo->msk_thread == 0))
+ && ((((pThrCreInfo->msk_available) & (*pLastSrvSts)) == pThrCreInfo->msk_available)
+ || (pThrCreInfo->msk_available == NTFY_MSK_NONE))
+ && ((((pThrCreInfo->msk_ntfy) & (*pLastNtfySts)) == pThrCreInfo->msk_ntfy)
+ || (pThrCreInfo->msk_ntfy == NTFY_MSK_NONE))) {
+ if (pThrCreInfo->pno == PNO_LINE_SENS_DRV || \
+ pThrCreInfo->pno == PNO_NAVI_GPS_MAIN || \
+ pThrCreInfo->pno == PNO_NAVI_GPS_RCV ||
+ pThrCreInfo->pno == PNO_CLK_GPS) {
+ (pThrCreInfo->routine)(h_app);
+ } else {
+ /* Thread creation */
+ threadHandle = FrameworkunifiedCreateChildThread(h_app,
+ (PCSTR)(pThrCreInfo->p_name),
+ pThrCreInfo->routine,
+ &PosStopThreadDummy);
+ if (threadHandle == NULL) { /* If the thread creation fails */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedCreateChildThread ERROR!! [tHandle=%p]",
+ threadHandle);
+ _pb_Exit();
+ /* don't arrive here. */
+ } else {
+ /* Thread activation (Notify the startup mode) */
+ eStatus = FrameworkunifiedStartChildThread(h_app,
+ threadHandle,
+ sizeof(EnumSetupMode_POS),
+ reinterpret_cast<void*>(peMode));
+ if (eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedStartChildThread ERROR!! [eStatus=%d, name=%s]",
+ eStatus,
+ pThrCreInfo->p_name);
+ } else {
+ pThrCreInfo->status = THREAD_STS_CREATING;
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "name=%s", pThrCreInfo->p_name);
+ }
+ }
+ }
+ }
+ }
+
+ pThrCreInfo++;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return;
+}
+
+
+/**
+ * @brief
+ * Termination of Positioning in-process threads
+ */
+static void PosStopThread(void) {
+ RET_API ret;
+ ST_THREAD_CREATE_INFO* p_thr_cre_info = g_pos_thread_create_info;
+ BOOL *p_thr_stop_req = &g_thread_stop_req;
+ uint8_t uc_msg = 0;
+ uint8_t uc_order = 0;
+ PNO us_pno = 0;
+ int32_t i;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ for (i = 0; i < ETID_POS_MAX; i++) {
+ if (uc_order < p_thr_cre_info->order) {
+ uc_order = p_thr_cre_info->order;
+ us_pno = p_thr_cre_info->pno;
+ }
+ p_thr_cre_info++;
+ }
+
+ if (uc_order != 0) {
+ /* Send Thread Termination Request */
+ if (us_pno == PNO_NAVI_GPS_RCV) {
+ /* Pos_gps_recv Only thread flag control */
+ *p_thr_stop_req = TRUE;
+ } else {
+ ret = PosSndMsg(us_pno, CID_THREAD_STOP_REQ, &uc_msg, sizeof(uc_msg));
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "PosSndMsg ERROR!! [ret = %d]",
+ ret);
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return;
+}
+
+/**
+ * @brief
+ * Backup RAM initialization
+ */
+static void PosBackupDataInit(void) {
+ UNIT_TYPE e_type = UNIT_TYPE_NONE;
+ EFrameworkunifiedStatus e_status;
+ BOOL b_is_available;
+ ST_GPS_SET_TIME st_gps_set_time;
+
+ (void)memset( reinterpret_cast<void *>(&st_gps_set_time), 0, (size_t)sizeof(st_gps_set_time) );
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ e_type = GetEnvSupportInfo();
+ if (e_type == UNIT_TYPE_GRADE1) {
+ /* Set GPS date and time */
+ e_status = BackupMgrIfBackupDataWt(D_BK_ID_POS_GPS_TIME_SET_INFO,
+ &st_gps_set_time,
+ 0,
+ sizeof(st_gps_set_time),
+ &b_is_available);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "D_BK_ID_POS_GPS_TIME_SET_INFO:W:Clear");
+ if (e_status != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "BackupMgrIfBackupDataWt ERROR!! [e_status=%d, b_is_available=%d]",
+ e_status,
+ b_is_available);
+ }
+ } else if (e_type == UNIT_TYPE_GRADE2) {
+ /*
+ * Note.
+ * This feature branches processing depending on the unit type.
+ */
+ } else {
+ /* No processing */
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher()
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosThreadCreateComp(HANDLE h_app) {
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ uint8_t* pLastThreadSts = &g_last_thread_sts;
+ ST_THREAD_CREATE_INFO* pThrCreInfo = g_pos_thread_create_info;
+ uint8_t* pLastNumThr = &g_last_num_of_thread;
+ uint8_t* pLastSrvSts = &g_last_srv_sts;
+ uint8_t* pLastNtfySts = &g_last_ntfy_sts;
+ EnumTID_POS eTid;
+ int32_t i;
+ static BOOL isSetAvailable = FALSE;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ (*pLastNumThr)++;
+
+ eTid = *(reinterpret_cast<EnumTID_POS*>(pRcvMsg));
+
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X]",
+ (pThrCreInfo + eTid)->p_name,
+ CID_THREAD_CREATE_COMP);
+
+ /* Thread Management Variable Updates */
+ *pLastThreadSts = static_cast<uint8_t>(*pLastThreadSts | (0x1u << eTid));
+ (pThrCreInfo + eTid)->status = THREAD_STS_CREATED;
+ (pThrCreInfo + eTid)->order = *pLastNumThr;
+
+ /* Individual processing of started threads */
+ switch (eTid) {
+ case ETID_POS_SENS: /* When sensor driver thread startup is completed */
+ {
+ /* When PSMShadow startup completion notice has been received */
+ if (((NTFY_MSK_PS_PSMSHADOW_INIT_COMP) & (*pLastNtfySts)) == NTFY_MSK_PS_PSMSHADOW_INIT_COMP) {
+ /* External pin status request */
+ LineSensDrvExtTermStsReq();
+ }
+ break;
+ }
+ case ETID_POS_GPS: /* When the GPS management thread has started */
+ {
+ /* NSBackupMgr/Availability=When TRUE notification has been received */
+ if (((NTFY_MSK_NS_BACKUPMGR_AVAILABILITY) & (*pLastSrvSts)) == NTFY_MSK_NS_BACKUPMGR_AVAILABILITY) {
+ /* Backup data read request to GSP management thread */
+ (void)DEVGpsSndBackupDataLoadReq();
+ }
+ break;
+ }
+ default: /* Other thread startup completion time */
+ break;
+ }
+
+ PosCreateThread(h_app);
+
+ for (i = 0; i < ETID_POS_MAX; i++) {
+ if ((pThrCreInfo->is_depended == TRUE) && (pThrCreInfo->status != THREAD_STS_CREATED)) {
+ break; /* Positioning/Availability->TRUE condition does not meet */
+ }
+ pThrCreInfo++;
+ }
+
+ if ((i == ETID_POS_MAX) && (isSetAvailable == FALSE)) {
+ /* Positionig/Availability -> TRUE */
+ eStatus = FrameworkunifiedPublishServiceAvailability(h_app, TRUE);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedPublishServiceAvailability ERROR!! [eStatus = %d]",
+ eStatus);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "Positioning/Availability -> TRUE");
+ isSetAvailable = TRUE;
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher()
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosThreadStopComp(HANDLE h_app) {
+ EFrameworkunifiedStatus eStatus;
+ BOOL bIsAvailable;
+
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ uint8_t* pLastThreadSts = &g_last_thread_sts;
+ ST_THREAD_CREATE_INFO* pThrCreInfo = g_pos_thread_create_info;
+ uint8_t* pLastNumThr = &g_last_num_of_thread;
+ BOOL *pThrStopReq = &g_thread_stop_req;
+ EnumTID_POS eTid;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ (*pLastNumThr)--;
+
+ eTid = *(reinterpret_cast<EnumTID_POS*>(pRcvMsg));
+
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X]",
+ (pThrCreInfo + eTid)->p_name,
+ CID_THREAD_STOP_COMP);
+
+ *pLastThreadSts = static_cast<uint8_t>(*pLastThreadSts & ~(0x1u << eTid));
+
+ (pThrCreInfo + eTid)->status = THREAD_STS_NOEXIST;
+ (pThrCreInfo + eTid)->order = 0;
+
+ if ((pThrCreInfo + eTid)->pno == PNO_NAVI_GPS_RCV) {
+ *pThrStopReq = FALSE;
+ }
+ }
+
+ PosStopThread();
+
+ /* When all threads have stopped */
+ if (*pLastThreadSts == 0) {
+ /* Unregister callback function */
+ eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(h_app,
+ "NS_ANY_SRC",
+ (const PUI_32)g_positioning_cids,
+ _countof(g_positioning_cids), NULL);
+ if (eStatus != eFrameworkunifiedStatusOK) { /* In the event of failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "PositioningDetachCallbacksToDispatcher Failed in FrameworkunifiedOnStop [eStatus:%d]",
+ eStatus);
+ }
+
+ /* Sensor log stop processing */
+ SensLogTerminate();
+
+ /* DeviceDetectionServiceIf termination process */
+ eStatus = DevDetectSrvIfUnRegisterForDeviceDetectionEvent(SS_DEV_DETECT_ANY_USB_EV, &bIsAvailable);
+ if (eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf UnRegisterEvent ERROR!! [sts:%d, ava:%d]",
+ eStatus,
+ bIsAvailable);
+ } else {
+ eStatus = DevDetectSrvIfCloseSessionRequest(&bIsAvailable);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf CloseSession ERROR!! [sts=%d, ava:%d]",
+ eStatus,
+ bIsAvailable);
+ }
+ }
+
+ (void)VehicleIfDetachCallbacksFromDispatcher((const PUI_32)g_positioning_cids_vehicle,
+ _countof(g_positioning_cids_vehicle));
+
+ /* Releasing Base API Resources */
+ _pb_Teardown_CWORD64_API();
+
+ /* Stop processing completion response */
+ SendInterfaceunifiedOnStopResponseToSystemManager(eFrameworkunifiedStatusOK);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(POS_RegisterListenerPkgSensData)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifRegisterListenerPkgSensorData(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ EventID ulEventId;
+ PCSTR pName;
+ static const PCSTR pNone = "-";
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ pName = _pb_CnvPno2Name((reinterpret_cast<SENSOR_MSG_DELIVERY_ENTRY_DAT*>(pRcvMsg))->pno);
+ if (pName == NULL) {
+ pName = pNone;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X",
+ pName,
+ CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT);
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ /* Event Generation */
+ ulEventId = PosCreateEvent((reinterpret_cast<SENSOR_MSG_DELIVERY_ENTRY_DAT*>(pRcvMsg))->pno);
+ if (ulEventId != 0) {
+ /* Event publishing */
+ ret = _pb_SetEvent(ulEventId, SAPI_EVSET_ABSOLUTE, SENSOR_RET_ERROR_INNER);
+ if (ret != RET_NORMAL) {
+ /* Event issuance failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent ERROR!! [ret = %d]", ret);
+ }
+ /* Event deletion */
+ (void)PosDeleteEvent(ulEventId);
+ } else {
+ /* Event generation failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosCreateEvent ERROR!!");
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(POS_RegisterListenerSensData)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifRegisterListenerSensorData(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ EventID ulEventId;
+ PCSTR pName;
+ static const PCSTR pNone = "-";
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ pName = _pb_CnvPno2Name((reinterpret_cast<VEHICLE_MSG_DELIVERY_ENTRY_DAT*>(pRcvMsg))->pno);
+ if (pName == NULL) {
+ pName = pNone;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X]",
+ pName,
+ CID_VEHICLEIF_DELIVERY_ENTRY);
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_VEHICLEIF_DELIVERY_ENTRY, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ /* Event Generation */
+ ulEventId = VehicleCreateEvent((reinterpret_cast<VEHICLE_MSG_DELIVERY_ENTRY_DAT*>(pRcvMsg))->pno);
+ if (ulEventId != 0) {
+ /* Event publishing */
+ ret = _pb_SetEvent(ulEventId, SAPI_EVSET_ABSOLUTE, SENSOR_RET_ERROR_INNER);
+ if (ret != RET_NORMAL) {
+ /* Event issuance failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent ERROR!! [ret = %d]", ret);
+ }
+ /* Event deletion */
+ (void)VehicleDeleteEvent(ulEventId);
+ } else {
+ /* Event generation failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleCreateEvent ERROR!!");
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(POS_ReqGPSSetting)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifReqGpsSetting(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ uint8_t ucResult = SENSLOG_RES_FAIL;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:-][CID:0x%X]",
+ CID_SENSORIF__CWORD82__REQUEST);
+ ucResult = SENSLOG_RES_SUCCESS;
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_SENSORIF__CWORD82__REQUEST, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ }
+ }
+
+ SensLogWriteInputData(SENSLOG_DATA_I_GPSSET, 0, 0, pRcvMsg, static_cast<uint16_t>(size),
+ ucResult, SENSLOG_ON, SENSLOG_ON);
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(POS_SetGPSInfo)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifSetGpsInfo(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ uint8_t ucResult = SENSLOG_RES_FAIL;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:-][CID:0x%X]",
+ CID_NAVIINFO_DELIVER);
+ ucResult = SENSLOG_RES_SUCCESS;
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_NAVI_GPS_MAIN, CID_NAVIINFO_DELIVER, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ }
+ }
+ SensLogWriteInputData(SENSLOG_DATA_I_GPSINF, 0, 0, pRcvMsg, static_cast<uint16_t>(size),
+ ucResult, SENSLOG_ON, SENSLOG_ON);
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(POS_GetGPSInfo)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifGetGpsInfo(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ EventID ulEventId;
+ PCSTR pName;
+ static const PCSTR pNone = "-";
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ pName = _pb_CnvPno2Name((reinterpret_cast<VEHICLE_MSG_GET_VEHICLE_DATA_DAT*>(pRcvMsg))->pno);
+ if (pName == NULL) {
+ pName = pNone;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X]",
+ pName,
+ CID_VEHICLEIF_GET_VEHICLE_DATA);
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_VEHICLEIF_GET_VEHICLE_DATA, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ /* Event Generation */
+ ulEventId = VehicleCreateEvent((reinterpret_cast<VEHICLE_MSG_GET_VEHICLE_DATA_DAT*>(pRcvMsg))->pno);
+ if (ulEventId != 0) {
+ /* Event publishing */
+ ret = _pb_SetEvent(ulEventId, SAPI_EVSET_ABSOLUTE, POS_RET_ERROR_INNER);
+ if (ret != RET_NORMAL) {
+ /* Event issuance failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "_pb_SetEvent ERROR!! [ret = %d]",
+ ret);
+ }
+ /* Event deletion */
+ (void)VehicleDeleteEvent(ulEventId);
+ } else {
+ /* Event generation failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleCreateEvent ERROR!!");
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(CID_POSIF_SET_DATA)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifSetData(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ EventID ulEventId;
+ PCSTR pName;
+ static const PCSTR pNone = "-";
+ uint8_t ucResult = SENSLOG_RES_FAIL;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ ucResult = SENSLOG_RES_SUCCESS;
+
+ pName = _pb_CnvPno2Name((reinterpret_cast<POS_MSGINFO*>(pRcvMsg))->pno);
+ if (pName == NULL) {
+ pName = pNone;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X][DID:0x%X]",
+ pName,
+ CID_POSIF_SET_DATA,
+ (reinterpret_cast<POS_MSGINFO*>(pRcvMsg))->did);
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_POSIF_SET_DATA, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ if ((reinterpret_cast<POS_MSGINFO*>(pRcvMsg))->did == VEHICLE_DID_SETTINGTIME) {
+ /* GPS time setting(When waiting for completion of an event, an event is issued. */
+ /* Event Generation */
+ ulEventId = VehicleCreateEvent((reinterpret_cast<POS_MSGINFO*>(pRcvMsg))->pno);
+ if (ulEventId != 0) {
+ /* Event publishing */
+ ret = _pb_SetEvent(ulEventId, SAPI_EVSET_ABSOLUTE, POS_RET_ERROR_INNER);
+ if (ret != RET_NORMAL) {
+ /* Event issuance failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "_pb_SetEvent ERROR!! [ret = %d]",
+ ret);
+ }
+ /* Event deletion */
+ (void)VehicleDeleteEvent(ulEventId);
+ } else {
+ /* Event generation failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleCreateEvent ERROR!!");
+ }
+ }
+ }
+ }
+ SensLogWriteInputData(SENSLOG_DATA_I_UNSPECIFIED,
+ (reinterpret_cast<POS_MSGINFO*>(pRcvMsg))->did,
+ 0,
+ pRcvMsg,
+ static_cast<uint16_t>(size),
+ ucResult,
+ SENSLOG_ON,
+ SENSLOG_ON);
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(CID_GPS_REQRESET)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosPosifReqGpsReset(HANDLE h_app) {
+ RET_API ret;
+ uint8_t* pRcvMsg;
+ uint32_t size;
+ EventID ulEventId;
+ PCSTR pName;
+ static const PCSTR pNone = "-";
+ uint8_t ucResult = SENSLOG_RES_FAIL;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "+");
+
+ pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ ucResult = SENSLOG_RES_SUCCESS;
+
+ pName = _pb_CnvPno2Name((reinterpret_cast<POS_RESETINFO*>(pRcvMsg))->snd_pno);
+ if (pName == NULL) {
+ pName = pNone;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_17, __FUNCTION__,
+ "Get message = [Sender:%s][CID:0x%X]",
+ pName,
+ CID_GPS_REQRESET);
+
+ /* Send Messages to Internal Thread */
+ ret = PosSndMsg(PNO_NAVI_GPS_MAIN, CID_GPS_REQRESET, pRcvMsg, size);
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+
+ /* Event Generation */
+ ulEventId = VehicleCreateEvent((reinterpret_cast<POS_RESETINFO*>(pRcvMsg))->snd_pno);
+ if (0 != ulEventId) {
+ /* Event publishing */
+ ret = _pb_SetEvent(ulEventId, SAPI_EVSET_ABSOLUTE, POS_RET_ERROR_INNER);
+ if (ret != RET_NORMAL) {
+ /* Event issuance failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "_pb_SetEvent ERROR!! [ret = %d]",
+ ret);
+ }
+ /* Event deletion */
+ (void)VehicleDeleteEvent(ulEventId);
+ } else {
+ /* Event generation failure */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleCreateEvent ERROR!!");
+ }
+ }
+ }
+
+ SensLogWriteInputData(SENSLOG_DATA_I_GPSRST, 0, 0, pRcvMsg, static_cast<uint16_t>(size),
+ ucResult, SENSLOG_ON, SENSLOG_ON);
+ FRAMEWORKUNIFIEDLOG(ZONE_28, __FUNCTION__, "-");
+
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Callback function for registering the dispatcher(CID_VEHICLESENS_VEHICLE_INFO)
+ *
+ * Send a message to an internal thread.
+ *
+ * @param[in] h_app Application handle
+ *
+ * @return eFrameworkunifiedStatusOK Normal completion
+ */
+static EFrameworkunifiedStatus PosVehicleInfoRcv(HANDLE h_app) {
+ LSDRV_MSG_LSDATA_DAT_G line_sns_data;
+ RET_API ret = RET_NORMAL;
+
+ memset(&line_sns_data, 0, sizeof(line_sns_data));
+ LSDRV_MSG_LSDATA_DAT_G *p_line_sns_data = &line_sns_data;
+ VEHICLE_UNIT_MSG_VSINFO *p_vehicle_msg = NULL;
+ uint32_t size = 0;
+ uint16_t us_speed = 0;
+
+ uint8_t* pRcvMsg = g_rcv_msg_buf;
+
+ size = PosGetMsg(h_app, reinterpret_cast<void**>(&pRcvMsg), MAX_MSG_BUF_SIZE);
+ if (size != 0) { // LCOV_EXCL_BR_LINE 4: nsfw error
+ memset(p_line_sns_data, 0x00, sizeof(line_sns_data));
+ p_vehicle_msg = (reinterpret_cast<VEHICLE_UNIT_MSG_VSINFO*>(pRcvMsg));
+ switch (p_vehicle_msg->data.did) {
+ // SPEED info
+ case VEHICLE_DID_SPEED:
+ {
+ p_line_sns_data->uc_data_num = LSDRV_KINDS_MAX;
+ p_line_sns_data->st_data[LSDRV_SPEED_KMPH].ul_did = POSHAL_DID_SPEED_KMPH;
+ p_line_sns_data->st_data[LSDRV_SPEED_KMPH].uc_size = POS_SNDMSG_DTSIZE_2;
+ p_line_sns_data->st_data[LSDRV_SPEED_KMPH].uc_sns_cnt = 0;
+
+ char p_env_variable[VP_MAX_LENGTH];
+
+ VP_GetEnv("VP__CWORD31__SPEED", p_env_variable);
+ if (0 == strcmp(p_env_variable, "direct")) {
+ int16_t speed = 0;
+ // To obtain the vehicle speed from Direct lanes,1 to 2 bytes of received data
+ memcpy(&speed, &p_vehicle_msg->data.data[0], sizeof(speed));
+ us_speed = static_cast<uint16_t>(abs(speed));
+ // Unit conversion [km/h] -> [0.01km/h]
+ us_speed = static_cast<uint16_t>(us_speed * 100);
+ } else if (0 == strcmp(p_env_variable, "CAN")) {
+ UINT16 speed = 0;
+ // To obtain the vehicle speed from CAN,2 to 3 bytes of received data
+ memcpy(&speed, &p_vehicle_msg->data.data[1], sizeof(speed));
+ us_speed = static_cast<uint16_t>(abs(speed));
+ // Unit conversion [km/h] -> [0.01km/h]
+ us_speed = static_cast<uint16_t>(us_speed * 100);
+ } else {
+ // In case of invalid value, the vehicle speed is acquired by CAN.
+ UINT16 speed = 0;
+ memcpy(&speed, &p_vehicle_msg->data.data[1], sizeof(speed));
+ us_speed = static_cast<uint16_t>(abs(speed));
+ // Unit conversion [km/h] -> [0.01km/h]
+ us_speed = static_cast<uint16_t>(us_speed * 100);
+ }
+
+ memcpy(&p_line_sns_data->st_data[LSDRV_SPEED_KMPH].uc_data[0], &us_speed, sizeof(us_speed));
+
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_LINESENS_VEHICLE_DATA_G,
+ reinterpret_cast<void*>(p_line_sns_data), sizeof(line_sns_data));
+
+ break;
+ }
+ // REV information
+ case VEHICLE_DID_REV:
+ {
+ p_line_sns_data->uc_data_num = LSDRV_KINDS_MAX;
+ p_line_sns_data->st_data[LSDRV_REV].ul_did = VEHICLE_DID_REV;
+ p_line_sns_data->st_data[LSDRV_REV].uc_size = POS_SNDMSG_DTSIZE_1;
+ p_line_sns_data->st_data[LSDRV_REV].uc_sns_cnt = 0;
+ p_line_sns_data->st_data[LSDRV_REV].uc_data[0] = p_vehicle_msg->data.data[0];
+
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_LINESENS_VEHICLE_DATA_G,
+ reinterpret_cast<void*>(p_line_sns_data), sizeof(line_sns_data));
+ break;
+ }
+
+ // Speed Pulse information
+ case VEHICLE_DID_SPEED_PULSE_VEHICLE:
+ {
+ p_line_sns_data->uc_data_num = LSDRV_KINDS_MAX;
+ p_line_sns_data->st_data[LSDRV_SPEED_PULSE].ul_did = POSHAL_DID_SPEED_PULSE;
+ p_line_sns_data->st_data[LSDRV_SPEED_PULSE].uc_size = sizeof(float);
+ p_line_sns_data->st_data[LSDRV_SPEED_PULSE].uc_sns_cnt = 0;
+
+ memcpy(&p_line_sns_data->st_data[LSDRV_SPEED_PULSE].uc_data[0],
+ &p_vehicle_msg->data.data[0], sizeof(float));
+
+ p_line_sns_data->st_data[LSDRV_PULSE_TIME].ul_did = POSHAL_DID_PULSE_TIME;
+ p_line_sns_data->st_data[LSDRV_PULSE_TIME].uc_size = sizeof(float);
+ p_line_sns_data->st_data[LSDRV_PULSE_TIME].uc_sns_cnt = 0;
+
+ memcpy(&p_line_sns_data->st_data[LSDRV_PULSE_TIME].uc_data[0],
+ &p_vehicle_msg->data.data[sizeof(float)], sizeof(float));
+
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR, CID_LINESENS_VEHICLE_DATA_G,
+ reinterpret_cast<void*>(p_line_sns_data), sizeof(line_sns_data));
+
+ break;
+ }
+ default:
+ break;
+ }
+
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PosSndMsg ERROR!! [ret = %d]", ret);
+ }
+ }
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * Get Message
+ *
+ * Get messages received by the dispatcher
+ *
+ * @param[in] h_app Application handle
+ * @param[out] p_buf Pointer to receive data storage buffer
+ * @param[in] Sizes of size receive data storage buffers
+ *
+ * @return Received data size(0:Receiving error)
+ */
+static uint32_t PosGetMsg(HANDLE h_app, void** p_buf, uint32_t size) {
+ EFrameworkunifiedStatus eStatus;
+ uint32_t ulSize = 0;
+ void* pRcvBuf;
+
+ /* null check */
+ if ((h_app == NULL) || (p_buf == NULL)) { // LCOV_EXCL_BR_LINE 200: can not NULL
+ // LCOV_EXCL_START 8: invalid
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Argument ERROR!! [h_app = %p, p_buf = %p]",
+ h_app,
+ p_buf);
+ // LCOV_EXCL_STOP
+ } else {
+ /* Check the size of received data */
+ ulSize = FrameworkunifiedGetMsgLength(h_app);
+ if (ulSize > size) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Message size ERROR!! [ulSize = %d, maxsize = %d]",
+ ulSize,
+ size);
+ ulSize = 0;
+ } else {
+ /* Obtain data */
+ eStatus = FrameworkunifiedGetDataPointer(h_app, &pRcvBuf);
+ if (eStatus == eFrameworkunifiedStatusOK) {
+ *p_buf = pRcvBuf;
+ } else if (eStatus == eFrameworkunifiedStatusInvldBufSize) {
+ eStatus = FrameworkunifiedGetMsgDataOfSize(h_app, *p_buf, ulSize);
+ /* When acquisition fails */
+ if (eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedGetMsgDataOfSize ERROR [eStatus:%d]",
+ eStatus);
+ ulSize = 0;
+ }
+ } else {
+ /* When acquisition fails */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedGetDataPointer ERROR [eStatus:%d]",
+ eStatus);
+ ulSize = 0;
+ }
+ }
+ }
+
+ return ulSize;
+}
+
+/**
+ * @brief
+ * Sending Messages for Internal Threads
+ *
+ * Adds a header to the message received by the dispatcher and sends it to the internal thread..
+ *
+ * @param[in] pno PNO
+ * @param[in] cid Command ID
+ * @param[in] p_msg_body Sent message body
+ * @param[in] size Send message size
+ *
+ * @return RET_NORAML Normal completion
+ * RET_ERROR ABENDs
+ */
+static RET_API PosSndMsg(PNO pno, CID cid, void* p_msg_body, uint32_t size) {
+ RET_API ret = RET_NORMAL;
+ T_APIMSG_MSGBUF_HEADER* p;
+ static u_int8 sndMsgBuf[MAX_MSG_BUF_SIZE + sizeof(T_APIMSG_MSGBUF_HEADER)];
+
+ if ((p_msg_body == NULL) || (size > MAX_MSG_BUF_SIZE)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Argument ERROR!! [p_msg_body = %p, size = %d]", p_msg_body, size);
+ ret = RET_ERROR;
+ } else {
+ p = reinterpret_cast<T_APIMSG_MSGBUF_HEADER*>(sndMsgBuf);
+
+ /* Message header addition */
+ p->hdr.cid = cid;
+ p->hdr.msgbodysize = static_cast<uint16_t>(size);
+
+ /* Copy of the data section */
+ memcpy((p + 1), p_msg_body, size);
+
+ /* Send a message to an internal thread */
+ ret = _pb_SndMsg(pno, static_cast<uint16_t>(size + sizeof(T_APIMSG_MSGBUF_HEADER)), p, 0);
+ /* When transmission fails */
+ if (ret != RET_NORMAL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SndMsg ERROR [ret = %d]", ret);
+ ret = RET_ERROR;
+ }
+ }
+
+ return ret;
+}
+
+/**
+ * @brief
+ * SS_DevDetectSrv service OpenSessionAck Callback Functions
+ *
+ * @param none
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosOnDevDetectOpenSessionAck(HANDLE h_app) {
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ BOOL bIsAvailable;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ eStatus = DevDetectSrvIfDecodeOpenSessionResponse(&bIsAvailable);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf OpenSession ERROR!! [sts=%d, ava=%d]", eStatus, bIsAvailable);
+ } else {
+ eStatus = DevDetectSrvIfRegisterForDeviceDetectionEvent(SS_DEV_DETECT_ANY_USB_EV,
+ &PosOnDevDetectEvent,
+ NULL,
+ &bIsAvailable);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf RegisterEvent ERROR!! [sts=%d, ava=%d]", eStatus, bIsAvailable);
+ } else {
+ eStatus = DevDetectSrvIfNotifyOnCloseSessionAck(&PosOnDevDetectCloseSessionAck, &bIsAvailable);
+ if (eFrameworkunifiedStatusOK != eStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "DeviceDetectionServiceIf CloseSessionAck ERROR!! [sts=%d, ava=%d]",
+ eStatus,
+ bIsAvailable);
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * SS_DevDetectSrv service CloseSessionAck Callback Functions
+ *
+ * @param none
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosOnDevDetectCloseSessionAck(HANDLE h_app) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+");
+
+ /* Sensor log stop processing */
+ SensLogTerminate();
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * @brief
+ * SS_DevDetectSrv service Event Callback Functions
+ *
+ * @param none
+ *
+ * @return eFrameworkunifiedStatusOK successful completion
+ */
+static EFrameworkunifiedStatus PosOnDevDetectEvent(HANDLE h_app) {
+ SS_MediaDetectInfo stMedia;
+ EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
+ uint32_t ulSize = 0;
+ uint8_t mode;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "+");
+
+ /* Check the size of received data */
+ ulSize = FrameworkunifiedGetMsgLength(h_app);
+ if (ulSize > sizeof(SS_MediaDetectInfo)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Message size ERROR!! [ulSize = %d, maxsize = %ld]",
+ ulSize, sizeof(SS_MediaDetectInfo));
+ ulSize = 0;
+ } else {
+ /* Obtain data */
+ eStatus = FrameworkunifiedGetMsgDataOfSize(h_app, &stMedia, ulSize);
+ /* When acquisition fails */
+ if (eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "FrameworkunifiedGetMsgDataOfSize ERROR [eStatus:%d]", eStatus);
+ ulSize = 0;
+ } else {
+ if (eUSB == stMedia.dev_type) {
+ if (TRUE == stMedia.bIsDeviceAvailable) {
+ /* Mount detection */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__,
+ "USB mounted sts=[%d] path=[%s] fusedav=[%d]",
+ stMedia.bIsDeviceAvailable, stMedia.deviceMountpath, stMedia.bIsFuseDav);
+
+ /* NOTE: bIsFuseDav -> From the _CWORD80_'s point of view, */
+ /* TRUE(With a USB flash drive inserted into the _CWORD84_,Be synchronized on the FuseDav)*/
+ /* FALSE(USB memory is inserted into the _CWORD80_.) */
+
+ if (stMedia.bIsFuseDav == FALSE) {
+ /* Inserted into your USB port */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "SensLog Initialize start.");
+ /* Get Debug/Release setting */
+ eStatus = NsLogGetFrameworkunifiedLogFlag(POSITIONINGLOG_FLAG_NAVI, &mode);
+ /* When acquisition fails */
+ if (eStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "NsLogGetFrameworkunifiedLogFlag ERROR [eStatus:%d]", eStatus);
+ } else {
+ if (mode == FRAMEWORKUNIFIEDLOG_FLAG_MODE_DEBUG) {
+ /* Sensor Log Initial Processing(Normal)*/
+ SensLogInitialize(reinterpret_cast<uint8_t *>(stMedia.deviceMountpath));
+ }
+ }
+ } else {
+ /* TODO: Mounts (FuseDav synchronized) that are not inserted into your device's USB port are not supported. */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "Don't output SensLog.");
+ }
+ } else {
+ /* Unmount detection */
+ if (stMedia.bIsFuseDav == FALSE) {
+ /* When it is unmounted to its own USB */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__,
+ "USB umounted sts=[%d] fusedav=[%d]",
+ stMedia.bIsDeviceAvailable, stMedia.bIsFuseDav);
+
+ /* Sensor log stop processing */
+ SensLogTerminate();
+ }
+ }
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__, "-");
+ return eStatus;
+}
+
+/**
+ * @brief Debug dump log output function
+ *
+ * @param[in] *p_buf Pointer to the output string
+ */
+static void PosOutputDebugDumpLog(uint8_t* p_buf) { // LCOV_EXCL_START 7: uesd only in FrameworkunifiedOnDebugDump
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SSDEBUGDUMP("%s\n", p_buf);
+ MilliSecSleep(1);
+ return;
+}
+// LCOV_EXCL_STOP
+
Code Review / staging / basesystem.git / blobdiff