//--------------------------------------------------------------------------------------------------
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);
}
