/*****************************************************************************
*
* KiiPush_init
*
* \param: recvMsgtaskPrio - the priority of task for receiving message
* pingReqTaskPrio - the priority of task for "PINGREQ" task
* callback - the call back function for processing the push message received
*
* \return 0:success; -1: failure
*
* \brief Initializes push
*
*****************************************************************************/
int KiiPush_init(unsigned int recvMsgtaskPrio, unsigned int pingReqTaskPrio, kiiPush_recvMsgCallback callback)
{
kiiPush_endpointState_e endpointState;
memset(&g_kii_push, 0, sizeof(g_kii_push));
g_kii_push.mqttSocket = -1;
if (kiiPush_install() != 0)
{
KII_DEBUG("kii-error: push installation failed !\r\n");
return -1;
}
do {
kiiHal_delayMs(1000);
endpointState = kiiPush_retrieveEndpoint() ;
}while((endpointState == KIIPUSH_ENDPOINT_UNAVAILABLE));
if (endpointState == KIIPUSH_ENDPOINT_READY)
{
kiiHal_taskCreate(NULL,
kiiPush_recvMsgTask,
(void *)callback,
(void *)mKiiPush_taskStk,
KIIPUSH_TASK_STK_SIZE * sizeof(unsigned char),
recvMsgtaskPrio);
kiiHal_taskCreate(NULL,
kiiPush_pingReqTask,
NULL,
(void *)mKiiPush_pingReqTaskStk,
KIIPUSH_PINGREQ_TASK_STK_SIZE * sizeof(unsigned char),
pingReqTaskPrio);
return 0;
}
else
{
return -1;
}
}
static void* kiiPush_recvMsgTask(void* sdata)
{
int remainingLen;
int byteLen;
int topicLen;
int totalLen;
char* p;
int bytes = 0;
size_t rcvdCounter = 0;
KII_PUSH_RECEIVED_CB callback;
kiiPush_endpointState_e endpointState;
kii_t* kii;
kii_mqtt_endpoint_t endpoint;
char installation_id[KII_PUSH_INSTALLATIONID_SIZE + 1];
memset(installation_id, 0x00, sizeof(installation_id));
memset(&endpoint, 0x00, sizeof(kii_mqtt_endpoint_t));
kii = (kii_t*) sdata;
callback = kii->push_received_cb;
for(;;)
{
if(kii->_mqtt_endpoint_ready == 0)
{
if(kiiPush_install(kii, KII_FALSE, installation_id,
sizeof(installation_id) / sizeof(installation_id[0])) != 0)
{
kii->delay_ms_cb(1000);
continue;
}
do
{
kii->delay_ms_cb(1000);
endpointState = kiiPush_retrieveEndpoint(kii, installation_id, &endpoint);
}
while(endpointState == KIIPUSH_ENDPOINT_UNAVAILABLE);
if(endpointState != KIIPUSH_ENDPOINT_READY)
{
continue;
}
M_KII_LOG(kii->kii_core.logger_cb("installationID:%s\r\n", installation_id));
M_KII_LOG(kii->kii_core.logger_cb("mqttTopic:%s\r\n", endpoint.topic));
M_KII_LOG(kii->kii_core.logger_cb("host:%s\r\n", endpoint.host));
M_KII_LOG(kii->kii_core.logger_cb("username:%s\r\n", endpoint.username));
M_KII_LOG(kii->kii_core.logger_cb("password:%s\r\n", endpoint.password));
if(kiiMQTT_connect(kii, &endpoint, KII_PUSH_KEEP_ALIVE_INTERVAL_VALUE) < 0)
{
continue;
}
else if(kiiMQTT_subscribe(kii, endpoint.topic, QOS0) < 0)
{
continue;
}
else
{
kii->_mqtt_endpoint_ready = 1;
}
}
else
{
memset(kii->mqtt_buffer, 0, kii->mqtt_buffer_size);
M_KII_LOG(kii->kii_core.logger_cb("readPointer: %d\r\n", kii->mqtt_buffer + bytes));
rcvdCounter = 0;
kii->mqtt_socket_recv_cb(&kii->mqtt_socket_context, kii->mqtt_buffer, 2, &rcvdCounter);
if(rcvdCounter == 2)
{
if((kii->mqtt_buffer[0] & 0xf0) == 0x30)
{
rcvdCounter = 0;
kii->mqtt_socket_recv_cb(&kii->mqtt_socket_context, kii->mqtt_buffer+2, KII_PUSH_TOPIC_HEADER_SIZE, &rcvdCounter);
if(rcvdCounter == KII_PUSH_TOPIC_HEADER_SIZE)
{
byteLen = kiiMQTT_decode(&kii->mqtt_buffer[1], &remainingLen);
}
else
{
M_KII_LOG(kii->kii_core.logger_cb("kii-error: mqtt decode error\r\n"));
kii->_mqtt_endpoint_ready = 0;
continue;
}
if(byteLen > 0)
{
totalLen =
remainingLen + byteLen + 1; /* fixed head byte1+remaining length bytes + remaining bytes*/
}
else
{
M_KII_LOG(kii->kii_core.logger_cb("kii-error: mqtt decode error\r\n"));
kii->_mqtt_endpoint_ready = 0;
continue;
}
if(totalLen > kii->mqtt_buffer_size)
{
M_KII_LOG(kii->kii_core.logger_cb("kii-error: mqtt buffer overflow\r\n"));
kii->_mqtt_endpoint_ready = 0;
continue;
}
M_KII_LOG(kii->kii_core.logger_cb("decode byteLen=%d, remainingLen=%d\r\n", byteLen, remainingLen));
bytes = rcvdCounter + 2;
M_KII_LOG(kii->kii_core.logger_cb("totalLen: %d, bytes: %d\r\n", totalLen, bytes));
while(bytes < totalLen)
{
M_KII_LOG(kii->kii_core.logger_cb("totalLen: %d, bytes: %d\r\n", totalLen, bytes));
M_KII_LOG(kii->kii_core.logger_cb("lengthToLead: %d\r\n", totalLen - bytes));
M_KII_LOG(kii->kii_core.logger_cb("readPointer: %d\r\n", kii->mqtt_buffer + bytes));
/*kii->socket_recv_cb(&(kii->socket_context), kii->mqtt_buffer + bytes, totalLen - bytes, &rcvdCounter);*/
rcvdCounter = 0;
kii->mqtt_socket_recv_cb(&(kii->mqtt_socket_context), kii->mqtt_buffer + bytes, totalLen - bytes, &rcvdCounter);
M_KII_LOG(kii->kii_core.logger_cb("totalLen: %d, bytes: %d\r\n", totalLen, bytes));
if(rcvdCounter > 0)
{
bytes += rcvdCounter;
M_KII_LOG(kii->kii_core.logger_cb("success read. totalLen: %d, bytes: %d\r\n", totalLen, bytes));
}
else
{
bytes = -1;
M_KII_LOG(kii->kii_core.logger_cb("failed to read. totalLen: %d, bytes: %d\r\n", totalLen, bytes));
break;
}
}
M_KII_LOG(kii->kii_core.logger_cb("bytes:%d, totalLen:%d\r\n", bytes, totalLen));
if(bytes >= totalLen)
{
p = kii->mqtt_buffer;
p++; /* skip fixed header byte1*/
p += byteLen; /* skip remaining length bytes*/
topicLen = p[0] * 256 + p[1]; /* get topic length*/
p = p + 2; /* skip 2 topic length bytes*/
p = p + topicLen; /* skip topic*/
if((remainingLen - 2 - topicLen) > 0)
{
M_KII_LOG(kii->kii_core.logger_cb("Successfully Recieved Push %s\n", p));
callback(kii, p, remainingLen - 2 - topicLen);
}
else
{
M_KII_LOG(kii->kii_core.logger_cb("kii-error: mqtt topic length error\r\n"));
kii->_mqtt_endpoint_ready = 0;
continue;
}
}
else
{
M_KII_LOG(kii->kii_core.logger_cb("kii_error: mqtt receive data error\r\n"));
kii->_mqtt_endpoint_ready = 0;
continue;
}
}
#if(KII_PUSH_PING_ENABLE)
else if((kii->mqtt_buffer[0] & 0xf0) == 0xd0)
{
M_KII_LOG(kii->kii_core.logger_cb("ping resp\r\n"));
}
#endif
}
else
{
M_KII_LOG(kii->kii_core.logger_cb("kii-error: mqtt receive data error\r\n"));
kii->_mqtt_endpoint_ready = 0;
}
}
}
return NULL;
}
