//--------------------------------------------------------------------------------------------------
static void StopCellularNetwork
(
void
)
{
le_onoff_t radioState;
le_result_t result;
result=le_mrc_GetRadioPower(&radioState);
if ((result == LE_OK) && (radioState == LE_OFF))
{
return;
}
else
{
// Try to shutdown the radio anyway
le_mrc_SetRadioPower(LE_OFF);
// Set a timer that gets the current position.
le_timer_Ref_t stopCellNetTimer = le_timer_Create("StopCellNetTimer");
le_clk_Time_t interval = {5, 0}; // 5 seconds
if ( (le_timer_SetHandler(stopCellNetTimer, StopCellNetTimerHandler) != LE_OK) ||
(le_timer_SetRepeat(stopCellNetTimer, 0) != LE_OK) ||
(le_timer_SetInterval(stopCellNetTimer, interval) != LE_OK) ||
(le_timer_Start(stopCellNetTimer) != LE_OK) )
{
LE_ERROR("Could not start the StopCellNet timer!");
}
}
}
//--------------------------------------------------------------------------------------------------
static void ResetClientWatchdog
(
int32_t timeout ///< [IN] The timeout to reset the watchdog timer to (in milliseconds).
)
{
le_clk_Time_t timeoutValue;
WatchdogObj_t* watchDogPtr = GetClientWatchdogPtr();
if (watchDogPtr != NULL)
{
le_timer_Stop(watchDogPtr->timer);
if (timeout == TIMEOUT_KICK)
{
timeoutValue = watchDogPtr->kickTimeoutInterval;
}
else
{
timeoutValue = MakeTimerInterval(timeout);
}
if (timeout != LE_WDOG_TIMEOUT_NEVER)
{
// timer should be stopped here so this should never fail
// testing
LE_ASSERT(LE_OK == le_timer_SetInterval(watchDogPtr->timer, timeoutValue));
le_timer_Start(watchDogPtr->timer);
}
else
{
LE_DEBUG("Timeout set to NEVER!");
}
}
}
//--------------------------------------------------------------------------------------------------
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 Testle_mcc_HangUpAll()
{
// Set a hang-up timer.
HangUpTimer = le_timer_Create("HangUp");
le_clk_Time_t interval = {10, 0};
LE_ASSERT(le_timer_SetInterval(HangUpTimer, interval) == LE_OK);
LE_ASSERT(le_timer_SetHandler(HangUpTimer, HangUpTimerHandler) == LE_OK);
}
//--------------------------------------------------------------------------------------------------
static le_result_t Testle_mcc_HangUpAll
(
void
)
{
// Set a hang-up timer.
HangUpTimer = le_timer_Create("HangUp");
le_clk_Time_t interval = {10, 0};
LE_ASSERT(le_timer_SetInterval(HangUpTimer, interval) == LE_OK);
LE_ASSERT(le_timer_SetHandler(HangUpTimer, HangUpTimerHandler) == LE_OK);
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
static void StartCellularNetwork
(
void
)
{
le_onoff_t radioState;
le_result_t result;
result=le_mrc_GetRadioPower(&radioState);
if ((result == LE_OK) && (radioState == LE_ON))
{
// Load SIM configuration from secure storage
le_sim_Id_t simSelected = le_sim_GetSelectedCard();
if (le_sim_IsPresent(simSelected))
{
LoadSimFromSecStore(simSelected);
}
// Notify the applications even if the SIM is absent
GetAndSendCellNetStateEvent();
}
else
{
// Try to power ON the radio anyway
le_mrc_SetRadioPower(LE_ON);
// Set a timer that gets the current position.
le_timer_Ref_t startCellNetTimer = le_timer_Create("StartCellNetTimer");
le_clk_Time_t interval = {15, 0}; // 15 seconds
if ( (le_timer_SetHandler(startCellNetTimer, StartCellNetTimerHandler) != LE_OK) ||
(le_timer_SetRepeat(startCellNetTimer, 0) != LE_OK) ||
(le_timer_SetInterval(startCellNetTimer, interval) != LE_OK) ||
(le_timer_Start(startCellNetTimer) != LE_OK) )
{
LE_ERROR("Could not start the StartCellNet timer!");
}
}
}
//--------------------------------------------------------------------------------------------------
le_result_t lwm2m_Init
(
void
)
{
// Register handlers for Operation and UpdateRequired indications
pa_avc_SetLWM2MOperationHandler(OperationHandler);
pa_avc_SetLWM2MUpdateRequiredHandler(lwm2m_RegistrationUpdate);
// Get instance creation or deletion events for any asset
assetData_server_SetAllAssetActionHandler(AssetActionHandler, NULL);
// Use a timer to delay reporting instance creation events to the modem for 15 seconds after
// the last creation event. The timer will only be started when the creation event happens.
le_clk_Time_t timerInterval = { .sec=15, .usec=0 };
RegUpdateTimerRef = le_timer_Create("RegUpdate timer");
le_timer_SetInterval(RegUpdateTimerRef, timerInterval);
le_timer_SetHandler(RegUpdateTimerRef, RegUpdateTimerHandler);
return LE_OK;
}
//--------------------------------------------------------------------------------------------------
ni_IteratorRef_t ni_CreateIterator
(
le_msg_SessionRef_t sessionRef, ///< [IN] The user session this request occured on.
tu_UserRef_t userRef, ///< [IN] Create the iterator for this user.
tdb_TreeRef_t treeRef, ///< [IN] The tree to create the iterator with.
ni_IteratorType_t type, ///< [IN] The type of iterator we are creating, read or write?
const char* initialPathPtr ///< [IN] The node to move to in the specified tree.
)
//--------------------------------------------------------------------------------------------------
{
LE_ASSERT(treeRef != NULL);
// Allocate the object and setup it's initial properties.
ni_IteratorRef_t iteratorRef = le_mem_ForceAlloc(IteratorPoolRef);
iteratorRef->creationTime = le_clk_GetRelativeTime();
iteratorRef->sessionRef = sessionRef;
iteratorRef->userRef = userRef;
iteratorRef->treeRef = treeRef;
iteratorRef->type = type;
iteratorRef->reference = NULL;
iteratorRef->isClosed = false;
iteratorRef->isTerminated = false;
// Setup the timeout timer for this transaction, if it's been configured.
time_t configTimeout = ic_GetTransactionTimeout();
if (configTimeout > 0)
{
le_clk_Time_t timeout = { configTimeout, 0 };
iteratorRef->timerRef = le_timer_Create("Transaction Timer");
LE_ASSERT(le_timer_SetInterval(iteratorRef->timerRef, timeout) == LE_OK);
LE_ASSERT(le_timer_SetHandler(iteratorRef->timerRef, OnTransactionTimeout) == LE_OK);
LE_ASSERT(le_timer_SetContextPtr(iteratorRef->timerRef, iteratorRef) == LE_OK);
LE_ASSERT(le_timer_Start(iteratorRef->timerRef) == LE_OK);
}
else
{
iteratorRef->timerRef = NULL;
}
// If this is a write iterator, then shadow the tree instead of accessing it directly.
if (iteratorRef->type == NI_WRITE)
{
iteratorRef->treeRef = tdb_ShadowTree(iteratorRef->treeRef);
}
// Get the root node of the requested tree, or if this is a write iterator... Get the shadowed
// root node of the tree.
iteratorRef->currentNodeRef = tdb_GetRootNode(iteratorRef->treeRef);
iteratorRef->pathIterRef = le_pathIter_CreateForUnix("/");
LE_DEBUG("Created a new %s iterator object <%p> for user %u (%s) on tree %s.",
TypeString(type),
iteratorRef,
tu_GetUserId(userRef),
tu_GetUserName(userRef),
tdb_GetTreeName(treeRef));
// If we were given an initial path, go to it now. Otherwise stay on the root node.
if (initialPathPtr)
{
ni_GoToNode(iteratorRef, initialPathPtr);
}
// Update the tree so that it can keep track of this iterator.
tdb_RegisterIterator(treeRef, iteratorRef);
// All done.
return iteratorRef;
}
