/*
Handle new SMS arrival
*/
void hfpHandleResponseCSRSms(Task task, const struct hfpHandleResponseCSRSms *sms)
{
HFP *hfp = (HFP*)task;
if (hfp->use_csr2csr)
{
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CSR_NEW_SMS_IND, sms->senderNum.length+1);
message->hfp = hfp;
message->index = sms->smsIndex;
message->size_sender_number = sms->senderNum.length+1;
memmove(message->sender_number, sms->senderNum.data, sms->senderNum.length);
message->sender_number[sms->senderNum.length] = '\0';
MessageSend(hfp->clientTask, HFP_CSR_NEW_SMS_IND, message);
if (sms->senderName.length > 0)
{
uint16 length = (sms->senderName.length < HFP_CSR_MAX_STRING) ? sms->senderName.length+1 : HFP_CSR_MAX_STRING; /* AT Parser strings are NOT NULL terminated */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CSR_NEW_SMS_NAME_IND, length);
message->hfp = hfp;
message->index = sms->smsIndex;
message->size_sender_name = length;
memmove(message->sender_name, sms->senderName.data, length-1);
message->sender_name[length-1] = '\0';
MessageSend(hfp->clientTask, HFP_CSR_NEW_SMS_NAME_IND, message);
}
}
}
/*
Handle +CSR= sent from AG
*/
void hfpHandleResponseCSRModAgIndicators(Task task, const struct hfpHandleResponseCSRModAgIndicators *inds)
{
HFP *hfp = (HFP*)task;
if (hfp->use_csr2csr)
{
uint16 num = inds->p.count;
uint16 cnt;
struct value_hfpHandleResponseCSRModAgIndicators_p ind;
/* Allocate message */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CSR_MODIFY_AG_INDICATORS_IND, (sizeof(hfp_csr_mod_indicator) * num));
message->hfp = hfp;
message->size_indicators = num;
for (cnt = 0; cnt < num; cnt++)
{
/* get indicator */
ind = get_hfpHandleResponseCSRModAgIndicators_p(&inds->p, cnt);
/* add to buffer */
message->indicators[cnt].indicator = ind.ind;
message->indicators[cnt].value = ind.val;
}
/* Send message */
MessageSend(hfp->clientTask, HFP_CSR_MODIFY_AG_INDICATORS_IND, message);
}
}
/****************************************************************************
NAME
sendCallWaitingNotificationToApp
DESCRIPTION
Send call waiting notification to the application
RETURNS
void
*/
static void sendCallWaitingNotificationToApp(hfp_link_data* link, uint8 type, uint16 size_number, const uint8 *number, uint16 size_name, const uint8* name)
{
/* Don't exceed max length */
if(size_number >= HFP_MAX_ARRAY_LEN)
size_number = HFP_MAX_ARRAY_LEN - 1;
if(size_name >= (HFP_MAX_ARRAY_LEN - size_number))
size_name = (HFP_MAX_ARRAY_LEN - size_number - 1);
/* Only pass this info to the app if the HFP supports this functionality */
if(hfFeatureEnabled(HFP_THREE_WAY_CALLING))
{
/* Allow room for NULLs */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CALL_WAITING_IND, size_number + size_name + 1);
message->priority = hfpGetLinkPriority(link);
message->number_type = hfpConvertNumberType(type);
/* Set offsets */
message->offset_number = 0;
message->offset_name = size_number + 1;
/* Don't report NULLs in sizes */
message->size_number = size_number;
message->size_name = size_name;
/* Copy data into the message */
memmove(message->caller_info + message->offset_number, number, size_number);
memmove(message->caller_info + message->offset_name, name, size_name);
/* NULL terminate strings */
message->caller_info[message->offset_number + size_number] = '\0';
message->caller_info[message->offset_name + size_name] = '\0';
MessageSend(theHfp->clientTask, HFP_CALL_WAITING_IND, message);
}
}
static void sendCallerIdMsgToApp(hfp_link_data* link, uint8 type, uint16 size_name, const uint8* name, uint16 size_number, const uint8 *number)
{
if(size_number || size_name)
{
/* Don't exceed max length */
if(size_number >= HFP_MAX_ARRAY_LEN)
size_number = HFP_MAX_ARRAY_LEN - 1;
if(size_name >= (HFP_MAX_ARRAY_LEN - size_number))
size_name = (HFP_MAX_ARRAY_LEN - size_number - 1);
/* If the local device does not support CLI presentation just ignore this */
if(hfFeatureEnabled(HFP_CLI_PRESENTATION))
{
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CALLER_ID_IND, size_number + size_name + 1);
message->priority = hfpGetLinkPriority(link);
message->number_type = hfpConvertNumberType(type);
/* Set offsets */
message->offset_number = 0;
message->offset_name = size_number + 1;
/* Don't report NULLs in sizes */
message->size_number = size_number;
message->size_name = size_name;
/* Copy data into the message */
memmove(message->caller_info + message->offset_number, number, size_number);
memmove(message->caller_info + message->offset_name, name, size_name);
/* NULL terminate strings */
message->caller_info[message->offset_number + size_number] = '\0';
message->caller_info[message->offset_name + size_name] = '\0';
MessageSend(theHfp->clientTask, HFP_CALLER_ID_IND, message);
}
}
}
/*
Handle Unsolicited +CSRTTS AT response
*/
void hfpHandleResponseCSRText(Task task, const struct hfpHandleResponseCSRText *text)
{
HFP *hfp = (HFP*)task;
if (!hfp->use_csr2csr)
{ /* CSR 2 CSR Extensions not initialised. Ignore */
return;
}
else
{
uint16 length = (text->text.length < HFP_CSR_MAX_STRING) ? text->text.length+1 : HFP_CSR_MAX_STRING; /* AT Parser strings are NOT NULL terminated */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CSR_TXT_IND, length);
message->hfp = hfp;
message->size_text = length;
memmove(message->text, text->text.data, length-1);
message->text[length-1] = '\0';
MessageSend(hfp->clientTask, HFP_CSR_TXT_IND, message);
}
}
/****************************************************************************
NAME
hfpHandleSubscriberNumber
DESCRIPTION
Subscriber number info indication received from the AG
AT INDICATION
+CNUM
RETURNS
void
*/
void hfpHandleSubscriberNumber(Task link_ptr, const struct hfpHandleSubscriberNumber *ind)
{
hfp_link_data* link = (hfp_link_data*)link_ptr;
uint16 size_number = ind->number.length;
if(size_number >= HFP_MAX_ARRAY_LEN)
size_number = HFP_MAX_ARRAY_LEN - 1;
{
/* Allow room to NULL terminate string */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_SUBSCRIBER_NUMBER_IND, size_number);
message->priority = hfpGetLinkPriority(link);
message->service = (hfp_subscriber_service)ind->service;
message->number_type = hfpConvertNumberType(ind->type);
message->size_number = size_number;
memmove(message->number, ind->number.data, size_number);
message->number[size_number] = '\0';
MessageSend(theHfp->clientTask, HFP_SUBSCRIBER_NUMBER_IND, message);
}
}
void hfpSendCsrSmsCfm(HFP *hfp, hfp_lib_status status, uint16 length, const uint8 *sms)
{
uint16 len = (length < HFP_CSR_MAX_STRING) ? length+1 : HFP_CSR_MAX_STRING; /* AT Parser strings are NOT NULL terminated */
MAKE_HFP_MESSAGE_WITH_LEN(HFP_CSR_SMS_CFM, len);
message->hfp = hfp;
message->status = status;
if (len > 1)
{
message->size_sms = len;
memmove(message->sms, sms, len-1);
message->sms[len-1] = '\0';
}
else
{
message->size_sms = 0;
message->sms[0] = 0;
}
MessageSend(hfp->clientTask, HFP_CSR_SMS_CFM, message);
}
/****************************************************************************
NAME
handleUnrecognised
DESCRIPTION
Called when we receive data that cannot be recognised by the AT cmd
parser. To stop us from panicking if the AG is spamming us with
unrecognised data e.g. some out of spec AG is sending us the wrong
commands, we only send the unrecognised data to the app if we have the
resources, otherwise we silently ignore it!
RETURNS
void
*/
void handleUnrecognised(const uint8 *data, uint16 length, Task link_ptr)
{
if (!length)
return;
/*
Create a message and send it directly to the app.
No point going through the state machine because we don't
know what this data is anyway.
*/
{
MAKE_HFP_MESSAGE_WITH_LEN(HFP_UNRECOGNISED_AT_CMD_IND, length);
if (message)
{
message->priority = hfpGetLinkPriority((hfp_link_data*)link_ptr);
message->size_data = length;
memmove(message->data, data, length);
MessageSend(theHfp->clientTask, HFP_UNRECOGNISED_AT_CMD_IND, message);
}
/* If we didn't alloc the mesage don't panic, just ignore this we only send these up if we have spare resources */
}
}
