src/lynq/lib/liblynq-tele-ril/lynq-riltel/stateManager/stateManager.cpp

/* Copyright Statement:
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein
 * is confidential and proprietary to MediaTek Inc. and/or its licensors.
 * Without the prior written permission of MediaTek inc. and/or its licensors,
 * any reproduction, modification, use or disclosure of MediaTek Software,
 * and information contained herein, in whole or in part, shall be strictly prohibited.
 */
/* MediaTek Inc. (C) 2010. All rights reserved.
 *
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
 * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
 * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
 * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
 * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
 * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
 * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
 * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
 * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
 * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
 * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 *
 * The following software/firmware and/or related documentation ("MediaTek Software")
 * have been modified by MediaTek Inc. All revisions are subject to any receiver's
 * applicable license agreements with MediaTek Inc.
 */
#include "stateManager/stateManager.h"

#include <string>
#include <string.h>
#include <alloca.h>
#include <stdlib.h>
#include <vector>
#include <arpa/inet.h>
#include <string.h>

#include "../util/AtLine.h"
#include "powerManager.h"
#include "util/utils.h"
#include <cutils/jstring.h>
#include <liblog/lynq_deflog.h>
#undef LOG_TAG
#define LOG_TAG "DEMO_MANAGER"

lynqCallStatus s_callStatus = LYNQ_CALL_OFF;

//static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
//RIL_REQUEST_DEVICE_IDENTITY
int getDeviceIdentity(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}
//  RIL_REQUEST_GET_IMEI
int getIMEI(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_GET_IMEISV
int getIMEISV(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_BASEBAND_VERSION
int getBasebandVersion(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_RESET_RADIO
int resetRadio(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_SCREEN_STATE
int getScreenState(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    size_t pos = p.dataPosition();

    p.writeInt32(1);
    p.writeInt32(atoi(argv[1]));

    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_SET_TRM
int setTRM(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
//  android::Parcel p;

//  pRI->pCI->dispatchFunction(p, pRI);
    free(pRI);
    return 0;
}
//RIL_REQUEST_SET_IMS_ENABLE
int setIMSEnable(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    size_t pos = p.dataPosition();

    p.writeInt32(1);
    p.writeInt32(atoi(argv[1]));
    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}
//RIL_REQUEST_OEM_HOOK_RAW
int sendATCMD(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    char *cmd = (char *)argv[1];
    size_t pos = p.dataPosition();
    if (cmd == NULL){
        RLOGD("sendATCMD:cmd is null\n");
        free(pRI);
        return -1;
    }
    int len = strlen(cmd);
    p.writeInt32(len);
    p.write((const void*)cmd,len);
    RLOGD("sendATCMD: %s %d",cmd,strlen(cmd));

    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}
#ifdef KEEP_ALIVE
//RIL_REQUEST_START_KEEPALIVE_PRO
void tranferToNetByteOrder(int type, char* addr, std::vector<uint8_t> & dest) {
    RLOGD("type is %d, addr: %s", type ,addr);
    int ret;
    int len = 0;
    int domain;
    if(type == static_cast<int>(RIL_PacketType::IPV4_TCP) || type == static_cast<int>(RIL_PacketType::IPV4_UDP)) {
        len = sizeof(struct in_addr);
        domain = AF_INET;
    } else if(type == static_cast<int>(RIL_PacketType::IPV6_TCP) || type == static_cast<int>(RIL_PacketType::IPV6_UDP)) {
        int len = sizeof(struct in6_addr);
        domain = AF_INET6;
    }
    if (len > 0) {
        unsigned char buf[len];
        ret = inet_pton(domain, addr, &buf);
        if (ret <= 0) {
            if (ret == 0)
                RLOGE("Not in presentation format");
            else
                RLOGE("inet_pton");
            return;
        }
        for (int i = 0 ; i < len; i++ ) {
            dest.push_back(buf[i]);
            RLOGD("tranferToNetByteOrder[%d]: %d", i,buf[i]);
        }
    }

}

int startKeepAlivePro(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) {
    if (argc != 10){
        RLOGD("startKeepAlivePro parameters  number isn't enough");
        free(pRI);
        return -1;
    }
    RLOGD("startKeepAlivePro");
    std::vector<uint8_t> sourceAddress;
    std::vector<uint8_t> destinationAddress;
    int type = atoi(argv[1]);
    tranferToNetByteOrder(type, argv[2], sourceAddress);
    int sourcePort = atoi(argv[3]);
    tranferToNetByteOrder(type, argv[4], destinationAddress);
    int destinationPort = atoi(argv[5]);
    int netif_id = atoi(argv[6]);
    int keepIdleTime = atoi(argv[7]);
    int keepIntervalTime = atoi(argv[8]);
    int retryCount = atoi(argv[9]);

    android::Parcel p;
    size_t pos = p.dataPosition();

    p.writeInt32(type);
    p.writeByteVector(sourceAddress);
    p.writeInt32(sourcePort);
    p.writeByteVector(destinationAddress);
    p.writeInt32(destinationPort);
    p.writeInt32(netif_id);
    p.writeInt32(keepIdleTime);
    p.writeInt32(keepIntervalTime);
    p.writeInt32(retryCount);

    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

//RIL_REQUEST_STOP_KEEPALIVE_PRO
int stopKeepAlivePro(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) {
    if (argc != 2){
        RLOGD("stopKeepAlivePro parameters  number isn't enough");
        free(pRI);
        return -1;
    }
    RLOGD("stopKeepAlivePro");
    android::Parcel p;
    uint32_t id = atoi(argv[1]);
    RLOGD("stopKeepAlivePro sesssion id:%d", id);
    size_t pos = p.dataPosition();
    p.writeInt32(1);
    p.writeInt32(id);

    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}

void composeMsg(int request,const void* data, size_t datalen) {
    int* p_int = (int*) (data);
    int numInts = datalen / sizeof(int);
    if (numInts < 2) {
        RLOGD("%s error.", android::requestToString(request));
        std::string fail(android::requestToString(request));
        fail.append(",fail");
        sendKeepAlive(fail.c_str());
        return;
    }
    std::string msg(android::requestToString(request));
    if(request == RIL_REQUEST_START_KEEPALIVE_PRO) {
        msg.append(",ok");
    }
    int sessionHandle = p_int[0];
    int code = p_int[1];
    msg.append(",");
    msg.append(std::to_string(sessionHandle));
    msg.append(",");
    msg.append(std::to_string(code));
    RLOGD("%s response(%s)", android::requestToString(request),msg.c_str());
    sendKeepAlive(msg.c_str());
}

void handleKeepAliveResponse(int request, const void* data, size_t datalen, RIL_SOCKET_ID soc_id, bool is_error) {
    RLOGD("handleKeepAliveResponse(%s) is_error: %d", android::requestToString(request),is_error);
    if(is_error) {
        if(request == RIL_REQUEST_START_KEEPALIVE_PRO) {
            sendKeepAlive("RIL_REQUEST_START_KEEPALIVE_PRO,fail");
        } else if(request == RIL_REQUEST_STOP_KEEPALIVE_PRO) {
            sendKeepAlive("RIL_REQUEST_STOP_KEEPALIVE_PRO,fail");
        }
    } else {
        if(request == RIL_REQUEST_START_KEEPALIVE_PRO) {
            composeMsg(request, data, datalen);
        } else if(request == RIL_REQUEST_STOP_KEEPALIVE_PRO) {
            sendKeepAlive("RIL_REQUEST_STOP_KEEPALIVE_PRO,ok");
        } else if (request == RIL_UNSOL_KEEPALIVE_STATUS_PRO) {
            composeMsg(request, data, datalen);
        }
    }
}
#endif /*KEEP_ALIVE*/

void parseAtCmd(const char* line) {
    if (strstr(line, "+ETHERMAL") != NULL) {
        RLOGD("parse at command: ETHERMAL");
        AtLine* atLine = new AtLine(line, NULL);
        int err;
        atLine->atTokStart(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("this is not a valid response string");
            return;
        }
        int rat = atLine->atTokNextint(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("parse rat fail");
            return;
        }
        int temperature = atLine->atTokNextint(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("parse temperature fail");
            return;
        }
        int tx_power = atLine->atTokNextint(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("parse tx_power fail");
            return;
        }
        RLOGD("[tx_power]rat: %d, temperature: %d, tx_power: %d", rat, temperature, tx_power);
        printf("[tx_power]rat: %d, temperature: %d, tx_power: %d\n", rat, temperature, tx_power);
        delete atLine;
    } else if (strstr(line, "+ECAL") != NULL) {
        RLOGD("parse at command: ECAL");
        AtLine* atLine = new AtLine(line, NULL);
        int err;
        atLine->atTokStart(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("this is not a valid response string");
            return;
        }
        int cal = atLine->atTokNextint(&err);
        if (err < 0) {
            delete atLine;
            RLOGW("parse rat fail");
            return;
        }
        RLOGD("calibration data is %s", cal == 1 ? "download" : "not download");
        if (cal == 0) {
            printf(
                    "************************************************\n*** NOTICE: calibration data is not download ***\n************************************************\n");
        }
        delete atLine;
    }
}
//RIL_REQUEST_SET_IMSCFG
int setIMSCfg(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
{
    android::Parcel p;
    size_t pos = p.dataPosition();

    p.writeInt32(6);
    p.writeInt32(atoi(argv[1]));
    p.writeInt32(atoi(argv[2]));
    p.writeInt32(atoi(argv[3]));
    p.writeInt32(atoi(argv[4]));
    p.writeInt32(atoi(argv[5]));
    p.writeInt32(atoi(argv[6]));
    p.setDataPosition(pos);
    pRI->pCI->dispatchFunction(p, pRI);
    return 0;
}
/*****mobiletek-add****/
lynq_call_list **pCallList=NULL;
//lynq_call_list *CallList=NULL;
//callInfoLink * callInfoLinkhead = (callInfoLink *)malloc(sizeof(callInfoLink));
//memset(callInfoLinkhead,0,sizeof(callInfoLink));
int calllistNum=0;
int flag=0;
callInfoLink * create_callInfoLink()
{
    callInfoLink * head = (callInfoLink *)malloc(sizeof(callInfoLink));
    if(head==NULL)
    {
         return NULL;
    }
    memset(head,0,sizeof(callInfoLink));
    head->next=NULL;
    head->calllist_tok=NULL;
    //head->parcel=NULL;
    return head;
}
lynqQueue * createLynqQueue()
{
    lynqQueue *head = (lynqQueue *)malloc(sizeof(lynqQueue));
    if(head==NULL)
    {
         return NULL;
    }
    memset(head,0,sizeof(lynqQueue));
    head->next=NULL;
    return head;
}
lynqQueue * searchRequestinQueue(int32_t request,lynqQueue *head)
{
    lynqQueue *p;
    p=head;
    if(p!=NULL)
    {
       do
       {
           if(p->request == request)
           {
              return p;
           }
            
           p = p->next;
       } while (p != NULL);
    }
    RLOGD("search  request %d failure from lynq queue",request);
    return NULL;
}
lynqQueue * searchTokeninQueue(int32_t token,lynqQueue *head)
{
    lynqQueue *p;
    p=head;
    if(p!=NULL)
    {
       do
       {
           if(p->token == token)
           {
              return p;
           }
           p = p->next;
       } while (p != NULL);
    }
    LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
    return NULL;
}
int lynqApiInit()
{
    LynqQueueHead=createLynqQueue();
    LYDBGLOG("[%s] init head is %p\n",__FUNCTION__,LynqQueueHead);
    if(LynqQueueHead==NULL)
    {
        LYERRLOG("[%s] init call  lynq queue head fail,maybe malloc fail!",__FUNCTION__);
        return -1;
    }
    return 0;
}
int getCallStatus(void)
{
    return s_callStatus;
}
int setCallStatus(lynqCallStatus callStatus)
{
    s_callStatus = callStatus;
    return 0;
}

simInfoLink *createSimInfoLink()
{
    simInfoLink * head = (simInfoLink *)malloc(sizeof(simInfoLink));
    if(head==NULL)
    {
         RLOGD("create sim info queue fail");
         return NULL;
    }
    memset(head,0,sizeof(simInfoLink));
    head->next=NULL;
    return head;
}
int callListToParcel(void *response,size_t responselen,Parcel &p);
static int updateCallStatus(void *response,size_t responselen);
int imsiToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int simInfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int lastCallFailCauseToParce(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int dataCalllistToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int currentOperatorInfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int queryNetSelectModeToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
static int stringsToParecl(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
static int stringToParecl(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
static int intToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
static int updateErrnoToQueue(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int cellinfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int neighboringCellToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int solicitedSignalStrengthToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
int smsResponseToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
 int updateE_status(int32_t token,RIL_Errno respe)
{
    lynqQueue *node =NULL;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node)
    {
        node->t_Errno = respe;
        node->E_status = 1;
    }
    return 0;
}
void LYNQ_DispatchResponse(int request,int32_t token,RIL_Errno respe,lynq_call_list**nodeCallList,void *response,size_t respLen)
{

    switch (request) {
        case RIL_REQUEST_DIAL:
        case RIL_REQUEST_ANSWER:
        case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
        case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
        case RIL_REQUEST_SEPARATE_CONNECTION:
        case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
        case RIL_REQUEST_CONFERENCE:
        case RIL_REQUEST_HANGUP:
        case RIL_REQUEST_UDUB:
        case RIL_REQUEST_DTMF:
        {
            /*
            lynqQueue *node =NULL;
            node = searchTokeninQueue(token,LynqQueueHead);
            if(node)
            {
                node->t_Errno = respe;
                node->E_status = 1;
            }
            */
            updateE_status(token,respe);
            break;
        }
        case RIL_REQUEST_GET_IMSI:
        {
            updateE_status(token,respe);
            imsiToParcel(request,token,response,respLen,respe);
            //addImsiInfo(request,respe,token,simInfoLinkHead,response,respLen);
            break;
        }
        case RIL_REQUEST_GET_SIM_STATUS:
        {
            updateE_status(token,respe);
            simInfoToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_LAST_CALL_FAIL_CAUSE:
        {
            /*
            lynqQueue *node =NULL;
            node = searchTokeninQueue(token,LynqQueueHead);
            if(node)
            {
                node->t_Errno = respe;
                node->E_status = 1;
            }
            */
            updateE_status(token,respe);
            lastCallFailCauseToParce(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_DATA_CALL_LIST:
        {
            dataCalllistToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_OPERATOR:
        case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS:
        case RIL_REQUEST_DATA_REGISTRATION_STATE:
        case RIL_REQUEST_VOICE_REGISTRATION_STATE:
        {
            //currentOperatorInfoToParcel(request,token,response,respLen,respe);
            updateE_status(token,respe);
            stringsToParecl(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
        case RIL_REQUEST_IMS_REGISTRATION_STATE:
        case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
        case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE:
        case RIL_REQUEST_VOICE_RADIO_TECH:
        case RIL_REQUEST_WRITE_SMS_TO_SIM:
        {
            intToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
        case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL:
        case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
        case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE:
        case RIL_REQUEST_SET_BAND_MODE:
        case RIL_REQUEST_RADIO_POWER:
        case RIL_REQUEST_MODEM_POWERON:
        case RIL_REQUEST_MODEM_POWEROFF:
        case RIL_REQUEST_DELETE_SMS_ON_SIM:
        case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS:
        case RIL_REQUEST_SET_SMSC_ADDRESS:
        {
            updateErrnoToQueue(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_GET_CELL_INFO_LIST:
        {
            cellinfoToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS:
        {
            neighboringCellToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_SIGNAL_STRENGTH:
        {
            solicitedSignalStrengthToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_SEND_SMS:
        case RIL_REQUEST_IMS_SEND_SMS:
        {
            smsResponseToParcel(request,token,response,respLen,respe);
            break;
        }
        case RIL_REQUEST_GET_SMSC_ADDRESS:
        {
            stringToParecl(request,token,response,respLen,respe);
            break;
        }
        default:
            break;
        }
}
callInfoLink* addCallInfo(int32_t tok,int request,RIL_Errno respe,callInfoLink* head,lynq_call_list**nodeCallList)
{
    if (head == NULL)
    {
         flag= 0;
         RLOGD("callInfoLink is null,set flag to 0!");
        return NULL;
    }
    if (flag == 0) 
    {
        head->token = tok;
        head->Error_tok = respe;
        head->request=request;
        if(nodeCallList!=NULL)
        {
            head->calllist_tok=nodeCallList;
        }
        head->next = NULL;
        flag=1;
    }
    else
    {
        if (head->token != tok)
        {
            callInfoLink* Node = (callInfoLink*)malloc(sizeof(callInfoLink));
            memset(Node,0,sizeof(callInfoLink));
            if (Node)
            {
                printf("new node p is %p\n", Node);
                Node->token = tok;
                Node->Error_tok = respe;
                Node->request=request;
                if(nodeCallList!=NULL)
                {
                    Node->calllist_tok=nodeCallList;
                }
                Node->next = head;
                head = Node;
            }
            else 
            {
                RLOGD("malloc Node failed!\n");
                flag = 0;
                return NULL;
            }
        }
        else
        {
            //head->token = tok;
            //head->Error_tok = respe;
            head->calllist_tok=nodeCallList;
        }

    }
    return head;
}
void updateLinkCallInfo(callInfoLink * callInfoLinkhead,lynq_call_list**nodeCallList)
{
    callInfoLink *p;
    p=callInfoLinkhead;
    if(p!=NULL)
    {
       do
       {
           p->calllist_tok=nodeCallList;
           p = p->next;
       } while (p != NULL);
    }
}
static int dispatchEvent(lynqQueue *node,void * response, size_t responselen, Parcel & p)
{
    //printf("request is %d\n",node->request);
    switch(node->request)
    {
        case RIL_REQUEST_DIAL:
        case RIL_REQUEST_ANSWER:
        //case RIL_REQUEST_HANGUP:
        //case RIL_REQUEST_UDUB:
        case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
        case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
        case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
        case RIL_REQUEST_CONFERENCE:
        //case RIL_REQUEST_SEPARATE_CONNECTION:
        //case RIL_REQUEST_DTMF:
        {
            //printf("request is %d\n",node->request);
            callListToParcel(response, responselen, p);
            break;
        }
        /*
        case RIL_REQUEST_HANGUP:
        {
            break;
        }
        */
        default:
            //printf("other test\n");
            //updateCallStatus(response,responselen);
            break;
    }
     return 0;
}
void updateAsyncData(RIL_Token t, RIL_Errno e,void * response, size_t responselen,lynqQueue* head)
{
    lynqQueue *p;
    p=head;
    if(p!=NULL)
    {
       do
       {
           dispatchEvent(p, response,responselen, p->parcel);
           p = p->next;
       } while (p != NULL);
    }
    updateCallStatus(response,responselen);
    return;
}
void printlist(callInfoLink * callInfoLinkhead)
{
    callInfoLink* p;
    p = callInfoLinkhead;
    if (p != NULL)
    {
        do
        {
            LYDBGLOG("[%s] token=%x Error_tok=%d,request =%d",__FUNCTION__,p->token, p->Error_tok,p->request);
            p = p->next;
        } while (p != NULL);
    }
    return ;
}
void setCallList_old(int token,RIL_Call **pCallLists,size_t respLen,RIL_Errno error)
{
    /*
    if(pCallLists!=NULL)
    {
        printf("DEMO_MANAGER:resplen is %d\n",respLen);
        for(int i=0;i<respLen;i++)
        {
            RIL_Call* p_cur = pCallLists[i];
            printf("state is %d\n",p_cur->state);
            RLOGD("state is %d\n",p_cur->state);
            printf("callid is %d\n",p_cur->index);
            RLOGD("callid is %d\n",p_cur->index);
            printf("toa is %d\n",p_cur->toa);
            RLOGD("toa is %d\n",p_cur->toa);
            printf("addr is %s\n",p_cur->number);
            RLOGD("addr is %s\n",p_cur->number);
        }
    }
    */
    if(calllistNum!=0)
    {
        printf("calllistNum!=0\n");
        RLOGD("calllistNum!=0\n");
        if(calllistNum!=respLen)
        {
            if (pCallList != NULL)
            {
                for (int index = 0; index < calllistNum; index++ ) 
                {
                    if (pCallList[index] != NULL) 
                    {
                        free(pCallList[index]->addr);
                        pCallList[index]->addr=NULL;
                        free(pCallList[index]);
                    }
                }
            free(pCallList);
            pCallList=NULL;
            RLOGD("free pCalllist\n");
          }
        if(respLen==0)
        {
           RLOGD("the call list is NULL,the pCalllist is NULL");
           return;
        }
        if(!(pCallList=(lynq_call_list **)malloc(sizeof(lynq_call_list *)*respLen)))
        {
            RLOGD("malloc pCallList failed");
            printf("malloc pCallList failed");
            return;
        }
        
        for(int index=0;index<respLen;index++)
        {
            if((pCallList[index]=(lynq_call_list *)malloc(sizeof(lynq_call_list)))==NULL)
            {    
                RLOGD("malloc CallList failed");
                printf("malloc CallList failed");
                for(int i=0;i<index;i++)
                {
                    free(pCallList[i]->addr);
                    pCallList[i]->addr=NULL;
                    free(pCallList[i]);
                }
                free(pCallList);
                pCallList=NULL;
                return;
            }
            pCallList[index]->addr=(char *)malloc(sizeof(char)*(sizeof(pCallLists[index]->number)+1));
            memcpy(pCallList[index]->addr, pCallLists[index]->number, strlen(pCallLists[index]->number)+1);
            pCallList[index]->token=token;
            //pCallList[index]->addr=pCallLists[index]->number;
            pCallList[index]->callid=pCallLists[index]->index;
            pCallList[index]->callState=pCallLists[index]->state;
            pCallList[index]->toa= pCallLists[index]->toa;
            pCallList[index]->lynq_error=error;
            pCallList[index]->selflen=respLen;
            
        }
        calllistNum=respLen;
      }
      else
      {
        for(int index=0;index<respLen;index++)
        {
            pCallList[index]->addr=(char *)malloc(sizeof(char)*(sizeof(pCallLists[index]->number)+1));
            memcpy(pCallList[index]->addr, pCallLists[index]->number, strlen(pCallLists[index]->number)+1);
            pCallList[index]->token=token;
            //pCallList[index]->addr=pCallLists[index]->number;
            pCallList[index]->callid=pCallLists[index]->index;
            pCallList[index]->callState=pCallLists[index]->state;
            pCallList[index]->toa= pCallLists[index]->toa;
            pCallList[index]->lynq_error=error;
            pCallList[index]->selflen=respLen;
        }
      }
      printf("retrun more than once\n");
      ///pthread_mutex_unlock(&s_startupMutex);
    }
    else
    {
        RLOGD("calllistNum==0\n");
        if((pCallList=(lynq_call_list **)malloc(sizeof(lynq_call_list *)*respLen))==NULL)
        {
            RLOGD("malloc pCallList failed");
            printf("malloc pCallList failed");
            return;
        }
        printf("pCalllist %p\n",pCallList);
        for(int index=0;index<respLen;index++)
        {
            if((pCallList[index]=(lynq_call_list *)malloc(sizeof(lynq_call_list)))==NULL)
            {    
                RLOGD("malloc CallList failed");
                printf("malloc CallList failed");
                for(int i=0;i<index;i++)
                {
                    free(pCallList[i]->addr);
                    pCallList[i]->addr=NULL;
                    free(pCallList[i]);
                }
                free(pCallList);
                pCallList=NULL;
                return;
            }
            pCallList[index]->addr=(char *)malloc(sizeof(char)*(sizeof(pCallLists[index]->number)+1));
            memcpy(pCallList[index]->addr, pCallLists[index]->number, strlen(pCallLists[index]->number)+1);
            pCallList[index]->token=token;
            //pCallList[index]->addr=pCallLists[index]->number;
            pCallList[index]->callid=pCallLists[index]->index;
            pCallList[index]->callState=pCallLists[index]->state;
            pCallList[index]->toa= pCallLists[index]->toa;
            pCallList[index]->lynq_error=error;
            pCallList[index]->selflen=respLen;
            
        }
        calllistNum=respLen;
        printf("retrun first\n");
        //pthread_mutex_unlock(&s_startupMutex);
    }
}
static void StringWriteToParcel(Parcel &p, const char *s) {
    char16_t *s16;
    size_t s16_len;
    s16 = strdup8to16(s, &s16_len);
    p.writeString16(s16, s16_len);
    free(s16);
}
char * lynqStrdupReadString(Parcel &p) {
    size_t stringlen;
    const char16_t *s16;

    s16 = p.readString16Inplace(&stringlen);
    return strndup16to8(s16, stringlen);
}
void setCallList(int token,RIL_Call **pCallLists,size_t respLen,RIL_Errno error)
{
    if(respLen==0)
    {
          LYDBGLOG("[%s] the call list is NULL",__FUNCTION__);
          return;
     }
    if((pCallList=(lynq_call_list **)malloc(sizeof(lynq_call_list *)*respLen))==NULL)
    {
        LYDBGLOG("[%s] malloc pCallList failed",__FUNCTION__);
        return;
    }
    //printf("pCalllist %p\n",pCallList);
    for(int index=0;index<respLen;index++)
    {
        if((pCallList[index]=(lynq_call_list *)malloc(sizeof(lynq_call_list)))==NULL)
        {    
            LYDBGLOG("[%s]malloc CallList failed",__FUNCTION__);
            for(int i=0;i<index;i++)
            {
                free(pCallList[i]->addr);
                pCallList[i]->addr=NULL;
                free(pCallList[i]);
            }
            free(pCallList);
            pCallList=NULL;
            return;
        }
        pCallList[index]->addr=(char *)malloc(sizeof(char)*(sizeof(pCallLists[index]->number)+1));
        memcpy(pCallList[index]->addr, pCallLists[index]->number, strlen(pCallLists[index]->number)+1);
        pCallList[index]->token=token;
        pCallList[index]->callid=pCallLists[index]->index;
        pCallList[index]->callState=pCallLists[index]->state;
        pCallList[index]->toa= pCallLists[index]->toa;
        pCallList[index]->lynq_error=error;
        pCallList[index]->isMT = pCallLists[index]->isMT;
        pCallList[index]->selflen=respLen;
   }
}
void freeCallList(int respLen)
{
    if(respLen!=0)
    {    
        LYDBGLOG("call on going");
        return;
    }
    if (pCallList != NULL)
    {
       if (pCallList[0]==NULL)
       {
           LYDBGLOG("pCalllist pCallList[0]");
           return;
       }
        int length=pCallList[0]->selflen;
        for (int index = 0; index < length; index++ ) 
        {
            if (pCallList[index] != NULL) 
            {
                free(pCallList[index]->addr);
                pCallList[index]->addr=NULL;
                free(pCallList[index]);
            }
        }
    free(pCallList);
    pCallList=NULL;
    LYDBGLOG("free pCalllist");
    }
    return ;
    
}
void updateSimStatus(void *response,size_t respLen,simInfoLink *msg)
{
    if(response!=NULL)
    {
        //printf("RIL_CardStatus_v6 length is %d\n",sizeof (RIL_CardStatus_v6));
        if (respLen == sizeof (RIL_CardStatus_v6)) 
        {
            RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
            msg->card_status=p_cur->card_state;
            for(int i=0;i<p_cur->num_applications;i++)
            {
                msg->card_type=p_cur->applications[i].app_type;
                msg->pin_state=p_cur->applications[i].pin1;
            }
        }
    }
return;
}
void addSimInfo(int request,RIL_Errno respe,int32_t token,simInfoLink *head,void *response,size_t respLen)
{
    if(head==NULL)
    {
        LYDBGLOG("[%s] the head is NULL!\n",__FUNCTION__);
        return;
    }
    LYDBGLOG("addSimInfo respLen is %d\n",respLen);
    if(response==NULL)
    {
        LYDBGLOG("the get sim status response is NULL!\n");
        return;
    }
    simInfoLink * temp=head;
    do
    {
        if(temp->token==token)
        {
            temp->Error_tok=respe;
            updateSimStatus(response,respLen,temp);
            temp->simInfoLen=respLen/sizeof(RIL_CardStatus_v6);
            break;
        }
        temp=temp->next;
    }while(temp!=NULL);
    return;
}
simInfoLink * inSimQueue(int request,int32_t token,simInfoLink *head)
{
    simInfoLink* Node = (simInfoLink*)malloc(sizeof(simInfoLink));
    memset(Node,0,sizeof(simInfoLink));
    if (Node)
    {
        Node->token = token;
        Node->request=request;
        Node->next = head;
        head = Node;
    }
    else 
    {
        LYDBGLOG("[%s] malloc Node failed!\n",__FUNCTION__);
        return NULL;
    }
    return head;

}
static lynqQueue * lynqInQueue(int request,int32_t token,lynqQueue *head)
{
    lynqQueue* Node = (lynqQueue*)malloc(sizeof(lynqQueue));
    memset(Node,0,sizeof(lynqQueue));
    if (Node)
    {
        Node->token = token;
        Node->request=request;
        Node->next = head;
        head = Node;
        LYDBGLOG("[%s] node->token is %x,request is %d\n",__FUNCTION__,Node->token,Node->request);
    }
    else 
    {
        LYDBGLOG("[%s] malloc Node failed!\n",__FUNCTION__);
        return head;
    }
    return head;

}
simInfoLink * deSimQueue(simInfoLink *head,int32_t token)
{
    simInfoLink *p,*temp;
    p = head;
    if((head ==NULL)||(head->next==NULL))
    {
        LYDBGLOG("deSimQueue head is NULL\n");
        return head;
    }
    //delete head note
    if(p->token == token)
    {
        temp=head->next;
        free(head);
        head =NULL;
        head = temp;
        return head;
    }
    //delete intermediate node
    do
    {
        temp = p;
        p=p->next;
        if(p->token==token)
        {
            temp->next=p->next;
            free(p);
            p=NULL;
            return head;
        }
    }while(p->next->next!=NULL);
    return head;
}
void lynqDeQueue(int32_t token)
{
    lynqQueue *p,*temp;
    p = LynqQueueHead;
    if((p ==NULL)||(p->next==NULL))
    {
        LYDBGLOG("[%s] lynqDeQueue head is NULL\n",__FUNCTION__);
        return 0;
        //return head;
    }
    //delete head note
    if(p->token == token)
    {
        temp=p->next;
        free(p);
        p =NULL;
        LynqQueueHead = temp;
        LYDBGLOG("[%s] delete head note!!\n",__FUNCTION__);
        return 0;
        //return head;
    }
    //delete intermediate node
    do
    {
        temp = p;
        p=p->next;
        if(p->token==token)
        {
            temp->next=p->next;
            free(p);
            p=NULL;
            LYDBGLOG("[%s] delete intermediate node!!\n",__FUNCTION__);
            //return head;
            return 0;
        }
    }while(p->next->next!=NULL);
    LYDBGLOG("[%s] Not find this token,token is %d!!\n",__FUNCTION__,token);
    return 0;
}
void LYNQ_DispatchRequest(int32_t request,int32_t token)
{
    switch(request)
    {
    //SIM CONTROLLER
        case RIL_REQUEST_GET_SIM_STATUS:
        case RIL_REQUEST_GET_IMSI:
    //CC CONTROLLER
        case RIL_REQUEST_DIAL:
        case RIL_REQUEST_ANSWER:
        case RIL_REQUEST_LAST_CALL_FAIL_CAUSE:
        case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
        case RIL_REQUEST_HANGUP:
        case RIL_REQUEST_UDUB:
        case RIL_REQUEST_DTMF:
        case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
        case RIL_REQUEST_SEPARATE_CONNECTION:
        case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
        case RIL_REQUEST_CONFERENCE:
    //DATA CONTROLLER
        //case RIL_REQUEST_SETUP_DATA_CALL:
        case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE:
        case RIL_REQUEST_DATA_CALL_LIST:
    //NETWORK CONTROLLER
        case RIL_REQUEST_OPERATOR:
        case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
        case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
        case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL:
        case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS:
        case RIL_REQUEST_DATA_REGISTRATION_STATE:
        case RIL_REQUEST_VOICE_REGISTRATION_STATE:
        case RIL_REQUEST_IMS_REGISTRATION_STATE:
        case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
        case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
        case RIL_REQUEST_GET_CELL_INFO_LIST:
        case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE:
        case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS:
        case RIL_REQUEST_SET_BAND_MODE:
        case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE:
        case RIL_REQUEST_RADIO_POWER:
        case RIL_REQUEST_VOICE_RADIO_TECH:
        case RIL_REQUEST_SIGNAL_STRENGTH:
        case RIL_REQUEST_MODEM_POWEROFF:
        case RIL_REQUEST_MODEM_POWERON:
    //SMS CONTROLLER
        case RIL_REQUEST_SEND_SMS:
        case RIL_REQUEST_IMS_SEND_SMS:
        case RIL_REQUEST_WRITE_SMS_TO_SIM:
        case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS:
        case RIL_REQUEST_DELETE_SMS_ON_SIM:
        case RIL_REQUEST_GET_SMSC_ADDRESS:
        case RIL_REQUEST_SET_SMSC_ADDRESS:
        {
            //simInfoLinkHead=inSimQueue(request, token, simInfoLinkHead);
            LynqQueueHead = lynqInQueue(request,token,LynqQueueHead);
            break;
        }
        default:
            break;
    }
    return;
}
void addImsiInfo(int request,RIL_Errno respe,int32_t token,simInfoLink *head,void *response,size_t respLen)
{
    if(head==NULL)
    {
        LYDBGLOG("[addImsiInfo] the head is NULL!\n");
        return;
    }
    LYDBGLOG("addImsiInfo respLen is %d\n",respLen);
    if(response==NULL)
    {
        LYDBGLOG("the get IMSI response is NULL!\n");
        return;
    }
    simInfoLink * temp=head;
    do
    {
        if(temp->token==token)
        {
            temp->Error_tok=respe;
            memcpy(temp->imsi,((char *)response),respLen+1);
            //temp->imsi = (char *)response;
            temp->simInfoLen=respLen/strlen((char*)response);
            break;
        }
        temp=temp->next;
    }while(temp!=NULL);
    return;
}
static int updateCallStatus(void *response,size_t responselen)
{
    if(response ==NULL||responselen==0)
    {
        s_callStatus=LYNQ_CALL_OFF;
        LYDBGLOG("[%s] update call status to call off\n",__FUNCTION__);
    }
    return 0;
}
int callListToParcel(void *response,size_t responselen,Parcel &p)
{
    int num;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        s_callStatus=LYNQ_CALL_OFF;
        return -1;
    }
    if(response ==NULL)
    {
        s_callStatus=LYNQ_CALL_OFF;
        LYDBGLOG("[%s] update call state to CALL_OFF!\n",__FUNCTION__);
    }
    if (responselen % sizeof (RIL_Call *) != 0) {
        LYDBGLOG("responseCallList: invalid response length %d expected multiple of %d\n",
            (int)responselen, (int)sizeof (RIL_Call *));
        s_callStatus=LYNQ_CALL_OFF;
        return -1;
    }
    /* number of call info's */
    num = responselen / sizeof(RIL_Call *);
    p.setDataPosition(0);
    p.writeInt32(num);
    for (int i = 0 ; i < num ; i++) 
    {
        RIL_Call *p_cur = ((RIL_Call **) response)[i];
        /* each call info */
        p.writeInt32(p_cur->state);
        //printf("callListToParcel state is %d\n",p_cur->state);
        p.writeInt32(p_cur->index);
        p.writeInt32(p_cur->toa);
        p.writeInt32(p_cur->isMpty);
        p.writeInt32(p_cur->isMT);
        StringWriteToParcel(p, p_cur->number);
        s_callStatus=LYNQ_CALL_ON;
        //printf("----parcel write success----\n");
    }
    return 0;
}
int imsiToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] get imsi fail\n");
        return -1;
    }
    /* number of imsi info's */
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    num=responselen/strlen((char*)response);
    node->parcel.writeInt32(num);
    for (int i = 0 ; i < num ; i++) 
    {
        StringWriteToParcel(node->parcel, response);
        LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    }
    return 0;
}
int simInfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] get sim fail\n",__FUNCTION__);
        return -1;
    }
    /* number of imsi info's */
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] simInfoToParcel search token %d failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (responselen == sizeof (RIL_CardStatus_v6)) 
    {
        RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
        node->parcel.writeInt32(p_cur->card_state);
        node->parcel.writeInt32(p_cur->num_applications);
        for(int i=0;i<p_cur->num_applications;i++)
        {
            node->parcel.writeInt32(p_cur->applications[i].app_type);
            node->parcel.writeInt32(p_cur->applications[i].pin1);
            LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
        }
    }
    return 0;
}
int lastCallFailCauseToParce(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("get last call fail cause fail\n");
        return -1;
    }
    /* number of imsi info's */
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    node->parcel.writeInt32(responselen);
    RIL_LastCallFailCauseInfo *p_cur = (RIL_LastCallFailCauseInfo *)response;
    //num=responselen/strlen((char*)response);
    node->parcel.writeInt32(p_cur->cause_code);
    StringWriteToParcel(node->parcel, p_cur->vendor_cause);
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;

}
int dataCalllistToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        RLOGD("get data call list fail\n");
        return -1;
    }
    /* number of data call list info's */
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    num = responselen/sizeof(RIL_Data_Call_Response_v11);
    node->parcel.writeInt32(num);
    RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *)response;
    for(int i=0;i<num;i++)
    {
        //RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *)response;
        node->parcel.writeInt32(p_cur[i].status);
        node->parcel.writeInt32(p_cur[i].suggestedRetryTime);
        node->parcel.writeInt32(p_cur[i].cid);
        node->parcel.writeInt32(p_cur[i].active);
        StringWriteToParcel(node->parcel, p_cur[i].type);
        StringWriteToParcel(node->parcel, p_cur[i].ifname);
        StringWriteToParcel(node->parcel, p_cur[i].addresses);
        StringWriteToParcel(node->parcel, p_cur[i].dnses);
        StringWriteToParcel(node->parcel, p_cur[i].gateways);
        StringWriteToParcel(node->parcel, p_cur[i].pcscf);
        node->parcel.writeInt32(p_cur[i].mtu);
    }
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;

}
int currentOperatorInfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    char **pString=NULL;
    char * subString=NULL;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        RLOGD("response is null\n");
        return -1;
    }
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    num = responselen/(sizeof(char*));
    LYDBGLOG("currentOperatorInfoToParcel is %d\n",num);
    node->t_Errno = e;
    pString=(char **)response;
    node->parcel.writeInt32(num);
    for (int i=0;i<num;i++)
    {
        subString = pString[i];
        LYDBGLOG("[%s] subString is %s\n",__FUNCTION__,subString);
        StringWriteToParcel(node->parcel,subString);
    }
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;

}
//int queryNetSelectModeToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e);
static int stringsToParecl(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    char **pString=NULL;
    char * subString=NULL;
    if (response == NULL && responselen != 0){
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("response is null\n");
        node = searchTokeninQueue(token,LynqQueueHead);
        if(node==NULL)
        {
            LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
            return -1;
        }
        node->parcel.writeInt32(0);
        node->t_Errno = e;
        return -1;
    }
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s][%d] search token %x failure from lynq queue\n",__FUNCTION__,__LINE__,token);
        return -1;
    }
    num = responselen/(sizeof(char*));
    node->t_Errno = e;
    pString=(char **)response;
    node->parcel.writeInt32(num);
    for (int i=0;i<num;i++)
    {
        subString = pString[i];
        LYDBGLOG("[%s] subString is %s\n",__FUNCTION__,subString);
        StringWriteToParcel(node->parcel,subString);
    }
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;
}
static int stringToParecl(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num;
    lynqQueue * node;
    char *pString=NULL;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0){
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] response is null\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    pString=(char *)response;
    node->parcel.writeInt32(1);
    StringWriteToParcel(node->parcel,pString);
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;
}

static int intToParcel(int32_t request, int32_t token, void * response, size_t responselen, RIL_Errno e)
{
    int num;
    lynqQueue * node;
    int *pInts=NULL;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0){
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] response is null\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    num = responselen/(sizeof(int));
    //printf("intToParcel is %d\n",num);
    pInts=(int*)response;
    node->parcel.writeInt32(num);
    for (int i=0;i<num;i++)
    {
        //printf("subints is %d\n",pInts[i]);
        node->parcel.writeInt32(pInts[i]);
    }
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;
}
static int updateErrnoToQueue(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int status=0;//something change
    lynqQueue * node;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    status =1;
    node->t_Errno=e;
    node->parcel.writeInt32(status);
    LYDBGLOG("[%s,%d] end!!! \n",__FUNCTION__,__LINE__);
    return 0;
}
int cellinfoToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num = 0;
    lynqQueue * node;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] response is null\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    num = responselen/sizeof(RIL_CellInfo);
    node->parcel.writeInt32(num);
    RIL_CellInfo *p_cur = (RIL_CellInfo *)response;
    for (int i = 0; i< num; i++) {
    node->parcel.writeInt32(p_cur[i].cellInfoType);
    node->parcel.writeInt32(p_cur[i].registered);
    node->parcel.writeInt32(p_cur[i].timeStampType);
    node->parcel.writeInt64(p_cur[i].timeStamp);
    switch(p_cur[i].cellInfoType) {
        case RIL_CELL_INFO_TYPE_GSM: {
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.cellIdentityGsm.mcc);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.cellIdentityGsm.mnc);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.cellIdentityGsm.lac);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.cellIdentityGsm.cid);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.signalStrengthGsm.signalStrength);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.signalStrengthGsm.bitErrorRate);
            node->parcel.writeInt32(p_cur[i].CellInfo.gsm.signalStrengthGsm.timingAdvance);
            break;
        }
        case RIL_CELL_INFO_TYPE_WCDMA: {
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.cellIdentityWcdma.mcc);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.cellIdentityWcdma.mnc);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.cellIdentityWcdma.lac);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.cellIdentityWcdma.cid);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.cellIdentityWcdma.psc);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.signalStrengthWcdma.signalStrength);
            node->parcel.writeInt32(p_cur[i].CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
            break;
        }
        case RIL_CELL_INFO_TYPE_CDMA: {
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.cellIdentityCdma.networkId);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.cellIdentityCdma.systemId);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.cellIdentityCdma.basestationId);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.cellIdentityCdma.longitude);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.cellIdentityCdma.latitude);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.signalStrengthCdma.dbm);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.signalStrengthCdma.ecio);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.signalStrengthEvdo.dbm);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.signalStrengthEvdo.ecio);
            node->parcel.writeInt32(p_cur[i].CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
            break;
        }
        case RIL_CELL_INFO_TYPE_LTE: {
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.cellIdentityLte.mcc);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.cellIdentityLte.mnc);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.cellIdentityLte.ci);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.cellIdentityLte.pci);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.cellIdentityLte.tac);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.signalStrength);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.rsrp);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.rsrq);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.rssnr);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.cqi);
            node->parcel.writeInt32(p_cur[i].CellInfo.lte.signalStrengthLte.timingAdvance);
            break;
        }
        case RIL_CELL_INFO_TYPE_TD_SCDMA: {
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.cellIdentityTdscdma.mcc);
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.cellIdentityTdscdma.mnc);
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.cellIdentityTdscdma.lac);
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.cellIdentityTdscdma.cid);
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.cellIdentityTdscdma.cpid);
            node->parcel.writeInt32(p_cur[i].CellInfo.tdscdma.signalStrengthTdscdma.rscp);
            break;
        }
    }
    }
    LYDBGLOG("[%s] parcel write success\n",__FUNCTION__);
    return 0;
}
int neighboringCellToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num = 0;
    lynqQueue * node;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s]  get cell list fail\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    num = responselen/sizeof(RIL_NeighboringCell*);
    node->parcel.writeInt32(num);
    RIL_NeighboringCell **p_cur = (RIL_NeighboringCell **)response;
    for (int i = 0; i< num; i++) {
        StringWriteToParcel(node->parcel,p_cur[i]->cid);
        node->parcel.writeInt32(p_cur[i]->rssi);
    }
    return 0;
}
int solicitedSignalStrengthToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num = 0;
    lynqQueue * node;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s]  get signal strength fail\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    num = responselen/sizeof(RIL_SignalStrength_v10);
    node->parcel.writeInt32(num);
    RIL_SignalStrength_v10 *p_cur = (RIL_SignalStrength_v10 *)response;
    node->parcel.writeInt32(p_cur->GW_SignalStrength.signalStrength);
    node->parcel.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
    node->parcel.writeInt32(p_cur->GW_SignalStrength.timingAdvance);
    node->parcel.writeInt32(p_cur->CDMA_SignalStrength.dbm);
    node->parcel.writeInt32(p_cur->CDMA_SignalStrength.ecio);
    node->parcel.writeInt32(p_cur->EVDO_SignalStrength.dbm);
    node->parcel.writeInt32(p_cur->EVDO_SignalStrength.ecio);
    node->parcel.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.rsrp);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.rsrq);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.rssnr);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.cqi);
    node->parcel.writeInt32(p_cur->LTE_SignalStrength.timingAdvance);
    node->parcel.writeInt32(p_cur->TD_SCDMA_SignalStrength.signalStrength);
    node->parcel.writeInt32(p_cur->TD_SCDMA_SignalStrength.bitErrorRate);
    node->parcel.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
    node->parcel.writeInt32(p_cur->WCDMA_SignalStrength.signalStrength);
    node->parcel.writeInt32(p_cur->WCDMA_SignalStrength.bitErrorRate);
    node->parcel.writeInt32(p_cur->WCDMA_SignalStrength.rscp);
    node->parcel.writeInt32(p_cur->WCDMA_SignalStrength.ecno);
    return 0;
}
int smsResponseToParcel(int32_t request,int32_t token,void *response,size_t responselen,RIL_Errno e)
{
    int num = 0;
    lynqQueue * node;
    node = searchTokeninQueue(token,LynqQueueHead);
    if(node==NULL)
    {
        LYDBGLOG("[%s] search token %x failure from lynq queue\n",__FUNCTION__,token);
        return -1;
    }
    node->t_Errno = e;
    if (response == NULL && responselen != 0) {
        LYDBGLOG("[%s] invalid response: NULL\n",__FUNCTION__);
        return -1;
    }
    if(responselen ==0)
    {
        LYDBGLOG("[%s] sms response\n",__FUNCTION__);
        node->parcel.writeInt32(0);
        return -1;
    }
    num = responselen/sizeof(RIL_SMS_Response);
    node->parcel.writeInt32(num);
    RIL_SMS_Response *p_cur = (RIL_SMS_Response *)response;
    node->parcel.writeInt32(p_cur->messageRef);
    StringWriteToParcel(node->parcel,p_cur->ackPDU);
    node->parcel.writeInt32(p_cur->errorCode);
    return 0;
}

/*****mobiletek-end****/