mfw_nm.c

是一个手机功能的模拟程序

    if (operLst->longOper)
    {
        plmn->network_long.len = MINIMUM(LONG_NAME-1, strlen((char *)operLst->longOper));
        memcpy (plmn->network_long.data, operLst->longOper, plmn->network_long.len);
        plmn->network_long.data[plmn->network_long.len] = '\0';
        plmn->network_long.dcs = MFW_ASCII;
    }

    if (operLst->shortOper)
    {
        plmn->network_short.len = MINIMUM(SHORT_NAME-1, strlen((char *)operLst->shortOper));
        memcpy (plmn->network_short.data, operLst->shortOper, plmn->network_short.len);
        plmn->network_short.data[plmn->network_short.len] = '\0';
        plmn->network_short.dcs = MFW_ASCII;
    }
#else
    memset(plmn->network_long, 0, LONG_NAME);
    memset(plmn->network_short, 0, SHORT_NAME);
    memset(plmn->network_numeric, 0, NUMERIC_LENGTH);

    if (operLst->longOper)
        strncpy((char *)plmn->network_long, (char *)operLst->longOper, LONG_NAME-1);

    if (operLst->shortOper)
        strncpy((char *)plmn->network_short, (char *)operLst->shortOper, SHORT_NAME-1);
#endif
    if (operLst->numOper)
        strncpy((char *)plmn->network_numeric, (char *)operLst->numOper, NUMERIC_LENGTH-1);

    if (operLst->status == COPS_STAT_Available
        || operLst->status == COPS_STAT_Current)
        plmn->forbidden_indicator = MFW_PLMN_AVAILABLE;
    else
        plmn->forbidden_indicator = MFW_PLMN_FORBIDDEN;

    if (!strncmp((char *) mfw_IMSI,(char *) plmn->network_numeric,5))
        plmn->roaming_indicator = 0;
    else
        plmn->roaming_indicator = 1;

    sAT_PlusCOPSF(&forbidden_id,&fieldstrength);
    plmn->fieldstrength = fieldstrength;
}


/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM              |
| STATE   : code                        ROUTINE : nm_pplmn_mem_req    |
+---------------------------------------------------------------------+

  PURPOSE : Request the maximum number of preferred PLMN records
            in SIM card

*/

T_MFW_NM_RETURN nm_pplmn_mem_req(void)
{
  T_ACI_RETURN res;
  SHORT maxRcd, usedRcd;
  T_MFW_PPLMN_MEM pplmn_mem;

  TRACE_FUNCTION("nm_pplmn_mem_req()");

  res = tAT_PlusCPOL(CMD_SRC_LCL, &maxRcd, &usedRcd);
  if (res == AT_EXCT)
  {
    mfwPplmnReq = 1;
    return NM_OK;
  }
  if (res == AT_CMPL)
  {
    pplmn_mem.maxRcd = (UBYTE)maxRcd;
    pplmn_mem.usedRcd = (UBYTE)usedRcd;
    nm_signal(E_NM_PPLMN_MEM, &pplmn_mem);
    return NM_OK;
  }

  return NM_ERR;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_registration    |
+--------------------------------------------------------------------+

  PURPOSE : Start registration

*/

T_MFW nm_registration (U8 mode, U8 freq_bands, U8 limited)
{
    U8 sim_stat;

    TRACE_FUNCTION("nm_registration()");

    sAT_Abort(CMD_SRC_LCL, AT_CMD_NRG);

    sim_stat = sim_status_check();
    reg_flag = 1;

    if (limited)
    {
        if (sAT_PercentNRG(CMD_SRC_LCL,
                           NRG_RGMD_Auto,
                           NRG_SVMD_Limited,
                           NRG_FRMT_Numeric,
                           NULL) != AT_EXCT)
            TRACE_EVENT("Limited Service error: SAT_PercentNRG");
        return sim_stat;
    }

    if (!limited && sim_stat != SIM_ACTIVE)
      return SIM_NOT_ACTIVE;


    if (mode == NM_MANUAL)
    {
        sim_spn_req();                  /* request provider_name    */
        nm_avail_plmn_list();
    }
    else
    {
    	if (sAT_PercentNRG(CMD_SRC_LCL,
                           NRG_RGMD_Auto,
                           NRG_SVMD_Full,
                           NRG_FRMT_Numeric,
                           NULL) != AT_EXCT)
        {
            TRACE_ERROR("sAT_PercentNRG error");
        }
        sim_spn_req();                  /* request provider name    */
    }
    return SIM_ACTIVE;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_avail_plmn_list |
+--------------------------------------------------------------------+

  PURPOSE : Request the available PLMN list

  SPR#2122 - DS - Restructured to make oper_list dynamically allocated

*/

void nm_avail_plmn_list ()
{
    T_ACI_RETURN result;
    int i;
    SHORT last_ind = 0;
    T_ACI_COPS_OPDESC* oper_list = NULL;

    TRACE_FUNCTION("nm_avail_plmn_list()");

    /* Dynamically allocate operator list buffer */
    oper_list = (T_ACI_COPS_OPDESC*)mfwAlloc(sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);

    if (oper_list == NULL)
    {
        TRACE_ERROR("ERROR: Failed to allocate oper list buffer");
        return;
    }

// PATCH JVU - PLMN selection during registration
    sAT_Abort(CMD_SRC_LCL, AT_CMD_NRG);
// END PATCH JVU - PLMN selection during registration

    plmn_list.count = 0;
    result = tAT_PlusCOPS(CMD_SRC_LCL,0,&last_ind,oper_list);
    if (result == AT_FAIL || result == AT_BUSY)
    {
        TRACE_ERROR("ERROR: tAT_PlusCOPS error");

         /* Deallocate operator list buffer */
        if (oper_list != NULL)
        {
            mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
            oper_list = NULL;
        }

        nm_signal(E_NM_PLMN_LIST,&plmn_list);
        return;
    }
    if (result == AT_EXCT)
    {
         /* Deallocate operator list buffer */
        if (oper_list != NULL)
        {
            mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
            oper_list = NULL;
        }
    
        return;                     /* wait for rAT_PlusCOPS()  */
    }

    if (last_ind > MAX_OPER)
        last_ind = MAX_OPER;

    for (i = 0; i <= last_ind; i++)
        nm_copy_plmn_list(&plmn_list.plmn[i], &oper_list[i]);

    /* Deallocate operator list buffer */
    if (oper_list != NULL)
    {
        mfwFree((U8*)oper_list, sizeof(T_ACI_COPS_OPDESC)*MAX_OPER);
        oper_list = NULL;
    }

    plmn_list.count = i;
    nm_signal(E_NM_PLMN_LIST,&plmn_list);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_home_plmn       |
+--------------------------------------------------------------------+

  PURPOSE : Get the home PLMN name

*/

void nm_home_plmn (T_MFW_NETWORK_STRUCT *hplmn)
{
    U8 oper[6];

    /* get network operator */
    strncpy((char *)oper, (char *)mfw_IMSI, 5);
    oper[5] = 0;

#ifdef NO_ASCIIZ
    sAT_PlusCOPSE(oper,
                  COPS_FRMT_Numeric,
                  &hplmn->network_long,
                  &hplmn->network_short,
                  hplmn->network_numeric);

#else
    sAT_PlusCOPSE(oper,
                  COPS_FRMT_Numeric,
                  hplmn->network_long,
                  hplmn->network_short,
                  hplmn->network_numeric);
#endif
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_plmn_list       |
+--------------------------------------------------------------------+

  PURPOSE : Request existing network list
  
*/

int nm_plnm_list(T_MFW_NETWORK_STRUCT *plmn_list, int start, int count)
{
    int  i;
    int  sum;

    TRACE_FUNCTION("nm_plnm_list()");
    sum = 0;
    while (operList[sum].longName != NULL)
        sum++;

    if (start >= sum)
        return 0;

    for (i=0; i<count; i++)
    {
        if (operList[start].longName != NULL)
        {
          plmn_list[i].index = start+1;
#ifdef NO_ASCIIZ
          sAT_PlusCOPSE((UBYTE *)operList[start].longName,
                          COPS_FRMT_Long,
                          &plmn_list[i].network_long,
                          &plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#else
           sAT_PlusCOPSE((UBYTE *)operList[start].longName,
                          COPS_FRMT_Long,
                          plmn_list[i].network_long,
                          plmn_list[i].network_short,
                          plmn_list[i].network_numeric);
#endif
            start++;
        }
        else
        {
#ifdef NO_ASCIIZ
            plmn_list[i].network_long.len = 0;
            plmn_list[i].network_short.len = 0;
            plmn_list[i].network_numeric[0] = 0;
#else
            plmn_list[i].network_long[0] = 0;
            plmn_list[i].network_short[0] = 0;
            plmn_list[i].network_numeric[0] = 0;
#endif
            break;
        }
    }
    return sum;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_select_plmn     |
+--------------------------------------------------------------------+

  PURPOSE : Select PLMN for registration

*/

void nm_select_plmn (U8 *network)
{
    TRACE_FUNCTION("nm_select_plmn()");

    if (sAT_PercentNRG(CMD_SRC_LCL,
                       NRG_RGMD_Manual,
                       NRG_SVMD_Full,
                       NRG_FRMT_Numeric,
                       (char *) network) != AT_EXCT)
    {
        TRACE_ERROR("sAT_PercentNRG error");
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_spn_cnf         |
+--------------------------------------------------------------------+

  PURPOSE : Notify about service provider name

*/

void nm_spn_cnf (SHORT error, T_EF_SPN *efspn)
{
    U8 i;

    TRACE_FUNCTION("nm_spn_cnf()");

#ifdef NO_ASCIIZ
    memset (service_provider_name.data, 0, sizeof(service_provider_name.data));
    service_provider_name.len = 0;
    
    if (error EQ (SHORT)SIM_NO_ERROR)
    {
        for (i=0; (efspn->service_provider[i] != 0xFF) && (i < SP_NAME); i++)
            service_provider_name.data[i] = efspn->service_provider[i];

        service_provider_name.len = i;
    }
#else
    memset (service_provider_name, 0, sizeof(service_provider_name));

    if (error EQ (SHORT)SIM_NO_ERROR)
    {
        for (i=0; (efspn->service_provider[i] != 0xFF) && (i < SP_NAME-1); i++)
            service_provider_name[i] = efspn->service_provider[i];
    }
#endif
    display_condition = efspn->display_condition & 0x01;

#ifdef SIM_TOOLKIT
  if (sat_update)
  {
    sat_update = FALSE;
    satUpdateFiles ( TRUE, SIM_SPN );
  }
#endif
}

#ifdef SIM_TOOLKIT
/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SIM                  |
| STATE   : code                   ROUTINE : nm_sat_file_update       |
+---------------------------------------------------------------------+

  PURPOSE : SIM file change indication

*/

void nm_sat_file_update(USHORT dataId)
{
  UBYTE serv_stat;

  TRACE_FUNCTION("nm_sat_file_update()");

  switch (dataId)
  {
    case SIM_SPN:
      if ((serv_stat = sim_serv_table_check(17)) NEQ NO_ALLOCATED)
      {
        sat_update = TRUE;
        sim_read_sim(SIM_SPN, NOT_PRESENT_8BIT, 17);
      }
      else
        satUpdateFiles ( TRUE, SIM_SPN );
      break;
    default:
      break;
  }
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_deregistration  |
+--------------------------------------------------------------------+

  PURPOSE : Delete registration

*/

void nm_deregistration (void)
{
    TRACE_FUNCTION ("nm_deregistration()");

    if (sAT_PlusCFUN(CMD_SRC_LCL,CFUN_FUN_Minimum,CFUN_RST_NotPresent)
        != AT_EXCT)
    {
        TRACE_ERROR("sAT_PlusCFUN error");
    }
}


/*
+-----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM                |
| STATE   : code                        ROUTINE : nm_ok_deregistration  |
+-----------------------------------------------------------------------+

  PURPOSE : de-registration successful

*/

void nm_ok_deregistration (void)
{
    TRACE_FUNCTION ("nm_ok_deregistration()");
    nm_signal(E_NM_DEREGISTRATION, 0);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_NM             |
| STATE   : code                        ROUTINE : nm_ok_cops         |
+--------------------------------------------------------------------+

  PURPOSE : Successful end of operator selection

*/

void nm_ok_cops (void)
{
  TRACE_FUNCTION("nm_ok_cops()");

  nm_search_reg_status();
  reg_flag = 0;