//--------------------------------------------------------------------------------------------------
le_result_t pa_mdc_Init
(
void
)
{
if (atports_GetInterface(ATPORT_COMMAND)==NULL) {
LE_WARN("DATA Module is not initialize in this session");
return LE_FAULT;
}
if (atports_GetInterface(ATPORT_PPP)==false) {
LE_WARN("PPP Module is not initialize in this session");
return LE_FAULT;
}
NewSessionStateEvent = le_event_CreateIdWithRefCounting("NewSessionStateEvent");
UnsolicitedEvent = le_event_CreateId("SessionUnsolicitedEvent",sizeof(atmgr_UnsolResponse_t));
NewSessionStatePool = le_mem_CreatePool("NewSessionStatePool", sizeof(pa_mdc_SessionStateData_t));
InternalEventCall = le_event_CreateId("MDCInternalEventCall",sizeof(atmgr_UnsolResponse_t));
le_event_AddHandler("MDCUnsolHandler",InternalEventCall ,MDCInternalHandler);
// set unsolicited +CGEV to Register our own handler.
SetIndicationHandler(2);
le_event_AddHandler("MDCUnsolHandler",UnsolicitedEvent ,CGEVUnsolHandler);
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
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 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);
}
//--------------------------------------------------------------------------------------------------
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 mqttClient_init(mqttClient_t* clientData)
{
LE_ASSERT(clientData);
memset(clientData, 0, sizeof(mqttClient_t));
clientData->session.tx.ptr = clientData->session.tx.buf;
clientData->session.rx.ptr = clientData->session.rx.buf;
clientData->session.sock = MQTT_CLIENT_INVALID_SOCKET;
strcpy(clientData->config.brokerUrl, MQTT_CLIENT_URL_AIRVANTAGE_SERVER);
clientData->config.portNumber = MQTT_CLIENT_PORT_AIRVANTAGE_SERVER;
clientData->config.keepAlive = MQTT_CLIENT_PING_TIMEOUT_MS;
clientData->config.QoS = MQTT_CLIENT_DEFAULT_QOS;
clientData->connStateEvent = le_event_CreateId("MqttConnState", sizeof(mqttClient_connStateData_t));
clientData->inMsgEvent = le_event_CreateId("MqttInMsg", sizeof(mqttClient_inMsg_t));
le_info_ConnectService();
le_info_GetImei(clientData->deviceId, sizeof(clientData->deviceId));
LE_DEBUG("IMEI('%s')", clientData->deviceId);
sprintf(clientData->subscribeTopic, "%s%s", clientData->deviceId, MQTT_CLIENT_TOPIC_NAME_SUBSCRIBE);
}
static void* Thread1(void* context)
{
delEvent = le_event_CreateId("DeleteSigs", 0);
le_event_AddHandler("DelSigHandler", delEvent, DeleteSigs);
le_sig_SetEventHandler(SIGUSR1, SigUser1Handler);
// Start the test procedure by sending a SIGUSR1 signal to our own process.
checkCount++;
LE_ASSERT(kill(getpid(), SIGUSR1) == 0);
le_event_RunLoop();
return NULL;
}
//--------------------------------------------------------------------------------------------------
void le_wifiAp_Init
(
void
)
{
LE_DEBUG( "Wifi Access Point Service is ready" );
pa_wifiAp_Init();
// Create an event Id for new Wifi Events
NewWifiApEventId = le_event_CreateId( "WiFiApEventId", sizeof( le_wifiAp_Event_t ) );
// register for events from PA.
pa_wifiAp_AddEventHandler( PaEventApHandler, NULL );
}
//--------------------------------------------------------------------------------------------------
le_result_t pa_sim_Init
(
void
)
{
if (atports_GetInterface(ATPORT_COMMAND)==NULL) {
LE_DEBUG("SIM Module is not initialize in this session");
return LE_NOT_POSSIBLE;
}
SimEventPoolRef = le_mem_CreatePool("SimEventPool", sizeof(pa_sim_Event_t));
SimEventPoolRef = le_mem_ExpandPool(SimEventPoolRef,DEFAULT_SIMEVENT_POOL_SIZE);
EventUnsolicitedId = le_event_CreateId("SIMEventIdUnsol",sizeof(atmgr_UnsolResponse_t));
EventNewSimStateId = le_event_CreateIdWithRefCounting("SIMEventIdNewState");
le_event_AddHandler("SIMUnsolHandler",EventUnsolicitedId ,SIMUnsolHandler);
LE_DEBUG_IF(SetIndicator()!=LE_OK,"cannot set sim +WIND indicator");
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
le_result_t pa_mrc_Init
(
void
)
{
if (atports_GetInterface(ATPORT_COMMAND)==NULL) {
LE_WARN("radio control Module is not initialize in this session");
return LE_NOT_POSSIBLE;
}
EventUnsolicitedId = le_event_CreateId("RCEventIdUnsol",sizeof(atmgr_UnsolResponse_t));
EventNewRcStatusId = le_event_CreateIdWithRefCounting("EventNewRcStatus");
le_event_AddHandler("RCUnsolHandler",EventUnsolicitedId ,CREGUnsolHandler);
RegStatePoolRef = le_mem_CreatePool("regStatePool",sizeof(le_mrc_NetRegState_t));
RegStatePoolRef = le_mem_ExpandPool(RegStatePoolRef,DEFAULT_REGSTATE_POOL_SIZE);
SubscribeUnsolCREG(PA_MRC_ENABLE_REG_LOC_NOTIFICATION);
pa_mrc_GetNetworkRegConfig(&ThisMode);
return LE_OK;
}
