2 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 ///////////////////////////////////////////////////////////////////////////////
18 /// \ingroup tag_SystemManagerIf
19 /// \brief This file provides support for the System Manager client interface.
21 ///////////////////////////////////////////////////////////////////////////////
22 #include "system_service/ss_sm_client_if.h"
23 #include <sys/mount.h>
28 #include <native_service/frameworkunified_application.h>
29 #include <native_service/frameworkunified_framework_if.h>
30 #include <native_service/frameworkunified_types.h>
31 #include <native_service/frameworkunified_framework_types.h>
32 #include <native_service/frameworkunified_dispatcher.h>
33 #include <native_service/frameworkunified_sm_framework_dispatch.h>
34 #include <native_service/frameworkunified_sm_hsmframework.h>
38 #include "system_service/ss_system_manager_if.h"
39 #include "system_service/ss_system_manager_protocol.h"
40 #include "system_service/ss_system_manager_notifications.h"
41 #include "system_service/ss_system_if.h"
42 #include "system_service/ss_services.h"
43 #include "system_service/ss_power_service_protocol.h"
44 #include "system_service/ss_templates.h"
45 #include "system_service/ss_string_maps.h"
46 #include "system_service/ss_error_message.h"
47 #include "system_service/ss_sm_client_if_local.h"
49 #include "system_service/ss_boot_map.h"
50 #include "ss_system_if_interfaceunifiedlog.h"
55 std::string szServiceName;
57 } TSystemManagerSession; // LCOV_EXCL_BR_LINE 11:Unexpected branch
60 MODULE_STATE_INVALID = 0, /// Initial state of all modules
61 MODULE_STATE_CONNECTING, /// Attempting to established a session connection
62 MODULE_STATE_CONNECTED, /// A session connection has been established
63 MODULE_STATE_STARTING, /// Received a START from System Manager,
64 /// called FrameworkunifiedOnStart or enqueued evStart
65 MODULE_STATE_START_FAILED, /// Application returned error from FrameworkunifiedOnStart
66 MODULE_STATE_STARTED, /// Sent Start Response to System Manager
67 MODULE_STATE_STOPPING, /// Received a Stop Request from System Manager,
68 /// called FrameworkunifiedOnStop or enqueued evStop
69 MODULE_STATE_STOP_FAILED, /// Application returned error from FrameworkunifiedOnStop
70 MODULE_STATE_STOPPED, /// Sent Start Response to System Manager
71 MODULE_STATE_DEBUG_DUMPING,
72 MODULE_STATE_STARTED_PRE, //!< Sent Pre-Start Response to System Manager
73 MODULE_STATE_START_PRE_FAILED, //!< Application returned error from FrameworkunifiedOnPreStart
74 MODULE_STATE_STOPPED_PRE, //!< Sent Pre-Stop Response to System Manager
75 MODULE_STATE_STOP_PRE_FAILED, //!< Application returned error from FrameworkunifiedOnPreStop
76 MODULE_STATE_STARTED_BACKGROUND, //!< Sent Background-Start Response to System Manager
77 MODULE_STATE_START_BACKGROUND_FAILED, //!< Application returned error from FrameworkunifiedOnBackgroundStart
78 MODULE_STATE_STOPPED_BACKGROUND, //!< Sent Background-Stop Response to System Manager
79 MODULE_STATE_STOP_BACKGROUND_FAILED //!< Application returned error from FrameworkunifiedOnBackgroundStop
82 static SMStopCompleteAck g_responseCompleteAck;
84 static EFrameworkunifiedStatus OnSystemManagerStart(HANDLE hApp);
85 static EFrameworkunifiedStatus OnSystemManagerStop(HANDLE hApp);
86 static EFrameworkunifiedStatus OnSystemManagerPreStart(HANDLE hApp);
87 static EFrameworkunifiedStatus OnSystemManagerPreStop(HANDLE hApp);
88 static EFrameworkunifiedStatus OnSystemManagerBackgroundStart(HANDLE hApp);
89 static EFrameworkunifiedStatus OnSystemManagerBackgroundStop(HANDLE hApp);
90 static EFrameworkunifiedStatus OnSystemManagerOpenSessionAck(HANDLE hApp);
91 static EFrameworkunifiedStatus DebugDumpAppCbStatistics(HANDLE hApp);
92 static EFrameworkunifiedStatus DebugDumpMemoryMap(HANDLE hApp);
93 static EFrameworkunifiedStatus SystemManagerOpenSender(HANDLE hApp);
95 static TSystemManagerSession g_tSystemManagerSession = { }; // LCOV_EXCL_BR_LINE 11:Unexpected branch
96 static pthread_mutex_t gMutexObj = PTHREAD_MUTEX_INITIALIZER;
98 static EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength,
100 static EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName,
101 UI_32 uiLength, PCVOID pData);
103 static EFrameworkunifiedStatus InvokeSyncRequestToSystemManager(UI_32 uiCmd,
105 UI_32 uiLength, PCVOID pData,
109 static EFrameworkunifiedStatus CommonSystemManagerStartStopCallbackProcessing(
110 HANDLE hApp, UI_32 f_InterfaceunifiedEvID, SS_String f_pInterfaceunifiedEvName, CbFuncPtr f_InterfaceunifiedFncCb,
111 PCSTR f_pInterfaceunifiedFncName, ModuleStateType f_moduleSuccessState,
112 ModuleStateType f_moduleFailureState, BOOL f_bUseNotificationVsFncFlag,
113 PCSTR f_pUseNotificationText, SS_SystemManagerProtocol f_ProtocolId,
114 PCSTR f_pProtocolName);
116 static EFrameworkunifiedStatus SendInterfaceunifiedOnResponseToSystemManager(
117 SS_SystemManagerProtocol f_ProtocolID, PCSTR f_pProtocolName,
118 PCSTR f_InterfaceunifiedOnFncName, ModuleStateType f_moduleSuccessState,
119 ModuleStateType f_moduleFailureState, EFrameworkunifiedStatus f_eStatus);
121 // Pointer of function which is called when SM OpenSession Ack is received.
122 // client can register this function pointer using RegisterSMSessionAckCallback() API
123 static CbFuncPtr CallbackFnPtr = NULL;
125 static BOOL UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc = FALSE;
127 static VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(
128 const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 * puiCmdIdArray,
129 UI_32 uiHandlerCount);
131 static VOID SetModuleState(ModuleStateType f_moduleState, BOOL f_bLog = TRUE);
133 static ModuleStateType g_moduleState = MODULE_STATE_INVALID;
134 extern HANDLE g_SystemIf_hApp;
136 //******************************************************************************
137 void Init_SS_IF_ModuleState_StrMap(
138 std::map<ModuleStateType, SS_String> & m_strMap) { // NOLINT (runtime/references)
139 // LCOV_EXCL_BR_START 11:Unexpected branch
140 MAP_ENTRY(m_strMap, MODULE_STATE_INVALID);
141 MAP_ENTRY(m_strMap, MODULE_STATE_CONNECTING);
142 MAP_ENTRY(m_strMap, MODULE_STATE_CONNECTED);
143 MAP_ENTRY(m_strMap, MODULE_STATE_STARTING);
144 MAP_ENTRY(m_strMap, MODULE_STATE_START_FAILED);
145 MAP_ENTRY(m_strMap, MODULE_STATE_STARTED);
146 MAP_ENTRY(m_strMap, MODULE_STATE_STOPPING);
147 MAP_ENTRY(m_strMap, MODULE_STATE_STOP_FAILED);
148 MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED);
149 MAP_ENTRY(m_strMap, MODULE_STATE_STARTED_PRE);
150 MAP_ENTRY(m_strMap, MODULE_STATE_START_PRE_FAILED);
151 MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED_PRE);
152 MAP_ENTRY(m_strMap, MODULE_STATE_STOP_PRE_FAILED);
153 MAP_ENTRY(m_strMap, MODULE_STATE_STARTED_BACKGROUND);
154 MAP_ENTRY(m_strMap, MODULE_STATE_START_BACKGROUND_FAILED);
155 MAP_ENTRY(m_strMap, MODULE_STATE_STOPPED_BACKGROUND);
156 MAP_ENTRY(m_strMap, MODULE_STATE_STOP_BACKGROUND_FAILED);
157 MAP_ENTRY(m_strMap, MODULE_STATE_DEBUG_DUMPING);
159 } // End of void Init_SS_IF_ModuleState_StrMap(std::map<ModuleStateType, SS_String> & m_strMap)
161 class EnumStringMap<ModuleStateType, Init_SS_IF_ModuleState_StrMap> g_oSS_IF_ModuleStateStrMap;
163 // LCOV_EXCL_START 6:Because the condition cannot be set
164 SS_String GetStr(ModuleStateType f_enum) {
165 return g_oSS_IF_ModuleStateStrMap.GetStr(f_enum);
168 HANDLE GetSystemManagerSessionHandle(void) {
169 return g_tSystemManagerSession.hService;
170 } // End of HANDLE GetSystemManagerSessionHandle(void)
173 EFrameworkunifiedStatus InterfaceunifiedSystemConnectToSystemManagerService(HANDLE hApp) {
174 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
175 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
177 CallbackFnPtr = NULL;
179 /// Avoid opening a session to the SystemManager
180 /// service Since it uses the framework as well
181 if (0 != strcmp(SERVICE_SYSMANAGER, FrameworkunifiedGetAppName(hApp))) {
182 // LCOV_EXCL_BR_LINE 6:Duplicate check(AppName has been checked by the caller)
183 memset(&g_responseCompleteAck, 0, sizeof(g_responseCompleteAck));
184 g_responseCompleteAck.unSessionId = 0;
185 strcpy(g_responseCompleteAck.szServiceName, SERVICE_SYSMANAGER); // NOLINT (runtime/printf)
187 pthread_mutex_lock(&gMutexObj);
189 /// Need to save the Group and Subgroup values
190 g_tSystemManagerSession.szServiceName = SERVICE_SYSMANAGER;
191 g_tSystemManagerSession.strIAm = FrameworkunifiedGetAppName(hApp);
193 /// Cleanup any other data members
194 g_tSystemManagerSession.fAvailable = FALSE;
195 g_tSystemManagerSession.hService = NULL;
197 pthread_mutex_unlock(&gMutexObj);
199 l_eStatus = SystemManagerOpenSender(hApp);
201 LOG_STATUS_IF_ERRORED(l_eStatus, "SystemManagerOpenSender()");
203 // LCOV_EXCL_START 6:Duplicate check(AppName has been checked by the caller)
204 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
205 " I am SystemManager ! Not registering for '%s' notification",
206 NTFY_SSSystemMgrAvailability);
209 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
213 ///////////////////////////////////////////////////////////
214 /// Function: SystemManagerOpenSender
216 ///////////////////////////////////////////////////////////
218 EFrameworkunifiedStatus SystemManagerOpenSender(HANDLE hApp) {
219 EFrameworkunifiedStatus l_eStatus;
221 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
223 pthread_mutex_lock(&gMutexObj);
225 // LCOV_EXCL_START 6:Duplicate check(hService is NULL only)
226 if (g_tSystemManagerSession.hService != NULL) {
227 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warn: hService != NULL");
228 pthread_mutex_unlock(&gMutexObj);
229 return eFrameworkunifiedStatusFail;
233 // opening the service
235 == (g_tSystemManagerSession.hService = FrameworkunifiedMcOpenSender(hApp,
236 SERVICE_SYSMANAGER))) {
237 l_eStatus = eFrameworkunifiedStatusNullPointer;
238 LOG_ERROR("FrameworkunifiedMcOpenSender(SERVICE_SYSMANAGER)");
240 FrameworkunifiedProtocolCallbackHandler l_SystemManager_Protocol_Cbs[] = {
241 // Command ID, Call back functions
242 { SS_SM_PROTOCOL_OPEN_SESSION_ACK, OnSystemManagerOpenSessionAck },
243 { SS_SM_START, OnSystemManagerStart },
244 { SS_SM_STOP, OnSystemManagerStop },
245 { SS_SM_PRE_START, OnSystemManagerPreStart },
246 { SS_SM_PRE_STOP, OnSystemManagerPreStop },
247 { SS_SM_BACKGROUND_START, OnSystemManagerBackgroundStart },
248 { SS_SM_BACKGROUND_STOP, OnSystemManagerBackgroundStop },
249 { SS_SM_DEBUG_DUMP, OnSystemManagerDebugDump },
250 }; // LCOV_EXCL_BR_LINE 11:Unexpected branch
252 /// Attach the valid callback for this service
253 if (eFrameworkunifiedStatusOK != // LCOV_EXCL_BR_LINE 11:Unexpected branch
254 (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(
255 hApp, SERVICE_SYSMANAGER, l_SystemManager_Protocol_Cbs,
256 _countof(l_SystemManager_Protocol_Cbs)))) {
257 LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()");
258 } else if (eFrameworkunifiedStatusOK != // LCOV_EXCL_BR_LINE 11:Unexpected branch
259 (l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
260 SS_SM_PROTOCOL_OPEN_SESSION_REQ, 0, NULL))) {
261 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: FrameworkunifiedSendMsg(%s) errored: 0x%X/%s",
262 g_tSystemManagerSession.szServiceName.c_str(), l_eStatus,
263 GetStr(l_eStatus).c_str());
264 } // LCOV_EXCL_BR_LINE 11:Unexpected branch
266 pthread_mutex_unlock(&gMutexObj);
268 if (eFrameworkunifiedStatusOK == l_eStatus) {
269 g_moduleState = MODULE_STATE_CONNECTING;
272 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
273 return l_eStatus; // LCOV_EXCL_BR_LINE 11:Unexpected branch
276 // LCOV_EXCL_START 6:Because the condition cannot be set
277 ///////////////////////////////////////////////////////////
278 /// Function: OnSystemManagerOpenSessionAck
279 /// Service Manager OpenSession callback
280 ///////////////////////////////////////////////////////////
281 EFrameworkunifiedStatus OnSystemManagerOpenSessionAck(HANDLE hApp) {
282 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
283 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
286 l_eStatus = eFrameworkunifiedStatusNullPointer;
287 LOG_ERROR("NULL == hApp");
289 pthread_mutex_lock(&gMutexObj);
290 if (NULL == g_tSystemManagerSession.hService) {
291 l_eStatus = eFrameworkunifiedStatusNullPointer;
292 LOG_ERROR("FrameworkunifiedGetOpenSessionHandle()");
293 g_tSystemManagerSession.fAvailable = FALSE;
295 LOG_SUCCESS("FrameworkunifiedGetOpenSessionHandle(hApp)");
296 g_tSystemManagerSession.fAvailable = TRUE;
297 g_moduleState = MODULE_STATE_CONNECTED;
299 pthread_mutex_unlock(&gMutexObj);
301 if ((eFrameworkunifiedStatusOK == l_eStatus) && (CallbackFnPtr != NULL)) {
302 // Call the RegisterSMSessionAckCallback()-registered function
303 if (eFrameworkunifiedStatusOK != (l_eStatus = (CallbackFnPtr)(hApp))) {
304 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
305 " Error: The 'CallbackFnPtr' function as set by "
306 "the RegisterSMSessionAckCallback() function "
308 l_eStatus, GetStr(l_eStatus).c_str());
312 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
314 } // EFrameworkunifiedStatus OnSystemManagerOpenSessionAck( HANDLE hApp )
317 ///////////////////////////////////////////////////////////
320 ///////////////////////////////////////////////////////////
321 #define SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING( \
322 hApp, evInterfaceunifiedId, InterfaceunifiedFnc, ModStateSuccess, ModStateFailure, \
323 NotifFlag, NotifText, ProtocolId) \
324 l_eStatus = CommonSystemManagerStartStopCallbackProcessing( \
326 evInterfaceunifiedId, \
327 #evInterfaceunifiedId, \
328 InterfaceunifiedFnc, \
329 #InterfaceunifiedFnc "()", \
336 LOG_STATUS(l_eStatus, \
337 "CommonSystemManagerStartStopCallbackProcessing(" #InterfaceunifiedFnc "())");
339 // LCOV_EXCL_START 6:Because the condition cannot be set
340 ///////////////////////////////////////////////////////////
341 /// Function: OnSystemManagerStart
343 ///////////////////////////////////////////////////////////
344 EFrameworkunifiedStatus OnSystemManagerStart(HANDLE hApp) {
345 EFrameworkunifiedStatus l_eStatus;
346 FrameworkunifiedDefaultCallbackHandler cbFuncs;
347 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
349 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
350 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
352 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
353 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
354 hApp, FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedStart), cbFuncs.onStart, MODULE_STATE_STARTED,
355 MODULE_STATE_START_FAILED, FALSE, "", SS_SM_START_COMPL_RSPN);
356 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
358 } // End of EFrameworkunifiedStatus OnSystemManagerStart( HANDLE hApp )
360 ///////////////////////////////////////////////////////////
361 /// Function: OnSystemManagerStop
363 ///////////////////////////////////////////////////////////
364 EFrameworkunifiedStatus OnSystemManagerStop(HANDLE hApp) {
365 EFrameworkunifiedStatus l_eStatus;
366 FrameworkunifiedDefaultCallbackHandler cbFuncs;
367 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
369 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
370 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
372 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
373 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
374 hApp, FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedStop), cbFuncs.onStop, MODULE_STATE_STOPPED,
375 MODULE_STATE_STOP_FAILED, UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc,
376 " 'UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc' is 'True': "
377 "setting 'l_eStatus' to 'eFrameworkunifiedStatusFail'",
378 SS_SM_STOP_COMPL_RSPN);
380 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
382 } // End of EFrameworkunifiedStatus OnSystemManagerStop( HANDLE hApp )
384 ///////////////////////////////////////////////////////////
385 /// Function: OnSystemManagerPreStart
387 ///////////////////////////////////////////////////////////
388 static EFrameworkunifiedStatus OnSystemManagerPreStart(HANDLE hApp) {
389 EFrameworkunifiedStatus l_eStatus;
390 FrameworkunifiedDefaultCallbackHandler cbFuncs; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
391 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
393 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
394 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
396 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
397 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
399 FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedPreStart),
401 MODULE_STATE_STARTED_PRE,
402 MODULE_STATE_START_PRE_FAILED,
405 SS_SM_PRE_START_COMPL_RSPN);
406 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
408 } // End of EFrameworkunifiedStatus OnSystemManagerPreStart( HANDLE hApp )
410 ///////////////////////////////////////////////////////////
411 /// Function: OnSystemManagerPreStop
413 ///////////////////////////////////////////////////////////
414 static EFrameworkunifiedStatus OnSystemManagerPreStop(HANDLE hApp) {
415 EFrameworkunifiedStatus l_eStatus;
416 FrameworkunifiedDefaultCallbackHandler cbFuncs; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
417 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
419 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
420 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
422 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
423 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
425 FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedPreStop),
427 MODULE_STATE_STOPPED_PRE,
428 MODULE_STATE_STOP_PRE_FAILED,
431 SS_SM_PRE_STOP_COMPL_RSPN);
432 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
434 } // End of EFrameworkunifiedStatus OnSystemManagerPreStop( HANDLE hApp )
436 ///////////////////////////////////////////////////////////
437 /// Function: OnSystemManagerBackgroundStart
439 ///////////////////////////////////////////////////////////
440 static EFrameworkunifiedStatus OnSystemManagerBackgroundStart(HANDLE hApp) {
441 EFrameworkunifiedStatus l_eStatus;
442 FrameworkunifiedDefaultCallbackHandler cbFuncs; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
443 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
445 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
446 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
448 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
449 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
451 FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedBackgroundStart),
452 cbFuncs.onBackgroundStart,
453 MODULE_STATE_STARTED_BACKGROUND,
454 MODULE_STATE_START_BACKGROUND_FAILED,
457 SS_SM_BACKGROUND_START_COMPL_RSPN);
458 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
460 } // End of EFrameworkunifiedStatus OnSystemManagerBackgroundStart( HANDLE hApp )
462 ///////////////////////////////////////////////////////////
463 /// Function: OnSystemManagerBackgroundStop
465 ///////////////////////////////////////////////////////////
466 static EFrameworkunifiedStatus OnSystemManagerBackgroundStop(HANDLE hApp) {
467 EFrameworkunifiedStatus l_eStatus;
468 FrameworkunifiedDefaultCallbackHandler cbFuncs; // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
469 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
471 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs); // LCOV_EXCL_BR_LINE 11:Excluded due to gcov restrictions(others)
472 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
474 // Call CommonSystemManagerStartStopCallbackProcessing(), & log status
475 SETUP_AND_CALL_COMMON_SYSTEM_MANAGER_START_STOP_PROCESSING(
477 FRAMEWORKUNIFIED_EVENT(evFrameworkunifiedBackgroundStop),
478 cbFuncs.onBackgroundStop,
479 MODULE_STATE_STOPPED_BACKGROUND,
480 MODULE_STATE_STOP_BACKGROUND_FAILED,
483 SS_SM_BACKGROUND_STOP_COMPL_RSPN);
484 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); // LCOV_EXCL_BR_LINE 15:Excluded for function that are expanded inline
486 } // End of EFrameworkunifiedStatus OnSystemManagerBackgroundStop( HANDLE hApp )
488 ///////////////////////////////////////////////////////////
489 /// Function: CommonSystemManagerStartStopCallbackProcessing
491 ///////////////////////////////////////////////////////////
492 EFrameworkunifiedStatus CommonSystemManagerStartStopCallbackProcessing(
493 HANDLE hApp, UI_32 f_InterfaceunifiedEvID, SS_String f_pInterfaceunifiedEvName, CbFuncPtr f_InterfaceunifiedFncCb,
494 PCSTR f_pInterfaceunifiedFncName, ModuleStateType f_moduleSuccessState,
495 ModuleStateType f_moduleFailureState, BOOL f_bUseNotificationVsFncFlag,
496 PCSTR f_pUseNotificationText, SS_SystemManagerProtocol f_ProtocolId,
497 PCSTR f_pProtocolName) {
498 EFrameworkunifiedStatus l_eStatus;
499 EFrameworkunifiedStatus l_StatusFncReturned;
500 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
501 SS_String l_pInterfaceunifiedFncName;
503 if (f_moduleSuccessState == g_moduleState) {
504 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
505 " Warning: Module state already is '%s', just "
506 "returning '%s' to System Manager",
507 GetStr(g_moduleState).c_str(), f_pProtocolName);
508 l_eStatus = eFrameworkunifiedStatusOK;
509 l_StatusFncReturned = l_eStatus;
511 // If client application is a state machine, post an Event instead of calling
512 // InterfaceunifiedOnXYZ()
513 if (FrameworkunifiedIsStateMachineApp(hApp)) {
514 l_pInterfaceunifiedFncName = "FrameworkunifiedPostEvent(FRAMEWORKUNIFIED_EVENT(" + f_pInterfaceunifiedEvName + " ))";
515 CFrameworkunifiedHSMFramework* l_pStateMachine = FrameworkunifiedGetStateMachine(hApp);
516 if (NULL == l_pStateMachine) {
517 l_eStatus = eFrameworkunifiedStatusNullPointer;
518 LOG_ERROR("FrameworkunifiedGetStateMachine()");
519 l_StatusFncReturned = l_eStatus;
521 l_eStatus = l_pStateMachine->FrameworkunifiedPostEvent(f_InterfaceunifiedEvID);
522 if (eFrameworkunifiedStatusOK != l_eStatus) {
523 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
524 " Error: l_pStateMachine->FrameworkunifiedPostEvent(%s) "
526 f_pInterfaceunifiedEvName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
527 l_StatusFncReturned = l_eStatus;
529 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
530 " f_bUseNotificationVsFncFlag is '%s'",
531 GetStr(f_bUseNotificationVsFncFlag).c_str());
532 if (f_bUseNotificationVsFncFlag) {
534 // DON'T send an 'Ok' back to the SendInterfaceunifiedOnResponse function: if
535 // it detects a 'Ok' it will send a SS_SM_<protocol>_RSPN back
536 // to System Manager, telling System Manager that the request
537 // has been completely serviced.
538 l_StatusFncReturned = eFrameworkunifiedStatusFail;
539 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", f_pUseNotificationText);
542 // Always send an 'Ok' back for the evInterfaceunified<protocol> version
543 // of InterfaceunifiedOn<protocol>; the l_eStatus applies to the
544 // FrameworkunifiedPostEvent() function, not the actual <protocol> event
546 l_StatusFncReturned = eFrameworkunifiedStatusOK;
548 } // End else successful FrameworkunifiedPostEvent()
549 } // End else valid FrameworkunifiedGetStateMachine()
550 } else { // End if FrameworkunifiedIsStateMachineApp() is TRUE
551 l_pInterfaceunifiedFncName = f_pInterfaceunifiedFncName;
552 if (f_InterfaceunifiedFncCb) {
553 l_eStatus = (f_InterfaceunifiedFncCb)(hApp);
554 LOG_STATUS(l_eStatus, f_pInterfaceunifiedFncName);
555 l_StatusFncReturned = l_eStatus;
558 l_StatusFncReturned = eFrameworkunifiedStatusOK;
563 l_eStatus = SendInterfaceunifiedOnResponseToSystemManager(f_ProtocolId, f_pProtocolName,
564 l_pInterfaceunifiedFncName.c_str(),
565 f_moduleSuccessState,
566 f_moduleFailureState,
567 l_StatusFncReturned);
568 const char l_cFormat[] = "SendInterfaceunifiedOnResponseToSystemManager(%s)";
569 char l_cBuf[sizeof(l_cFormat) + strlen(f_pProtocolName) + 1]; // NOLINT (runtime/arrays)
570 snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, f_pProtocolName);
571 LOG_STATUS_IF_ERRORED(l_eStatus, l_cBuf);
573 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
575 } // End of CommonSystemManagerStartStopCallbackProcessing(
578 ///////////////////////////////////////////////////////////
579 /// Function: SendInterfaceunifiedOnStopResponseToSystemManager()
581 ///////////////////////////////////////////////////////////
582 EFrameworkunifiedStatus SendInterfaceunifiedOnStopResponseToSystemManager(EFrameworkunifiedStatus f_eStatus) {
583 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
584 EFrameworkunifiedStatus l_eStatus = SendInterfaceunifiedOnResponseToSystemManager(
585 SS_SM_STOP_COMPL_RSPN, "SS_SM_STOP_COMPL_RSPN", "FrameworkunifiedOnStop()",
586 MODULE_STATE_STOPPED, MODULE_STATE_STOP_FAILED, f_eStatus);
587 LOG_STATUS_IF_ERRORED(l_eStatus, "SendInterfaceunifiedOnResponseToSystemManager("
588 "SS_SM_STOP_COMPL_RSPN");
589 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
591 } // End of EFrameworkunifiedStatus SendInterfaceunifiedOnStopResponseToSystemManager(EFrameworkunifiedStatus f_eStatus)
593 ///////////////////////////////////////////////////////////
594 /// Function: GetInterfaceunifiedOnStartExtInfo()
596 ///////////////////////////////////////////////////////////
597 EFrameworkunifiedStatus GetInterfaceunifiedOnStartExtInfo(T_SS_SM_START_ExtDataStructType &f_info) { // NOLINT (runtime/references)
598 EFrameworkunifiedStatus l_eStatus;
599 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
601 l_eStatus = InvokeSyncRequestToSystemManager(
602 SS_SM_GET_START_EXT_INFO, "SS_SM_GET_START_EXT_INFO", 0, NULL,
603 sizeof(T_SS_SM_START_ExtDataStructType), (PVOID) & f_info);
604 LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
606 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
610 ///////////////////////////////////////////////////////////
611 /// Function: GetInterfaceunifiedOnStopExtInfo()
613 ///////////////////////////////////////////////////////////
614 EFrameworkunifiedStatus GetInterfaceunifiedOnStopExtInfo(T_SS_SM_STOP_ExtDataStructType &f_info) { // NOLINT (runtime/references)
615 EFrameworkunifiedStatus l_eStatus;
616 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
618 l_eStatus = InvokeSyncRequestToSystemManager(
619 SS_SM_GET_STOP_EXT_INFO, "SS_SM_GET_STOP_EXT_INFO", 0, NULL,
620 sizeof(T_SS_SM_STOP_ExtDataStructType), (PVOID) & f_info);
621 LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
623 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
627 // LCOV_EXCL_START 6:Because the condition cannot be set
628 ///////////////////////////////////////////////////////////
629 /// Function: OnSystemManagerDebugDump
631 ///////////////////////////////////////////////////////////
632 EFrameworkunifiedStatus OnSystemManagerDebugDump(HANDLE hApp) {
633 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
634 EFrameworkunifiedStatus l_eStatus;
635 FrameworkunifiedDefaultCallbackHandler cbFuncs;
637 g_moduleState = MODULE_STATE_DEBUG_DUMPING;
638 l_eStatus = FrameworkunifiedGetDefaultCbHandler(&cbFuncs);
639 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedGetDefaultCbHandler()");
641 if (cbFuncs.onDebugDump) {
642 l_eStatus = cbFuncs.onDebugDump(hApp);
643 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedOnDebugDump()");
648 l_eStatus = DebugDumpAppCbStatistics(hApp);
649 LOG_STATUS_IF_ERRORED(l_eStatus, "DebugDumpAppCbStatistics()");
651 l_eStatus = DebugDumpMemoryMap(hApp);
652 LOG_STATUS_IF_ERRORED(l_eStatus, "DebugDumpMemoryMap()");
654 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
656 } // End of EFrameworkunifiedStatus OnSystemManagerDebugDump( HANDLE hApp )
658 ///////////////////////////////////////////////////////////
659 /// Function: DebugDumpAppCbStatistics
661 ///////////////////////////////////////////////////////////
662 EFrameworkunifiedStatus DebugDumpAppCbStatistics(HANDLE hApp) {
663 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
664 EFrameworkunifiedStatus l_eStatus;
665 l_eStatus = eFrameworkunifiedStatusOK;
667 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
671 ///////////////////////////////////////////////////////////
672 /// Function: DebugDumpMemoryMap
674 ///////////////////////////////////////////////////////////
675 EFrameworkunifiedStatus DebugDumpMemoryMap(HANDLE hApp) {
676 #define MEM_MAP_READ_SIZE 4096
677 #define DUMP_MAX_SIZE 131072 // 128KB
679 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
680 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
681 char buf[MEM_MAP_READ_SIZE];
682 std::string bufString;
685 fd = open("/proc/self/maps", O_RDONLY);
687 while ((ret = read(fd, buf, MEM_MAP_READ_SIZE)) > 0) {
688 if ((bufString.size() + ret) > DUMP_MAX_SIZE) {
689 // If read it again, it will break because it overflows
692 bufString.append(buf, ret);
696 l_eStatus = eFrameworkunifiedStatusOK;
697 SendDebugDumpResponseToSystemManager(bufString);
700 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
705 //////////////////////////////////////////
706 // SendDebugDumpResponseToSystemManager
707 //////////////////////////////////////////
708 VOID SendDebugDumpResponseToSystemManager(BOOL f_bFormatStrRequired,
709 PCSTR f_cFormat, ...) {
710 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
711 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
713 const UI_32 l_maxDebugDumpMsgSize = (1024 * 4);
714 CHAR l_cMsg[l_maxDebugDumpMsgSize] = { 0 };
717 pthread_mutex_lock(&gMutexObj);
719 l_pAppName = FrameworkunifiedGetAppName(g_SystemIf_hApp); // LCOV_EXCL_BR_LINE 11:Unexpected branch
720 if (f_bFormatStrRequired) {
721 // build a format string
722 // Format: AppName/debugdump_data
723 snprintf(l_cMsg, l_maxDebugDumpMsgSize, "%s/", l_pAppName);
726 va_start(l_argList, f_cFormat);
727 vsnprintf(&l_cMsg[strlen(l_cMsg)], l_maxDebugDumpMsgSize - strlen(l_cMsg),
728 f_cFormat, l_argList);
731 if (0 == strcmp(SERVICE_SYSMANAGER, l_pAppName)) {
732 l_eStatus = FrameworkunifiedSendSelf(g_SystemIf_hApp, SS_SM_DEBUG_DUMP_RSPN,
733 strlen(l_cMsg) + 1, l_cMsg); // LCOV_EXCL_BR_LINE 11:Unexpected branch
734 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendSelf(SS_SM_DEBUG_DUMP_RSPN)");
735 } else if (NULL != g_tSystemManagerSession.hService) {
736 l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
737 SS_SM_DEBUG_DUMP_RSPN, strlen(l_cMsg) + 1, l_cMsg); // LCOV_EXCL_BR_LINE 11:Unexpected branch
738 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_DEBUG_DUMP_RSPN)");
740 l_eStatus = eFrameworkunifiedStatusNullPointer;
741 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
742 " Error: Invalid handle[g_tSystemManagerSession.hService == NULL]");
745 pthread_mutex_unlock(&gMutexObj);
747 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
748 } // End of EFrameworkunifiedStatus SendDebugDumpResponseToSystemManager( HANDLE hApp )
750 // LCOV_EXCL_START 6:Because the condition cannot be set
751 //////////////////////////////////////////
752 // SendDebugDumpResponseToSystemManager
753 //////////////////////////////////////////
754 VOID SendDebugDumpResponseToSystemManager(std::string & f_messageStr) { // NOLINT (runtime/references)
755 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
756 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
758 pthread_mutex_lock(&gMutexObj);
760 if (0 == strcmp(SERVICE_SYSMANAGER, FrameworkunifiedGetAppName(g_SystemIf_hApp))) {
761 l_eStatus = FrameworkunifiedSendSelf(g_SystemIf_hApp, SS_SM_DEBUG_DUMP_RSPN,
762 f_messageStr.size() + 1, f_messageStr.c_str());
763 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendSelf(SS_SM_DEBUG_DUMP_RSPN)");
764 } else if (NULL != g_tSystemManagerSession.hService) {
765 l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService,
766 SS_SM_DEBUG_DUMP_RSPN, f_messageStr.size() + 1,
767 f_messageStr.c_str());
768 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_DEBUG_DUMP_RSPN)");
770 l_eStatus = eFrameworkunifiedStatusNullPointer;
771 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: hService = NULL");
774 pthread_mutex_unlock(&gMutexObj);
776 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
777 } // End of EFrameworkunifiedStatus SendDebugDumpResponseToSystemManager(std::string & f_messageStr)
780 ///////////////////////////////////////////////////////////
781 /// Function: SendInterfaceunifiedOnResponseToSystemManager()
783 ///////////////////////////////////////////////////////////
784 EFrameworkunifiedStatus SendInterfaceunifiedOnResponseToSystemManager(
785 SS_SystemManagerProtocol f_ProtocolID, PCSTR f_pProtocolName,
786 PCSTR f_InterfaceunifiedOnFncName, ModuleStateType f_moduleSuccessState,
787 ModuleStateType f_moduleFailureState, EFrameworkunifiedStatus f_eStatus) {
788 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
789 EFrameworkunifiedStatus l_eStatus;
791 if (eFrameworkunifiedStatusOK != f_eStatus) {
792 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
793 " Warning: '%s' returned %d/%s, NOT sending '%s' to System Manager",
794 f_InterfaceunifiedOnFncName, f_eStatus, GetStr(f_eStatus).c_str(),
796 l_eStatus = f_eStatus;
797 SetModuleState(f_moduleFailureState);
799 if (f_moduleSuccessState == g_moduleState) {
800 FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
801 " Warning: Module state already is '%s', just "
802 "returning '%s' to System Manager",
803 GetStr(g_moduleState).c_str(), f_pProtocolName);
806 l_eStatus = SendMsgToSystemManager(static_cast<UI_32>(f_ProtocolID),
808 sizeof(g_responseCompleteAck),
809 &g_responseCompleteAck); // LCOV_EXCL_BR_LINE 11:Unexpected branch
810 const char l_cFormat[] = "SendMsgToSystemManager(%s)";
811 char l_cBuf[sizeof(l_cFormat) + strlen(f_pProtocolName) + 1]; // NOLINT (runtime/arrays)
812 snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, f_pProtocolName);
813 LOG_STATUS(l_eStatus, l_cBuf);
814 SetModuleState(f_moduleSuccessState);
817 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
819 } // End of SendInterfaceunifiedOnResponseToSystemManager(
821 ///////////////////////////////////////////////////////////
822 /// Function: SendMsgToSystemManager
824 ///////////////////////////////////////////////////////////
825 EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName, UI_32 uiLength,
827 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Sending %s", f_pCmdName);
829 return SendMsgToSystemManager(uiCmd, uiLength, pData);
830 } // End of EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName, UI_32 uiLength, PCVOID pData)
832 ///////////////////////////////////////////////////////////
833 /// Function: SendMsgToSystemManager
835 ///////////////////////////////////////////////////////////
836 EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength, PCVOID pData) {
837 EFrameworkunifiedStatus l_eStatus;
838 if (NULL == g_tSystemManagerSession.hService) {
839 l_eStatus = eFrameworkunifiedStatusNullPointer;
840 LOG_ERROR("NULL == g_tSystemManagerSession.hService");
842 pthread_mutex_lock(&gMutexObj);
843 l_eStatus = FrameworkunifiedSendMsg(g_tSystemManagerSession.hService, uiCmd, uiLength,
845 pthread_mutex_unlock(&gMutexObj);
846 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg()");
849 } // End of EFrameworkunifiedStatus SendMsgToSystemManager(UI_32 uiCmd, UI_32 uiLength, PCVOID pData)
851 ///////////////////////////////////////////////////////////
852 /// Function: InvokeSyncRequestToSystemManager
854 ///////////////////////////////////////////////////////////
855 EFrameworkunifiedStatus InvokeSyncRequestToSystemManager(UI_32 uiCmd, PCSTR f_pCmdName,
856 UI_32 uiLength, PCVOID pData,
857 UI_32 uiResLength, PVOID pResData) {
858 EFrameworkunifiedStatus l_eStatus;
859 UI_32 uiRcvLength = 0;
860 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Sending %s", f_pCmdName);
862 if (NULL == g_tSystemManagerSession.hService) {
863 l_eStatus = eFrameworkunifiedStatusNullPointer;
864 LOG_ERROR("NULL == g_tSystemManagerSession.hService");
866 pthread_mutex_lock(&gMutexObj);
867 l_eStatus = FrameworkunifiedInvokeSync(g_tSystemManagerSession.hService, uiCmd, uiLength,
868 pData, uiResLength, pResData, &uiRcvLength); // LCOV_EXCL_BR_LINE 11:Unexpected branch
869 if (eFrameworkunifiedStatusOK == l_eStatus) {
870 if (uiResLength != uiRcvLength) {
871 LOG_ERROR("uiResLength != uiRcvLength");
872 l_eStatus = eFrameworkunifiedStatusFail;
875 pthread_mutex_unlock(&gMutexObj);
876 LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedInvokeSync()");
881 // LCOV_EXCL_START 6:Because the condition cannot be set
882 ///////////////////////////////////////////////////////////
883 /// Function: SendWakeUpToSystemManager
885 ///////////////////////////////////////////////////////////
886 EFrameworkunifiedStatus SendWakeUpToSystemManager(wakeInfo *pData) {
887 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
888 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_WAKEUP_MODULES,
889 "SS_SM_WAKEUP_MODULES",
892 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
893 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
895 } // End of EFrameworkunifiedStatus SendWakeUpToSystemManager(wakeInfo *pData)
898 // LCOV_EXCL_START 6:Because the condition cannot be set
899 ///////////////////////////////////////////////////////////
900 /// Function: SendShutdownToSystemManager
902 ///////////////////////////////////////////////////////////
903 EFrameworkunifiedStatus SendShutdownToSystemManager(Pwr_ServiceSetInterface *pData) {
904 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
905 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_SHUTDOWN_MODULES,
906 "SS_SM_SHUTDOWN_MODULES",
907 sizeof(Pwr_ServiceSetInterface),
909 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
910 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
912 } // End of EFrameworkunifiedStatus SendShutdownToSystemManager(Pwr_ServiceSetInterface *pData)
915 ///////////////////////////////////////////////////////////
916 /// Function: RegisterSMSessionAckCallback
918 ///////////////////////////////////////////////////////////
919 EFrameworkunifiedStatus RegisterSMSessionAckCallback(EFrameworkunifiedStatus (*CallbackPtr)(HANDLE)) {
920 CallbackFnPtr = CallbackPtr;
921 return eFrameworkunifiedStatusOK;
922 } // End of EFrameworkunifiedStatus RegisterSMSessionAckCallback(EFrameworkunifiedStatus (*CallbackPtr)(HANDLE))
924 // LCOV_EXCL_START 6:Because the condition cannot be set
925 ///////////////////////////////////////////////////////////
926 /// Function: SendSystemModeRequestToSystemManager
928 ///////////////////////////////////////////////////////////
929 EFrameworkunifiedStatus SendSystemModeRequestToSystemManager(void) {
930 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
931 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_SYSTEM_MODE_INFO_REQ,
932 "SS_SM_SYSTEM_MODE_INFO_REQ", 0,
934 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
935 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
937 } // End of EFrameworkunifiedStatus SendSystemModeRequestToSystemManager(void)
939 ///////////////////////////////////////////////////////////
940 /// Function: SendInitCompReportToSystemManager
942 ///////////////////////////////////////////////////////////
943 EFrameworkunifiedStatus SendInitCompReportToSystemManager(void) {
944 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
945 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_INITCOMP_REP,
946 "SS_SM_INITCOMP_REP", 0, NULL);
947 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
948 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
950 } // End of EFrameworkunifiedStatus SendInitCompReportToSystemManager(void)
953 ///////////////////////////////////////////////////////////
954 /// Function: AttachCallbackToSystemManager
956 ///////////////////////////////////////////////////////////
957 EFrameworkunifiedStatus AttachCallbackToSystemManager(HANDLE hApp, UI_32 iCmd,
959 return FrameworkunifiedAttachCallbackToDispatcher(
960 hApp, g_tSystemManagerSession.szServiceName.c_str(), iCmd, fpOnCmd);
961 } // End of EFrameworkunifiedStatus AttachCallbackToSystemManager( HANDLE hApp, UI_32 iCmd, CbFuncPtr fpOnCmd )
964 ///////////////////////////////////////////////////////////
965 /// Function: SetDataResetModeToSystemManager
967 ///////////////////////////////////////////////////////////
968 EFrameworkunifiedStatus SetDataResetModeToSystemManager(ESMDataResetModeInfo dataResetMode) {
969 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
970 EFrameworkunifiedStatus l_resData;
972 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
974 switch (dataResetMode) {
975 case e_SS_SM_DATA_RESET_MODE_NONE:
976 case e_SS_SM_DATA_RESET_MODE_USER:
977 case e_SS_SM_DATA_RESET_MODE_FACTORY:
980 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "dataResetMode %d", dataResetMode);
981 return eFrameworkunifiedStatusInvldParam;
984 l_eStatus = InvokeSyncRequestToSystemManager(SS_SM_DATA_RESET_MODE_SET_REQ,
985 "SS_SM_DATA_RESET_MODE_SET_REQ",
986 sizeof(dataResetMode),
987 (PVOID) & dataResetMode,
989 (PVOID) & l_resData); // LCOV_EXCL_BR_LINE 11:Unexpected branch
990 LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
992 if (eFrameworkunifiedStatusOK == l_eStatus) {
993 if (eFrameworkunifiedStatusOK != l_resData) {
994 l_eStatus = l_resData;
995 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " l_eStatus %d", l_eStatus);
999 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1001 } // End of EFrameworkunifiedStatus SetDataResetModeToSystemManager(ESMDataResetModeInfo dataResetMode)
1003 ///////////////////////////////////////////////////////////
1004 /// Function: SetProgUpdateStateToSystemManager
1006 ///////////////////////////////////////////////////////////
1007 EFrameworkunifiedStatus SetProgUpdateStateToSystemManager(
1008 SMProgUpdateState progUpdateState) {
1009 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
1010 EFrameworkunifiedStatus l_resData;
1012 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1014 if (progUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) {
1015 } else if (progUpdateState & SS_SM_PROG_UPDATE_STATE_MAP_UPDATED) {
1016 } else if (progUpdateState & SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED) {
1018 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "unknown %#x", progUpdateState);
1019 return eFrameworkunifiedStatusInvldParam;
1022 l_eStatus = InvokeSyncRequestToSystemManager(
1023 SS_SM_PROG_UPDATE_STATE_SET_REQ, "SS_SM_PROG_UPDATE_STATE_SET_REQ",
1024 sizeof(progUpdateState), (PVOID) & progUpdateState, sizeof(l_resData),
1025 (PVOID) & l_resData); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1026 LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
1028 if ((eFrameworkunifiedStatusOK == l_eStatus) && (eFrameworkunifiedStatusOK != l_resData)) {
1029 l_eStatus = l_resData;
1030 LOG_ERROR("SM RESP");
1033 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1035 } // End of EFrameworkunifiedStatus SetProgUpdateStateToSystemManager(SMProgUpdateState progUpdateState)
1037 ///////////////////////////////////////////////////////////
1038 /// Function: SetNextWakeupTypeToSystemManager
1040 ///////////////////////////////////////////////////////////
1041 EFrameworkunifiedStatus SetNextWakeupTypeToSystemManager(ESMNextWakeupType f_wakeupType) {
1042 EFrameworkunifiedStatus l_eStatus;
1043 EFrameworkunifiedStatus l_resData;
1044 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1046 switch (f_wakeupType) {
1047 case e_SS_SM_NEXT_WAKEUP_TYPE_NONE:
1048 case e_SS_SM_NEXT_WAKEUP_TYPE_COLD:
1049 case e_SS_SM_NEXT_WAKEUP_TYPE_HOT:
1052 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unknown type(%d)", f_wakeupType);
1053 return eFrameworkunifiedStatusInvldParam;
1056 l_eStatus = InvokeSyncRequestToSystemManager(SS_SM_NEXT_WAKEUP_TYPE_SET_REQ,
1057 "SS_SM_NEXT_WAKEUP_TYPE_SET_REQ",
1058 sizeof(f_wakeupType),
1059 (PVOID) & f_wakeupType,
1061 (PVOID) & l_resData); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1062 LOG_STATUS_IF_ERRORED(l_eStatus, "InvokeSyncRequestToSystemManager()");
1064 if (eFrameworkunifiedStatusOK == l_eStatus) {
1065 if (eFrameworkunifiedStatusOK != l_resData) {
1066 l_eStatus = l_resData;
1067 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " l_eStatus %d", l_eStatus);
1071 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1075 ///////////////////////////////////////////////////////////
1076 /// Function: SendCpuResetRequestToSystemManager
1078 ///////////////////////////////////////////////////////////
1079 EFrameworkunifiedStatus SendCpuResetRequestToSystemManager(
1080 ESMCpuResetReason l_eCpuResetReason, std::string f_messageStr/* = "" */,
1081 std::string f_suffixStr/* = "" */) {
1082 TSystemManagerCpuResetInfo l_resetInfo; // LCOV_EXCL_BR_LINE 11:Unexpected branch
1083 EFrameworkunifiedStatus l_eStatus;
1085 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1087 l_resetInfo.resetReason = l_eCpuResetReason;
1088 snprintf(l_resetInfo.messageStr, SS_SM_RESET_MSG_STR_SIZE, "%s",
1089 f_messageStr.c_str()); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1090 snprintf(l_resetInfo.suffixStr, SS_SM_SUFFIX_STR_SIZE, "%s",
1091 f_suffixStr.c_str()); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1093 l_eStatus = SendMsgToSystemManager(SS_SM_CPU_RESET_REQ, "SS_SM_CPU_RESET_REQ",
1094 sizeof(l_resetInfo),
1095 (PVOID) & l_resetInfo); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1097 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1098 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1100 } // End of SendCpuResetRequestToSystemManager
1102 ///////////////////////////////////////////////////////////
1103 /// Function: SendStartupConfirmationToSystemManager
1105 ///////////////////////////////////////////////////////////
1106 // LCOV_EXCL_START 6:Because the condition cannot be set
1107 EFrameworkunifiedStatus SendStartupConfirmationToSystemManager(
1108 StartupConfirmationMsgStrut &f_startupConfirmationMsg) { //NOLINT (runtime/references)
1109 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1110 EFrameworkunifiedStatus l_eStatus;
1112 Pwr_ServiceSetInterface tServiceSetIf;
1113 tServiceSetIf.data.startupConfirmationMsg = f_startupConfirmationMsg;
1115 l_eStatus = SendMsgToSystemManager(SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ,
1116 "SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ",
1117 sizeof(Pwr_ServiceSetInterface),
1118 (PCVOID) & tServiceSetIf);
1119 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1120 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1122 } // End of EFrameworkunifiedStatus SendStartupConfirmationToSystemManager(
1125 // LCOV_EXCL_START 6:Because the condition cannot be set
1126 EFrameworkunifiedStatus SendSystemErrorToSystemManager(EFrameworkunifiedSystemError f_systemError) {
1127 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1128 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM_PROPAGATE_SYSTEM_ERROR,
1129 sizeof(f_systemError),
1130 reinterpret_cast<void*>(&f_systemError));
1131 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1132 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1136 EFrameworkunifiedStatus Send_CWORD56_HeartBeatRequestToSystemManager(
1137 EPWR_HB_REQ_MSG_STRUCT f_HbReq) {
1138 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1139 EFrameworkunifiedStatus l_eStatus = SendMsgToSystemManager(SS_SM__CWORD56__HEARTBEAT_REQ,
1141 reinterpret_cast<void*>(&f_HbReq));
1142 LOG_STATUS_IF_ERRORED(l_eStatus, "SendMsgToSystemManager()");
1143 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1148 VOID Set_UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc_StateVar(BOOL f_SetTrue) {
1149 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1150 UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc = f_SetTrue;
1151 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
1152 " UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc set '%s'",
1153 UseStopCompleteNotificationVsInterfaceunifiedOnStopFnc ? "True" : "False");
1154 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1157 EFrameworkunifiedStatus SendBootMicroResetNotificationToSystemManager(
1158 eSMBootMicroResetReason f_ResetReason) {
1159 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1160 EFrameworkunifiedStatus l_eStatus;
1162 l_eStatus = SendMsgToSystemManager(SS_SM_BOOT_MICRO_RESET_NTF,
1163 "SS_SM_BOOT_MICRO_RESET_NTF",
1164 sizeof(f_ResetReason), &f_ResetReason);
1166 LOG_STATUS_IF_ERRORED(l_eStatus,
1167 "SendMsgToSystemManager(SS_SM_BOOT_MICRO_RESET_NTF)");
1169 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1173 EFrameworkunifiedStatus SendUserInvokedLoggingRequestToSystemManager(
1174 eSMUserLogType f_userInvokedLogType, std::string f_messageStr/* = "" */,
1175 std::string f_suffixStr/* = "" */) {
1176 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1177 EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
1180 switch (f_userInvokedLogType) {
1181 case e_SS_SM_CAPTURE_ALL_LOGS:
1182 case e_SS_SM_SCREEN_CAPTURE:
1183 case e_SS_SM_CAPTURE_INTERFACEUNIFIED_LOGS:
1184 case e_SS_SM_CAPTURE_DEV_LOGS:
1185 case e_SS_SM_CAPTURE_MODULE_LOGS:
1186 case e_SS_SM_CAPTURE_DTC_LOGS:
1187 case e_SS_SM_CAPTURE_NAVI_LOGS:
1188 case e_SS_SM_CAPTURE_GROUP_RELAUNCH:
1191 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Unknown key ID '%d'",
1192 f_userInvokedLogType);
1193 throw eFrameworkunifiedStatusInvldParam;
1197 TSystemManagerLoggingRequestInfo l_logInfo = { };
1199 snprintf(l_logInfo.messageStr, SS_SM_LOG_MSG_STR_SIZE, "%s",
1200 f_messageStr.c_str()); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1201 snprintf(l_logInfo.suffixStr, SS_SM_SUFFIX_STR_SIZE, "%s",
1202 f_suffixStr.c_str()); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1204 l_logInfo.logType = f_userInvokedLogType;
1205 l_eStatus = SendMsgToSystemManager(SS_SM_USER_INVOKED_LOG_REQ,
1206 "SS_SM_USER_INVOKED_LOG_REQ",
1207 sizeof(l_logInfo), &l_logInfo); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1208 LOG_STATUS_IF_ERRORED(l_eStatus,
1209 "SendMsgToSystemManager(SS_SM_USER_INVOKED_LOG_REQ)");
1210 } catch (EFrameworkunifiedStatus e) {
1213 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1214 return (l_eStatus); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1217 // LCOV_EXCL_START 6:Because the condition cannot be set
1218 EFrameworkunifiedStatus SendDiagLoggingRequestToSystemManager(
1219 std::string f_copyDestPathStr) {
1220 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1221 EFrameworkunifiedStatus l_eStatus;
1223 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_DIAG_LOG_REQ,
1224 "SS_SM_ERROR_EVENT_DIAG_LOG_REQ",
1225 f_copyDestPathStr.length() + 1,
1226 f_copyDestPathStr.c_str());
1227 LOG_STATUS_IF_ERRORED(
1228 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_DIAG_LOG_REQ)");
1230 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1234 EFrameworkunifiedStatus SendCANLoggingRequestToSystemManager(void) {
1235 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1236 EFrameworkunifiedStatus l_eStatus;
1238 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_CAN_LOG_REQ,
1239 "SS_SM_ERROR_EVENT_CAN_LOG_REQ", 0, NULL);
1241 LOG_STATUS_IF_ERRORED(
1242 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_CAN_LOG_REQ)");
1244 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1248 EFrameworkunifiedStatus SendDTCLoggingRequestToSystemManager(UI_32 f_dtc) {
1250 return eFrameworkunifiedStatusOK;
1254 EFrameworkunifiedStatus RegisterBootMicroLogRequestCb(HANDLE hApp, CbFuncPtr fpOnCmd) {
1255 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1256 EFrameworkunifiedStatus l_eStatus;
1259 l_eStatus = eFrameworkunifiedStatusNullPointer;
1260 LOG_ERROR("(NULL == hApp)");
1261 } else if (NULL == fpOnCmd) {
1262 l_eStatus = eFrameworkunifiedStatusNullPointer;
1263 LOG_ERROR("(NULL == fpOnCmd)");
1265 l_eStatus = FrameworkunifiedSubscribeToSessionEventWithCallback(
1266 hApp, SS_SM_BOOT_MICRO_LOG_REQ, fpOnCmd,
1267 g_tSystemManagerSession.hService); // LCOV_EXCL_BR_LINE 11:Unexpected branch
1269 LOG_STATUS_IF_ERRORED(
1271 "FrameworkunifiedSubscribeToSessionEventWithCallback(SS_SM_BOOT_MICRO_LOG_REQ)");
1274 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1278 EFrameworkunifiedStatus SendBootMicroLogResponseToSystemManager(std::string f_logString) {
1279 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1280 EFrameworkunifiedStatus l_eStatus;
1282 l_eStatus = SendMsgToSystemManager(SS_SM_BOOT_MICRO_LOG_RSP,
1283 "SS_SM_BOOT_MICRO_LOG_RSP",
1284 f_logString.size() + 1,
1285 f_logString.c_str());
1287 LOG_STATUS_IF_ERRORED(l_eStatus,
1288 "SendMsgToSystemManager(SS_SM_BOOT_MICRO_LOG_RSP)");
1290 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1294 // LCOV_EXCL_START 6:Because the condition cannot be set
1295 EFrameworkunifiedStatus DetachCallbacksFromInterfaceunifiedDispatcher(
1296 HANDLE hApp, PCSTR pServiceName,
1297 const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 uiHandlerCount,
1299 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1300 EFrameworkunifiedStatus l_eStatus;
1301 PUI_32 l_puiCmdIdArray;
1303 if (NULL == pServiceName) {
1304 l_eStatus = eFrameworkunifiedStatusInvldParam;
1305 LOG_ERROR("NULL == pServiceName");
1306 } else if (NULL == pMsgHandler) {
1307 l_eStatus = eFrameworkunifiedStatusInvldParam;
1308 LOG_ERROR("NULL == pMsgHandler");
1309 } else if (0 == uiHandlerCount) {
1310 l_eStatus = eFrameworkunifiedStatusInvldParam;
1311 LOG_ERROR("0 == uiHandlerCount");
1312 } else if (NULL == hSession) {
1313 l_eStatus = eFrameworkunifiedStatusInvldParam;
1314 LOG_ERROR("NULL == hSession");
1316 == (l_puiCmdIdArray = new (std::nothrow) UI_32[uiHandlerCount])) {
1317 l_eStatus = eFrameworkunifiedStatusNullPointer;
1318 LOG_ERROR("new (std::nothrow)UI_32[ uiHandlerCount ]");
1320 LoadCbHandlerCmdIDsIntoDetachCbIDsArray(pMsgHandler, l_puiCmdIdArray,
1323 l_eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(hApp, pServiceName,
1325 uiHandlerCount, hSession);
1326 LOG_STATUS(l_eStatus, "FrameworkunifiedDetachCallbacksFromDispatcher()");
1327 delete[] l_puiCmdIdArray;
1329 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1331 } // End of EFrameworkunifiedStatus DetachCallbacksFromInterfaceunifiedDispatcher(HANDLE hApp,
1333 EFrameworkunifiedStatus DetachParentCallbacksFromInterfaceunifiedDispatcher(
1334 HANDLE hApp, const FrameworkunifiedProtocolCallbackHandler* pMsgHandler,
1335 UI_32 uiHandlerCount) {
1336 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1337 EFrameworkunifiedStatus l_eStatus;
1338 PUI_32 l_puiCmdIdArray;
1340 if (NULL == pMsgHandler) {
1341 l_eStatus = eFrameworkunifiedStatusInvldParam;
1342 LOG_ERROR("NULL == pMsgHandler");
1343 } else if (0 == uiHandlerCount) {
1344 l_eStatus = eFrameworkunifiedStatusInvldParam;
1345 LOG_ERROR("0 == uiHandlerCount");
1347 == (l_puiCmdIdArray = new (std::nothrow) UI_32[uiHandlerCount])) {
1348 l_eStatus = eFrameworkunifiedStatusNullPointer;
1349 LOG_ERROR("new (std::nothrow)UI_32[ uiHandlerCount ]");
1351 LoadCbHandlerCmdIDsIntoDetachCbIDsArray(pMsgHandler, l_puiCmdIdArray,
1354 l_eStatus = FrameworkunifiedDetachParentCallbacksFromDispatcher(hApp, l_puiCmdIdArray,
1356 LOG_STATUS(l_eStatus, "FrameworkunifiedDetachParentCallbacksFromDispatcher()");
1357 delete[] l_puiCmdIdArray;
1360 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1362 } // End of EFrameworkunifiedStatus DetachParentCallbacksFromInterfaceunifiedDispatcher(HANDLE hApp,
1364 VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(
1365 const FrameworkunifiedProtocolCallbackHandler* pMsgHandler, UI_32 * puiCmdIdArray,
1366 UI_32 uiHandlerCount) {
1367 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1368 for (UI_32 i = 0; i < uiHandlerCount; i++) {
1369 puiCmdIdArray[i] = pMsgHandler[i].iCmd;
1371 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1372 } // End of VOID LoadCbHandlerCmdIDsIntoDetachCbIDsArray(const FrameworkunifiedProtocolCallbackHandler* pMsgHandler,
1374 ///////////////////////////////////////////////////////////
1375 /// Function: SendLogStartRequestToSystemManager
1377 ///////////////////////////////////////////////////////////
1378 EFrameworkunifiedStatus SendLogStartRequestToSystemManager(EErrorEventType f_errorEvent) {
1379 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1380 EFrameworkunifiedStatus l_eStatus;
1382 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_START_REQ,
1383 "SS_SM_ERROR_EVENT_LOGGING_START_REQ",
1384 sizeof(f_errorEvent), &f_errorEvent);
1386 LOG_STATUS_IF_ERRORED(
1387 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_START_REQ)");
1389 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1393 ///////////////////////////////////////////////////////////
1394 /// Function: SendLogArtifactRequestToSystemManager
1396 ///////////////////////////////////////////////////////////
1397 EFrameworkunifiedStatus SendLogArtifactRequestToSystemManager(EArtifactId f_artifactId) {
1398 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1399 EFrameworkunifiedStatus l_eStatus;
1401 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_ARTIFACT_REQ,
1402 "SS_SM_ERROR_EVENT_ARTIFACT_REQ",
1403 sizeof(f_artifactId), &f_artifactId);
1405 LOG_STATUS_IF_ERRORED(
1406 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_ARTIFACT_REQ)");
1408 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1412 ///////////////////////////////////////////////////////////
1413 /// Function: SendLogCompleteRequestToSystemManager
1415 ///////////////////////////////////////////////////////////
1416 EFrameworkunifiedStatus SendLogCompleteRequestToSystemManager(EFrameworkunifiedStatus f_eStatus) {
1417 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1418 EFrameworkunifiedStatus l_eStatus;
1420 if (eFrameworkunifiedStatusOK != f_eStatus) {
1421 l_eStatus = eFrameworkunifiedStatusFail;
1423 l_eStatus = f_eStatus;
1426 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_COMPLETE,
1427 "SS_SM_ERROR_EVENT_LOGGING_COMPLETE",
1428 sizeof(l_eStatus), &l_eStatus);
1430 LOG_STATUS_IF_ERRORED(
1431 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_LOGGING_COMPLETE)");
1433 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1437 ///////////////////////////////////////////////////////////
1438 /// Function: SendEelExportRequestToSystemManager
1440 ///////////////////////////////////////////////////////////
1441 EFrameworkunifiedStatus SendEelExportRequestToSystemManager(std::string f_path) {
1442 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1443 EFrameworkunifiedStatus l_eStatus;
1445 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_EEL_EXPORT_REQ,
1446 "SS_SM_ERROR_EVENT_EEL_EXPORT_REQ",
1447 f_path.length() + 1, f_path.c_str());
1449 LOG_STATUS_IF_ERRORED(
1450 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_EEL_EXPORT_REQ)");
1452 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1457 ///////////////////////////////////////////////////////////
1458 /// Function: SendInterfaceunifiedEmmcLogsRequestToSystemManager
1460 ///////////////////////////////////////////////////////////
1461 EFrameworkunifiedStatus SendInterfaceunifiedEmmcLogsRequestToSystemManager(std::string f_path) {
1462 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1463 EFrameworkunifiedStatus l_eStatus;
1465 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ,
1466 "SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ",
1467 f_path.length() + 1, f_path.c_str());
1469 LOG_STATUS_IF_ERRORED(
1470 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ)");
1472 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1476 ///////////////////////////////////////////////////////////
1477 /// Function: SendClearLogsRequestToSystemManager
1479 ///////////////////////////////////////////////////////////
1480 EFrameworkunifiedStatus SendClearLogsRequestToSystemManager(
1481 TSystemManagerClearLogsInfo *f_info) {
1482 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
1483 EFrameworkunifiedStatus l_eStatus;
1486 l_eStatus = eFrameworkunifiedStatusInvldParam;
1488 l_eStatus = SendMsgToSystemManager(SS_SM_ERROR_EVENT_CLR_LOGS_REQ,
1489 "SS_SM_ERROR_EVENT_CLR_LOGS_REQ", 0,
1492 LOG_STATUS_IF_ERRORED(
1493 l_eStatus, "SendMsgToSystemManager(SS_SM_ERROR_EVENT_CLR_LOGS_REQ)");
1496 FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
1500 VOID SetModuleState(ModuleStateType f_moduleState, BOOL f_bLog) {
1501 if (f_bLog) { // LCOV_EXCL_BR_LINE 8:f_bLog is true only
1502 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Changing SM_IF state from '%s' to '%s'",
1503 GetStr(g_moduleState).c_str(), GetStr(f_moduleState).c_str());
1505 g_moduleState = f_moduleState;
1506 } // LCOV_EXCL_BR_LINE 10:Because the last line
1507 // End of VOID ModuleLaunchParams::SetModuleState(SMModuleState f_moduleState )
1509 // EOF /SS_SystemIf/src/ss_sm_client.cpp