rilsimtk_magneto.cpp

windows mobile RIL软件

//////////////////////////////////////////////////////////////////////////////
//
// Parsing callback to parse the the SAT profile.
//
// Return:
//  S_OK on successs, E_FAIL otherwise.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT CSimToolkitHandling::ParseGetProfile(LPCSTR szRsp, void*& pBlob, UINT& cbBlob/*, LPVOID pParam*/) {
UINT     i;
UINT     nValue;
UINT     cbProfileString;
LPSTR    szProfileString = NULL;
LPSTR    pchProfileStringWalk;
UINT     cbProfile;
BYTE*    pbProfileWalk;
BYTE*    pbProfile = NULL;
HRESULT  hr = S_OK;

  pBlob = NULL;
  cbBlob = 0;

  // Parse "<prefix>+PPSTAC: <state>,<alphabet>,<allowedInstance>,<Profile>"
  //+PPSTAC: <Mode>,<Config>,<Timeout>
  if (!ParseRspPrefix(szRsp, szRsp)                   ||
      !MatchStringBeginning(szRsp, "+PPSTAC:", szRsp)  ||
      !ParseUInt(szRsp, TRUE, nValue, szRsp)          ||
      !MatchStringBeginning(szRsp, ",", szRsp)) 
  {
    hr = E_FAIL;
    goto Error;
  }

  // Parse "<profile>"
  // NOTE: we take ownerswhip of allocated szProfileString
  if (!ParseUnlimitedString(szRsp, szProfileString, cbProfileString, szRsp)) {
    hr = E_FAIL;
    goto Error;
  }
  TBD_ASSERT(0 == (cbProfileString - 1) % 2);
  cbProfile = (cbProfileString - 1) / 2;

  // Allocate the byte array of needed size
  pbProfile = (BYTE*)AllocBlob(cbProfile);
  if (!pbProfile) {
    hr = E_OUTOFMEMORY;
    goto Error;
  }

  // Decode the profile
  pbProfileWalk = pbProfile;
  pchProfileStringWalk = szProfileString;
  for (i = 0; i < cbProfile; i++) {
    *pbProfileWalk = SemiByteCharsToByte(*pchProfileStringWalk, *(pchProfileStringWalk + 1));
    pbProfileWalk++;
    pchProfileStringWalk += 2;
  }

  ParseUInt(szRsp, TRUE, nValue, szRsp);          //skip timeout field

  // Parse "<postfix>"
  if (!ParseRspPostfix(szRsp, szRsp)) {
    hr = E_FAIL;
    goto Error;
  }

  pBlob = (void*)pbProfile;
  cbBlob = cbProfile;

Error:
  if (FAILED(hr)) {
    FreeBlob(pbProfile);
  }
  delete[] szProfileString;
  return hr;
}

//////////////////////////////////////////////////////////////////////////////
//
// Trace the binary data of the SIMToolkit blob passed tt the MMI.
//
// Params:
//  pBlob : Pointer to the blob
//  dwSize: Size of the blob
// Return:
//  TRUE or FALSE depending on the success of the operation.
//
//////////////////////////////////////////////////////////////////////////////
void CSimToolkitHandling::TraceBlob(BYTE* pBlob, DWORD dwSize) {
#ifdef SIMTK_ENABLE_BIN_TRACE
  RILRetailTrace((TEXT("RilDrv: -----------------------------------------------------------------------\r\n")));
  RILRetailTrace((TEXT("RilDrv: SIM-Toolkit blob data (size: %d)\r\n"), dwSize));
  TCHAR   Buf[1024];
  TCHAR*  pBuf = Buf;
  BOOL    tr = FALSE;
  for (DWORD i = 1; i <= dwSize; i++) {
    _stprintf(pBuf, TEXT("0x%02X "), pBlob[i-1]);
    pBuf += 5;
    if (i && !(i % 16)) {
      swprintf(pBuf, TEXT("\r\n"));
      RILRetailTrace((Buf));
      pBuf = Buf;
      tr = TRUE;
    } else {
      tr = FALSE;
    }
  }
  if (!tr) {
    _stprintf(pBuf, TEXT("\r\n"));
    RILRetailTrace((Buf));
  }
  RILRetailTrace((TEXT("RilDrv: -----------------------------------------------------------------------\r\n")));
#endif // SIMTK_ENABLE_BIN_TRACE
}


//////////////////////////end merge////////////////////////////////////////////////////
//
// Internal parsing function.
//
// Return:
//  TRUE or FALSE depending on the success of the operation.
//
//////////////////////////////////////////////////////////////////////////////
BOOL CSimToolkitHandling::ParseRefresh(LPCSTR szRsp, void*& pBlob, UINT& cbBlob) {
UINT               nDetails;
RILSIMTOOLKITCMD*  pSatCmd;
SIMFILEREFRESH*    pSatRefresh;
BOOL               fRet = TRUE;

  PrepareRilCmdStruct(m_bCmdBuffer, &pSatCmd, SIM_NOTIFY_REFRESH);

  // Parse: "<details>"
  if (!ParseUInt(szRsp, FALSE, nDetails, szRsp) ||
      !ParseRspPostfix(szRsp, szRsp)) {
    PrepareRilCmdError(pSatCmd, SIM_RESPONSE_ERR_VALUESMISSING);
    fRet = FALSE;
  } else {
    pSatRefresh = (SIMFILEREFRESH*)((BYTE*)pSatCmd + pSatCmd->dwDetailsOffset);

    pSatRefresh->dwParams     = SIM_PARAM_FILEREFRESH_FLAGS;
    pSatRefresh->dwFlags      = 0;
    switch (nDetails) {
      case 0:
	  	pSatRefresh->dwFlags  = SIMFILE_SIMINIT | SIMFILE_FULLFILECHANGE;
	  	break;
      case 1:
        pSatRefresh->dwFlags  = SIMFILE_FILECHANGE;
        break;
      case 2:
        pSatRefresh->dwFlags  = SIMFILE_SIMINIT | SIMFILE_FILECHANGE;
        break;
      case 3:
        pSatRefresh->dwFlags  = SIMFILE_SIMINIT;
        break;
      case 4:
        pSatRefresh->dwFlags  = SIMFILE_SIMRESET;
        // In case off a full SIM reset the module doesn't require any response
        m_fNoResponse = TRUE;
        break;
      default:
        PrepareRilCmdError(pSatCmd, SIM_RESPONSE_ERR_COMMANDDATA);
        fRet = FALSE;
        break;
    }
    pSatRefresh->cbSize        = ROUNDTODWORD(sizeof(SIMFILEREFRESH));

    pSatCmd->cbSize += pSatRefresh->cbSize;
    pSatCmd->dwDetailsSize = pSatRefresh->cbSize;
  }

  // Notify the SIM manager of the SAT command
  if (!HandleBlob(RIL_NOTIFY_SIMTOOLKITEVENT, pBlob, cbBlob , m_bCmdBuffer, pSatCmd->cbSize)) {
    fRet = FALSE;
  }

  return fRet;
}

//////////////////////////////////////////////////////////////////////////////
//
// Internal parsing function.
//
// Return:
//  TRUE or FALSE depending on the success of the operation.
//
//////////////////////////////////////////////////////////////////////////////
BOOL CSimToolkitHandling::ParseSetupEventList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob) {
UINT               nDetails, nEventList;
RILSIMTOOLKITCMD*  pSatCmd;
SIMEVENTLIST*      pSatEventList;
BYTE*              pEvents;
BOOL               fRet = TRUE;

  PrepareRilCmdStruct(m_bCmdBuffer, &pSatCmd, SIM_NOTIFY_EVENTLIST);

  // Parse: "<details>,<eventlist>"
  if (!ParseUInt(szRsp, FALSE, nDetails, szRsp)    ||
      !ParseRspParamSeparator(szRsp, szRsp)        ||
      !ParseUInt(szRsp, FALSE, nEventList, szRsp)  ||
      !ParseRspPostfix(szRsp, szRsp)) {
    PrepareRilCmdError(pSatCmd, SIM_RESPONSE_ERR_VALUESMISSING);
    fRet = FALSE;
  } else {
    pSatEventList = (SIMEVENTLIST*)((BYTE*)pSatCmd + pSatCmd->dwDetailsOffset);

    pSatEventList->dwParams        = SIM_PARAM_SIMEVENTLIST_ALL;
    pSatEventList->dwEventsSize    = 0;
    pSatEventList->dwEventsOffset  = ROUNDTODWORD(sizeof(SIMEVENTLIST));

    pEvents = (BYTE*)pSatEventList + pSatEventList->dwEventsOffset;
    if (nEventList & 0x0010) { pEvents[pSatEventList->dwEventsSize++] = SIMTKIT_EVENT_USERACTIVITY; }
    if (nEventList & 0x0020) { pEvents[pSatEventList->dwEventsSize++] = SIMTKIT_EVENT_IDLESCREEN; }
	if (nEventList & 0x0040) { pEvents[pSatEventList->dwEventsSize++] = SIMTKIT_EVENT_CARDREADERSTATUS; }
	if (nEventList & 0x0080) { pEvents[pSatEventList->dwEventsSize++] = SIMTKIT_EVENT_LANGUAGESELECTION; }

	pSatEventList->cbSize = ROUNDTODWORD2(sizeof(SIMEVENTLIST), pSatEventList->dwEventsSize);

    pSatCmd->cbSize += pSatEventList->cbSize;
    pSatCmd->dwDetailsSize = pSatEventList->cbSize;
  }

  // Notify the SIM manager of the SAT command
  if (!HandleBlob(RIL_NOTIFY_SIMTOOLKITCMD, pBlob, cbBlob , m_bCmdBuffer, pSatCmd->cbSize)) {
    fRet = FALSE;
  }

  return fRet;
}

//////////////////////////////////////////////////////////////////////////////
//
// Internal parsing function.
//
// Return:
//  TRUE or FALSE depending on the success of the operation.
//
//////////////////////////////////////////////////////////////////////////////
BOOL CSimToolkitHandling::ParseSetupCall(LPCSTR szRsp, void*& pBlob, UINT& cbBlob) {
UINT               nDummy, nDetails, nConfIconQualifier, nConfIconId, nSetupIconQualifier, nSetupIconId, nCallCtrlBySim;
RILSIMTOOLKITCMD*  pSatCmd;
SIMCALL*           pSatCall;
WCHAR              wszConfirmation[UCS2_LEN + 1], wszNumber[UCS2_LEN + 1], wszSetup[UCS2_LEN + 1];
BOOL               fRet = TRUE;

  PrepareRilCmdStruct(m_bCmdBuffer, &pSatCmd, SIM_NOTIFY_SETUPCALL);

  // Parse "<details>,<confirmation text>,<called number>,<call setup text>,<conf icon qual>,<conf icon>,<call setup icon qual>,<call setup icon>
  //+PPSTGI:<CmdType>,<CmdQualifier>,<CalledNumber>,<ConfirmText>,<ConfirmIconID>,<ConfirmIconQualifier>,<SetupText>,<SetupIconID>,<SetupIconQualifier>,<CallControlBySIM>
  ParseUInt(szRsp, FALSE, nDetails, szRsp);		//Details
  ParseRspParamSeparator(szRsp, szRsp);
 
  if('"' == szRsp[0])
  {
	 //ParseUCS2String(szRsp, wszNumber, UCS2_LEN, szRsp);
	 UINT nIndex = 0;
	szRsp ++;	//skip the leading quote
	while(*szRsp != '"')	//look for post quote
	{
		wszNumber[nIndex++] = *szRsp++;
	}
	wszNumber[nIndex] = '\0';		//terminated by the character '\0'
	szRsp ++;					//skip the post quote
  }
  else
  {
  	wszNumber[0]='\0';
	ParseUInt(szRsp, FALSE, nDummy, szRsp);
  }
  ParseRspParamSeparator(szRsp, szRsp);
  
 //     !ParseUInt(szRsp, FALSE, nDummy, szRsp)	|| //!ParseUCS2String(szRsp, wszNumber, UCS2_LEN, szRsp)        ||		//call number
 //     !ParseRspParamSeparator(szRsp, szRsp)                      ||
  if( !ParseUCS2String(szRsp, wszConfirmation, UCS2_LEN, szRsp)  ||		//confirm text
      !ParseRspParamSeparator(szRsp, szRsp)                      ||
  	  !ParseUInt(szRsp, FALSE, nConfIconId, szRsp)               ||		//confirm Icon Id
      !ParseRspParamSeparator(szRsp, szRsp)                      ||
      !ParseUInt(szRsp, FALSE, nConfIconQualifier, szRsp)        ||		//confirm Icon Qualifier
      !ParseRspParamSeparator(szRsp, szRsp)                      ||
      !ParseUCS2String(szRsp, wszSetup, UCS2_LEN, szRsp)         ||		//setup Text
      !ParseRspParamSeparator(szRsp, szRsp)                      ||
      !ParseUInt(szRsp, FALSE, nSetupIconId, szRsp)              ||		//setup icon id
      !ParseRspParamSeparator(szRsp, szRsp)						 ||
      !ParseUInt(szRsp, FALSE, nSetupIconQualifier, szRsp)       ||		//setup icon qualifier
      !ParseRspParamSeparator(szRsp, szRsp)                      ||
      !ParseUInt(szRsp, FALSE, nCallCtrlBySim, szRsp)			 ||		//Call control by SIM
      !ParseRspPostfix(szRsp, szRsp)) 
  {
    PrepareRilCmdError(pSatCmd, SIM_RESPONSE_ERR_VALUESMISSING);
    fRet = FALSE;
  } 
  else 
  {
    pSatCall = (SIMCALL*)((BYTE*)pSatCmd + pSatCmd->dwDetailsOffset);

    pSatCall->dwParams = SIM_PARAM_SIMCALL_FLAGS;
    switch (nDetails) {
      case 0:
        pSatCall->dwFlags = SIMCALL_IDLE;
        break;
      case 1:
        pSatCall->dwFlags = SIMCALL_IDLE | SIMCALL_REDIAL;
        break;
      case 2:
        pSatCall->dwFlags = SIMCALL_HOLDCALLS;
        break;
      case 3:
        pSatCall->dwFlags = SIMCALL_HOLDCALLS | SIMCALL_REDIAL;
        break;
      case 4:
        pSatCall->dwFlags = SIMCALL_DISCONNECTCALLS;
        break;
      case 5:
        pSatCall->dwFlags = SIMCALL_DISCONNECTCALLS | SIMCALL_REDIAL;
        break;
      default:
        pSatCall->dwParams = 0;
        break;