//--------------------------------------------------------------------------------------------------
static void FirstLayerSessionStateHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
bool* eventDataPtr = reportPtr;
le_avdata_SessionStateHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
clientHandlerFunc(*eventDataPtr, le_event_GetContextPtr());
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerTestAHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
int32_t* dataPtr = reportPtr;
TestAHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
clientHandlerFunc(*dataPtr, le_event_GetContextPtr());
}
//--------------------------------------------------------------------------------------------------
static void FirstDtmfLayeredHandler
(
void* reportPtr,
void* secondLayerFunc
)
{
le_audio_StreamEvent_t* streamEventPtr = reportPtr;
le_audio_DtmfStreamEventHandlerFunc_t dtmfStreamEventHandler =
(le_audio_DtmfStreamEventHandlerFunc_t) secondLayerFunc;
dtmfStreamEventHandler( streamEventPtr, le_event_GetContextPtr() );
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerCellNetStateHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_cellnet_State_t* eventDataPtr = reportPtr;
le_cellnet_StateHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
clientHandlerFunc(*eventDataPtr,
le_event_GetContextPtr());
}
//--------------------------------------------------------------------------------------------------
static void DirectorySocketError
(
int fd
)
//--------------------------------------------------------------------------------------------------
{
Service_t* servicePtr = le_event_GetContextPtr();
LE_FATAL("Error on Service Directory connection for service (%s:%s).",
servicePtr->id.name,
le_msg_GetProtocolIdStr(servicePtr->id.protocolRef));
}
//--------------------------------------------------------------------------------------------------
static void DirectorySocketClosed
(
int fd
)
//--------------------------------------------------------------------------------------------------
{
Service_t* servicePtr = le_event_GetContextPtr();
LE_FATAL("Permission to offer service (%s:%s) has been denied.",
servicePtr->id.name,
le_msg_GetProtocolIdStr(servicePtr->id.protocolRef));
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerNetRegStateChangeHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_mrc_NetRegState_t* statePtr = reportPtr;
le_mrc_NetRegStateHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
clientHandlerFunc(*statePtr, le_event_GetContextPtr());
// The reportPtr is a reference counted object, so need to release it
le_mem_Release(reportPtr);
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerVoltageChangeHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_ips_ThresholdStatus_t* ipsPtr = reportPtr;
le_ips_ThresholdEventHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
clientHandlerFunc(*ipsPtr, le_event_GetContextPtr());
// The reportPtr is a reference counted object, so need to release it
le_mem_Release(reportPtr);
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerAntennaStatusHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_antenna_StatusHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
pa_antenna_StatusInd_t* statusPtr = (pa_antenna_StatusInd_t*) reportPtr;
LE_DEBUG("Call application handler antennaType %d", statusPtr->antennaType);
// Call the client handler
clientHandlerFunc( AntennaCtx[statusPtr->antennaType].antennaRef,
statusPtr->status,
le_event_GetContextPtr() );
}
//--------------------------------------------------------------------------------------------------
static void DirectorySocketReadable
(
int fd
)
//--------------------------------------------------------------------------------------------------
{
Service_t* servicePtr = le_event_GetContextPtr();
le_result_t result;
int clientSocketFd;
// Receive the Client connection file descriptor from the Service Directory.
result = unixSocket_ReceiveMsg(fd,
NULL, // dataBuffPtr
0, // dataBuffSize
&clientSocketFd,
NULL); // credPtr
if (result == LE_CLOSED)
{
LE_DEBUG("Connection has closed.");
}
else if (result != LE_OK)
{
LE_FATAL("Failed to receive client fd from Service Directory (%d: %s).",
result,
LE_RESULT_TXT(result));
}
else if (clientSocketFd < 0)
{
LE_ERROR("Received something other than a file descriptor from Service Directory for (%s:%s).",
servicePtr->id.name,
le_msg_GetProtocolIdStr(servicePtr->id.protocolRef));
}
else
{
// Create a server-side Session object for that connection to this Service.
le_msg_SessionRef_t sessionRef = msgSession_CreateServerSideSession(servicePtr, clientSocketFd);
// If successful, call the registered "open" handler, if there is one.
if (sessionRef != NULL)
{
CallOpenHandler(servicePtr, sessionRef);
}
}
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerCallEventHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_mcc_CallRef_t *callRef = reportPtr;
le_mcc_CallEventHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
le_mcc_Call_t* callPtr = le_ref_Lookup(MccCallRefMap, *callRef);
if (callPtr == NULL)
{
LE_CRIT("Invalid reference (%p) provided!", *callRef);
return;
}
LE_DEBUG("Send Call Event for [%p] with [%d]",*callRef,callPtr->event);
clientHandlerFunc(*callRef, callPtr->event, le_event_GetContextPtr());
}
//--------------------------------------------------------------------------------------------------
static void DirectorySocketWriteable
(
int fd
)
//--------------------------------------------------------------------------------------------------
{
Service_t* servicePtr = le_event_GetContextPtr();
if (servicePtr->state == LE_MSG_SERVICE_CONNECTING)
{
// Must have connected (or failed to do so).
int errCode = unixSocket_GetErrorState(servicePtr->directorySocketFd);
// Disable writeability notification.
le_event_ClearFdHandlerByEventType(servicePtr->fdMonitorRef, LE_EVENT_FD_WRITEABLE);
// If connection successful,
if (errCode == 0)
{
// Send the Service ID to the Service Directory.
msgService_SendServiceId(servicePtr, fd);
servicePtr->state = LE_MSG_SERVICE_ADVERTISED;
// Wait for the Service Directory to respond by either dropping the connection
// (meaning that we have been denied permission to offer this service) or by
// forwarding us file descriptors for authenticated client connections.
}
// If connection failed,
else
{
LE_FATAL("Failed to connect to Service Directory. SO_ERROR %d (%s).",
errCode,
strerror(errCode));
}
}
else
{
LE_CRIT("Unexpected writeability notification in state %d.", servicePtr->state);
}
}
//--------------------------------------------------------------------------------------------------
static void FirstLayerWifiApEventHandler
(
void* reportPtr,
void* secondLayerHandlerFunc
)
{
le_wifiAp_EventHandlerFunc_t clientHandlerFunc = secondLayerHandlerFunc;
le_wifiAp_Event_t * wifiEvent = (le_wifiAp_Event_t*)reportPtr;
if ( NULL != wifiEvent)
{
LE_DEBUG( "FirstLayerWifiApEventHandler event: %d", *wifiEvent );
clientHandlerFunc( *wifiEvent, le_event_GetContextPtr());
}
else
{
LE_ERROR( "FirstLayerWifiApEventHandler event is NULL" );
}
}
