//--------------------------------------------------------------------------------------------------
static void ConnectionLostHandler
(
void* contextPtr, ///< context parameter contains the session for which the connection was lost
char* causePtr ///< paho library doesn't currently populate this
)
{
le_event_Report(ConnectionLostThreadEventId, &contextPtr, sizeof(void*));
}
//--------------------------------------------------------------------------------------------------
void avData_ReportSessionState
(
le_avdata_SessionState_t sessionState
)
{
LE_DEBUG("Reporting session state %d", sessionState);
// Send the event to interested applications
le_event_Report(SessionStateEvent, &sessionState, sizeof(sessionState));
}
//--------------------------------------------------------------------------------------------------
le_cellnet_RequestObjRef_t le_cellnet_Request
(
void
)
{
uint32_t command = REQUEST_COMMAND;
le_event_Report(CommandEvent, &command, sizeof(command));
// Need to return a unique reference that will be used by Release.
return le_ref_CreateRef(RequestRefMap, (void*)1);
}
static void PaEventApHandler
(
le_wifiAp_Event_t event,
void * ctxPtr
)
{
LE_DEBUG( "PaEventApHandler event: %d", event );
le_event_Report( NewWifiApEventId, (void*)&event, sizeof( le_wifiAp_Event_t ) );
}
static void mqttClient_SendConnStateEvent(bool isConnected, int32_t connectErrorCode, int32_t subErrorCode)
{
mqttClient_connStateData_t eventData;
mqttClient_t* clientData = mqttMain_getClient();
eventData.isConnected = isConnected;
eventData.connectErrorCode = connectErrorCode;
eventData.subErrorCode = subErrorCode;
LE_DEBUG("MQTT connected(%d), error(%d), sub-error(%d)", eventData.isConnected, eventData.connectErrorCode, eventData.subErrorCode);
le_event_Report(clientData->connStateEvent, &eventData, sizeof(eventData));
}
//--------------------------------------------------------------------------------------------------
void pa_audioSimu_ReceiveDtmf
(
char dtmf
)
{
le_audio_StreamEvent_t streamEvent;
// Only one interface support the DTMF detection for now
streamEvent.streamEvent = LE_AUDIO_BITMASK_DTMF_DETECTION;
streamEvent.event.dtmf = dtmf;
le_event_Report(DtmfEvent, &streamEvent, sizeof(le_audio_StreamEvent_t));
}
void TriggerTestA
(
void
)
{
// todo: This could instead be the value passed into the trigger function, but need
// to change the .api definition for that to work.
static int32_t triggerCount=0;
triggerCount++;
LE_PRINT_VALUE("%d", triggerCount);
le_event_Report(TriggerEvent, &triggerCount, sizeof(triggerCount));
}
// -------------------------------------------------------------------------------------------------
static void MrcNetRegHandler
(
le_mrc_NetRegState_t state,
void* contextPtr
)
{
le_cellnet_State_t cellNetState = TranslateToCellNetState(state);
LE_PRINT_VALUE("Cellular Network Registration state.%d", cellNetState);
// Send the state event to applications
le_event_Report(CellNetStateEvent, &cellNetState, sizeof(cellNetState));
}
//--------------------------------------------------------------------------------------------------
static void ReportCellNetStateEvent
(
le_cellnet_State_t state
)
{
LE_DEBUG("Report cellular network state %d (%s)", state, cellNetStateStr[state]);
// Update current network cell state
CurrentState = state;
// Send the event to interested applications
le_event_Report(CellNetStateEvent, &state, sizeof(state));
}
static void mqttClient_SendIncomingMessageEvent(const char* topicName, const char* keyName, const char* value, const char* timestamp)
{
mqttClient_inMsg_t eventData;
mqttClient_t* clientData = mqttMain_getClient();
strcpy(eventData.topicName, topicName);
strcpy(eventData.keyName, keyName);
strcpy(eventData.value, value);
strcpy(eventData.timestamp, timestamp);
LE_DEBUG("Send MQTT incoming message('%s', ['%s':'%s'@'%s'])", eventData.topicName, eventData.keyName, eventData.value, eventData.timestamp);
le_event_Report(clientData->inMsgEvent, &eventData, sizeof(eventData));
}
//--------------------------------------------------------------------------------------------------
static void SendCellNetStateEvent
(
void
)
{
le_mrc_NetRegState_t state;
le_mrc_GetNetRegState(&state);
le_cellnet_State_t cellNetState = TranslateToCellNetState(state);
LE_PRINT_VALUE("%i", cellNetState);
// Send the event to interested applications
le_event_Report(CellNetStateEvent, &cellNetState, sizeof(cellNetState));
}
//--------------------------------------------------------------------------------------------------
static void AntennaStatus ( pa_antenna_StatusInd_t* msgRef )
{
// Sanity check
if (( msgRef->antennaType >= LE_ANTENNA_MAX ) ||
( AntennaCtx[msgRef->antennaType].antennaRef == NULL ) ||
( AntennaCtx[msgRef->antennaType].statusEventId == NULL ))
{
LE_ERROR("Invalid status indication");
return;
}
LE_DEBUG("Report AntennaStatus antenna %d", msgRef->antennaType);
// Report the status if event was created
le_event_Report( AntennaCtx[msgRef->antennaType].statusEventId,
(void*)msgRef, sizeof(pa_antenna_StatusInd_t) );
}
static void SigUser1Handler(int sigNum)
{
LE_ASSERT(sigNum == SIGUSR1);
LE_INFO("%s received through fd handler.", strsignal(sigNum));
switch (checkCount)
{
case 1:
{
// Report event to delete sigs for our thread.
le_event_Report(delEvent, NULL, 0);
break;
}
default: LE_FATAL("Should not be here.");
}
}
//--------------------------------------------------------------------------------------------------
void le_cellnet_Release
(
le_cellnet_RequestObjRef_t requestRef ///< Reference to a previously requested cellular network
)
{
// Look up the reference. If it is NULL, then the reference is not valid.
// Otherwise, delete the reference and send the release command to the CellNet thread.
void* cellNetPtr = le_ref_Lookup(RequestRefMap, requestRef);
if ( cellNetPtr == NULL )
{
LE_ERROR("Invalid cellular network request reference %p", requestRef);
}
else
{
LE_PRINT_VALUE("%p", requestRef);
le_ref_DeleteRef(RequestRefMap, requestRef);
uint32_t command = RELEASE_COMMAND;
le_event_Report(CommandEvent, &command, sizeof(command));
}
}
//--------------------------------------------------------------------------------------------------
static int MessageArrivedHandler
(
void* contextPtr,
char* topicNamePtr,
int topicLen,
MQTTClient_message* messagePtr
)
{
mqtt_Session* s = le_ref_Lookup(SessionRefMap, contextPtr);
if (s == NULL)
{
LE_WARN("Session doesn't exist");
return true;
}
mqtt_Message* storedMsgPtr = le_mem_ForceAlloc(MessagePoolRef);
LE_ASSERT(storedMsgPtr);
memset(storedMsgPtr, 0, sizeof(*storedMsgPtr));
LE_DEBUG("MessageArrivedHandler called for topic=%s. Storing session=0x%p", topicNamePtr, contextPtr);
storedMsgPtr->sessionRef = contextPtr;
// When topicLen is 0 it means that the topic contains embedded nulls and can't be treated as a
// normal C string
storedMsgPtr->topicLength = (topicLen == 0) ? (strlen(topicNamePtr) + 1) : topicLen;
storedMsgPtr->topicPtr = le_mem_ForceAlloc(TopicPoolRef);
LE_ASSERT(storedMsgPtr->topicPtr);
memset(storedMsgPtr->topicPtr, 0, sizeof(MQTT_MAX_TOPIC_LENGTH));
memcpy(storedMsgPtr->topicPtr, topicNamePtr, storedMsgPtr->topicLength);
storedMsgPtr->payloadLength = messagePtr->payloadlen;
storedMsgPtr->payloadPtr = le_mem_ForceAlloc(PayloadPoolRef);
LE_ASSERT(storedMsgPtr->payloadPtr);
memset(storedMsgPtr->payloadPtr, 0, sizeof(MQTT_MAX_PAYLOAD_LENGTH));
memcpy(storedMsgPtr->payloadPtr, messagePtr->payload, storedMsgPtr->payloadLength);
le_event_Report(ReceiveThreadEventId, &storedMsgPtr, sizeof(mqtt_Message*));
return true;
}
//--------------------------------------------------------------------------------------------------
static void NewCallEventHandler
(
pa_mcc_CallEventData_t* dataPtr
)
{
le_mcc_Call_t* callPtr = NULL;
// Acquire wakeup source on first indication of call
if (LE_MCC_EVENT_SETUP == dataPtr->event ||
LE_MCC_EVENT_ORIGINATING == dataPtr->event ||
LE_MCC_EVENT_INCOMING == dataPtr->event)
{
// Note: 3GPP calls have both SETUP and INCOMING states, so
// this will warn on INCOMING state as a second "stay awake"
le_pm_StayAwake(WakeupSource);
}
// Check if we have already an ongoing callPtr for this call
callPtr = GetCallObject("", dataPtr->callId, true);
if (callPtr == NULL)
{
// Call not in progress
// check if a callPtr exists with the same number
callPtr = GetCallObject(dataPtr->phoneNumber, -1, false);
if (callPtr == NULL)
{
callPtr = CreateCallObject (dataPtr->phoneNumber,
dataPtr->callId,
dataPtr->event,
dataPtr->terminationEvent,
dataPtr->terminationCode);
}
callPtr->inProgress = true;
}
else
{
callPtr->event = dataPtr->event;
callPtr->termination = dataPtr->terminationEvent;
callPtr->terminationCode = dataPtr->terminationCode;
// Update reference count
UpdateReferenceCount(callPtr);
}
// Handle call state transition
switch (dataPtr->event)
{
case LE_MCC_EVENT_TERMINATED:
// Release wakeup source once call termination is processed
le_pm_Relax(WakeupSource);
callPtr->inProgress = false;
break;
default:
break;
}
// Call the client's handler
le_event_Report(CallStateEventId,
&callPtr->callRef,
sizeof(callPtr->callRef));
}
void *CombainHttpThreadFunc(void *context)
{
char combainUrl[128];
char oldCombainApiKey[MAX_LEN_API_KEY];
do {
auto t = RequestJson->dequeue();
// Have the API key changeable from DHUB
if (strncmp(oldCombainApiKey, combainApiKey, sizeof(combainUrl) - (1 + strlen(combainUrl))) != 0)
{
strncpy(oldCombainApiKey, combainApiKey, sizeof(combainUrl) - (1 + strlen(combainUrl)));
combainUrl[0] = '\0';
strcpy(combainUrl, "https://cps.combain.com?key=");
strncat(combainUrl, oldCombainApiKey, sizeof(combainUrl) - (1 + strlen(combainUrl)));
}
ma_combainLocation_LocReqHandleRef_t handle = std::get<0>(t);
std::string &requestBody = std::get<1>(t);
if (oldCombainApiKey[0] == '\0')
{
ResponseJson->enqueue(std::make_tuple(handle, "Combain API key not set"));
le_event_Report(ResponseAvailableEvent, NULL, 0);
continue;
}
// Bug existed as we kept tacking onto the existing buffer
HttpReceiveBuffer.used = 0;
HttpReceiveBuffer.data[0] = 0;
CURL* curl = curl_easy_init();
LE_ASSERT(curl);
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_URL, combainUrl) == CURLE_OK);
struct curl_slist *httpHeaders = NULL;
httpHeaders = curl_slist_append(httpHeaders, "Content-Type:application/json");
LE_ASSERT(httpHeaders != NULL);
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_HTTPHEADER, httpHeaders) == CURLE_OK);
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, requestBody.c_str()) == CURLE_OK);
LE_INFO("APIKEY: %s", combainUrl);
LE_INFO("SENDING %d char: %s", requestBody.length(), requestBody.c_str());
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemCallback) == CURLE_OK);
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&HttpReceiveBuffer) == CURLE_OK);
// Set the timeout for connection phase
LE_ASSERT(curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, CURL_CONNECT_TIMEOUT_SECONDS) == CURLE_OK);
const CURLcode res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
LE_ERROR("libcurl returned error (%d): %s", res, curl_easy_strerror(res));
// TODO: better way to encode CURL errors?
ResponseJson->enqueue(std::make_tuple(handle, ""));
le_event_Report(ResponseAvailableEvent, NULL, 0);
}
else
{
std::string json((char*)HttpReceiveBuffer.data, HttpReceiveBuffer.used);
LE_INFO("RECEIVED %d char: %s", HttpReceiveBuffer.used, (char*) HttpReceiveBuffer.data);
ResponseJson->enqueue(std::make_tuple(handle, json));
le_event_Report(ResponseAvailableEvent, NULL, 0);
}
curl_easy_cleanup(curl);
curl_slist_free_all(httpHeaders);
} while (true);
}
