//-------------------------------------------------------------------------------------------------- void avData_Init ( void ) { SessionStateEvent = le_event_CreateId("Session state", sizeof(le_avdata_SessionState_t)); // Create safe reference map for session request references. The size of the map should be based on // the expected number of simultaneous requests for session. 5 of them seems reasonable. AvSessionRequestRefMap = le_ref_CreateMap("AVSessionRequestRef", 5); FieldEventDataPoolRef = le_mem_CreatePool("Field event data pool", sizeof(FieldEventData_t)); InstanceRefDataPoolRef = le_mem_CreatePool("Instance ref data pool", sizeof(InstanceRefData_t)); // Create safe reference map for instance references. The size of the map should be based on // the expected number of user data instances across all apps. For now, budget for 30 apps // and 10 instances per app. This can always be increased/decreased later, if needed. InstanceRefMap = le_ref_CreateMap("InstRefMap", 300); // Add a handler for client session closes le_msg_AddServiceCloseHandler(le_avdata_GetServiceRef(), ClientCloseSessionHandler, NULL); // Use a timer to delay releasing the session for 2 seconds. le_clk_Time_t timerInterval = { .sec=2, .usec=0 }; SessionReleaseTimerRef = le_timer_Create("Session Release timer"); le_timer_SetInterval(SessionReleaseTimerRef, timerInterval); le_timer_SetHandler(SessionReleaseTimerRef, SessionReleaseTimerHandler); }
//-------------------------------------------------------------------------------------------------- void msgService_Init ( void ) //-------------------------------------------------------------------------------------------------- { // Create and initialize the pool of Service objects. ServicePoolRef = le_mem_CreatePool("MessagingServices", sizeof(Service_t)); le_mem_ExpandPool(ServicePoolRef, MAX_EXPECTED_SERVICES); le_mem_SetDestructor(ServicePoolRef, ServiceDestructor); // Create and initialize the pool of event handlers objects. HandlerEventPoolRef = le_mem_CreatePool("HandlerEventPool", sizeof(SessionEventHandler_t)); le_mem_ExpandPool(HandlerEventPoolRef, MAX_EXPECTED_SERVICES*6); // Create safe reference map for add references. HandlersRefMap = le_ref_CreateMap("HandlersRef", MAX_EXPECTED_SERVICES*6); // Create the Service Map. ServiceMapRef = le_hashmap_Create("MessagingServices", MAX_EXPECTED_SERVICES, ComputeServiceIdHash, AreServiceIdsTheSame); // Create the key to be used to identify thread-local data records containing the Message // Reference when running a Service's message receive handler. int result = pthread_key_create(&ThreadLocalRxMsgKey, NULL); if (result != 0) { LE_FATAL("Failed to create thread local key: result = %d (%s).", result, strerror(result)); } }
//-------------------------------------------------------------------------------------------------- void le_antenna_Init ( void ) { // Create safe reference map for antenna references. AntennaRefMap = le_ref_CreateMap("AntennaRef", LE_ANTENNA_MAX); memset( AntennaCtx, 0, LE_ANTENNA_MAX*sizeof(AntennaCtx_t) ); pa_antenna_AddStatusHandler ( AntennaStatus ); // Init the context le_antenna_Type_t antenna; for (antenna = LE_ANTENNA_PRIMARY_CELLULAR; antenna < LE_ANTENNA_MAX; antenna++) { char eventName[32]; snprintf(eventName, sizeof(eventName), "AntennaStatus_%d", antenna); AntennaCtx[antenna].antennaType = antenna; AntennaCtx[antenna].antennaRef = le_ref_CreateRef(AntennaRefMap, &AntennaCtx[antenna]); AntennaCtx[antenna].statusEventId = le_event_CreateId( eventName, sizeof(pa_antenna_StatusInd_t)); AntennaCtx[antenna].statusEventHandlerRef = NULL; } }
//-------------------------------------------------------------------------------------------------- void AdvertiseService ( void ) { LE_DEBUG("======= Starting Server %s ========", SERVICE_INSTANCE_NAME); le_msg_ProtocolRef_t protocolRef; // Create the server data pool _ServerDataPool = le_mem_CreatePool("ServerData", sizeof(_ServerData_t)); // Create safe reference map for handler references. // The size of the map should be based on the number of handlers defined for the server. // Don't expect that to be more than 2-3, so use 3 as a reasonable guess. _HandlerRefMap = le_ref_CreateMap("ServerHandlers", 3); // Start the server side of the service protocolRef = le_msg_GetProtocolRef(PROTOCOL_ID_STR, sizeof(_Message_t)); _ServerServiceRef = le_msg_CreateService(protocolRef, SERVICE_INSTANCE_NAME); le_msg_SetServiceRecvHandler(_ServerServiceRef, ServerMsgRecvHandler, NULL); le_msg_AdvertiseService(_ServerServiceRef); // Register for client sessions being closed le_msg_AddServiceCloseHandler(_ServerServiceRef, CleanupClientData, NULL); // Need to keep track of the thread that is registered to provide this service. _ServerThreadRef = le_thread_GetCurrent(); }
//-------------------------------------------------------------------------------------------------- void thread_Init ( void ) { // Create the thread memory pool. ThreadPool = le_mem_CreatePool("Thread Pool", sizeof(ThreadObj_t)); le_mem_ExpandPool(ThreadPool, THREAD_POOL_SIZE); // Create the Safe Reference Map for Thread References. Lock(); ThreadRefMap = le_ref_CreateMap("ThreadRef", THREAD_POOL_SIZE); Unlock(); // Create the destructor object pool. DestructorObjPool = le_mem_CreatePool("DestructorObjs", sizeof(DestructorObj_t)); // Create the thread-local data key to be used to store a pointer to each thread object. LE_ASSERT(pthread_key_create(&ThreadLocalDataKey, NULL) == 0); // Create a Thread Object for the main thread (the thread running this function). ThreadObj_t* threadPtr = CreateThread("main", NULL, NULL); // Store the Thread Object pointer in thread-local storage so GetCurrentThreadPtr() can // find it later. LE_ASSERT(pthread_setspecific(ThreadLocalDataKey, threadPtr) == 0); }
//-------------------------------------------------------------------------------------------------- le_result_t le_mcc_Init ( void ) { // Create a pool for Call objects MccCallPool = le_mem_CreatePool("MccCallPool", sizeof(struct le_mcc_Call)); le_mem_ExpandPool(MccCallPool, MCC_MAX_CALL); le_mem_SetDestructor(MccCallPool, CallDestructor); SessionRefPool = le_mem_CreatePool("SessionRefPool", sizeof(SessionRefNode_t)); le_mem_ExpandPool(SessionRefPool, MCC_MAX_CALL); // Create the Safe Reference Map to use for Call object Safe References. MccCallRefMap = le_ref_CreateMap("MccCallMap", MCC_MAX_CALL); // Initialize call wakeup source - succeeds or terminates caller WakeupSource = le_pm_NewWakeupSource(0, CALL_WAKEUP_SOURCE_NAME); CallStateEventId = le_event_CreateId("CallStateEventId", sizeof(le_mcc_CallRef_t)); // Register a handler function for Call Event indications if(pa_mcc_SetCallEventHandler(NewCallEventHandler) != LE_OK) { LE_CRIT("Add pa_mcc_SetCallEventHandler failed"); return LE_FAULT; } // Add a handler to the close session service le_msg_AddServiceCloseHandler( le_mcc_GetServiceRef(), CloseSessionEventHandler, NULL ); return LE_OK; }
//-------------------------------------------------------------------------------------------------- void le_mrc_Init ( void ) { le_result_t result=LE_OK; pa_mrc_NetworkRegSetting_t setting; // Create an event Id for new Network Registration State notification NewNetRegStateId = le_event_CreateIdWithRefCounting("NewNetRegState"); ScanInformationListPool = le_mem_CreatePool("ScanInformationListPool", sizeof(le_mrc_ScanInformationList_t)); ScanInformationSafeRefPool = le_mem_CreatePool("ScanInformationSafeRefPool", sizeof(le_mrc_ScanInformationSafeRef_t)); // Create the Safe Reference Map to use for Scan Information List object Safe References. ScanInformationListRefMap = le_ref_CreateMap("ScanInformationListMap", MRC_MAX_SCANLIST); // Create the Safe Reference Map to use for Scan Information List object Safe References. ScanInformationRefMap = le_ref_CreateMap("ScanInformationMap", MRC_MAX_SCAN); // Register a handler function for new Registration State indication LE_DEBUG("Add pa_mrc_SetNetworkRegHandler"); LE_FATAL_IF((pa_mrc_AddNetworkRegHandler(NewRegStateHandler) == NULL), "Add pa_mrc_AddNetworkRegHandler failed"); // Get & Set the Network registration state notification LE_DEBUG("Get the Network registration state notification configuration"); result=pa_mrc_GetNetworkRegConfig(&setting); if ((result != LE_OK) || (setting == PA_MRC_DISABLE_REG_NOTIFICATION)) { LE_ERROR_IF((result != LE_OK), "Fails to get the Network registration state notification configuration"); LE_INFO("Enable the Network registration state notification"); LE_FATAL_IF((pa_mrc_ConfigureNetworkReg(PA_MRC_ENABLE_REG_NOTIFICATION) != LE_OK), "Enable the Network registration state notification failure"); } LoadMrcConfigurationFromConfigDB(); }
//-------------------------------------------------------------------------------------------------- void fdMon_Init ( void ) //-------------------------------------------------------------------------------------------------- { // Create the FD Monitor Pool from which FD Monitor objects are to be allocated. /// @todo Make this configurable. FdMonitorPool = le_mem_CreatePool("FdMonitor", sizeof(FdMonitor_t)); le_mem_ExpandPool(FdMonitorPool, DEFAULT_FD_MONITOR_POOL_SIZE); // Create the Safe Reference Maps. /// @todo Make this configurable. FdMonitorRefMap = le_ref_CreateMap("FdMonitors", DEFAULT_FD_MONITOR_POOL_SIZE); HandlerRefMap = le_ref_CreateMap("FdEventHandlers", DEFAULT_FD_MONITOR_POOL_SIZE * LE_EVENT_NUM_FD_EVENT_TYPES); // Get a reference to the trace keyword that is used to control tracing in this module. TraceRef = le_log_GetTraceRef("fdMonitor"); }
//-------------------------------------------------------------------------------------------------- void ni_Init ( void ) //-------------------------------------------------------------------------------------------------- { LE_DEBUG("** Initialize Node Iterator subsystem."); IteratorPoolRef = le_mem_CreatePool(ITERATOR_POOL_NAME, sizeof(Iterator_t)); le_mem_ExpandPool(IteratorPoolRef, INITIAL_MAX_ITERATORS); IteratorRefMap = le_ref_CreateMap(ITERATOR_REF_MAP_NAME, INITIAL_MAX_ITERATORS*5); }
//-------------------------------------------------------------------------------------------------- static void InitClient(void) { // Allocate the client data pool _ClientDataPool = le_mem_CreatePool("ClientData", sizeof(_ClientData_t)); // Allocate the client thread pool _ClientThreadDataPool = le_mem_CreatePool("ClientThreadData", sizeof(_ClientThreadData_t)); // Create the thread-local data key to be used to store a pointer to each thread object. LE_ASSERT(pthread_key_create(&_ThreadDataKey, NULL) == 0); // Create safe reference map for handler references. // The size of the map should be based on the number of handlers defined multiplied by // the number of client threads. Since this number can't be completely determined at // build time, just make a reasonable guess. _HandlerRefMap = le_ref_CreateMap("ClientHandlers", 5); }
//-------------------------------------------------------------------------------------------------- void fdMon_Init ( void ) //-------------------------------------------------------------------------------------------------- { // Create the FD Monitor Pool from which FD Monitor objects are to be allocated. /// @todo Make this configurable. FdMonitorPool = le_mem_CreatePool("FdMonitor", sizeof(FdMonitor_t)); le_mem_ExpandPool(FdMonitorPool, DEFAULT_FD_MONITOR_POOL_SIZE); // Create the Safe Reference Map. /// @todo Make this configurable. FdMonitorRefMap = le_ref_CreateMap("FdMonitors", DEFAULT_FD_MONITOR_POOL_SIZE); // Get a reference to the trace keyword that is used to control tracing in this module. TraceRef = le_log_GetTraceRef("fdMonitor"); // Create the thread-specific data key for the FD Monitor Ptr of the current running handler. LE_ASSERT(pthread_key_create(&FDMonitorPtrKey, NULL) == 0); }