smi_reg.c

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

*/
GLOBAL T_ACI_RETURN reg_changeReg (void)
{
  T_ACI_RETURN ret = AT_FAIL; /* holds status information */
  
  TRACE_FUNCTION ("reg_changeReg ()");

  switch (COPSmode)
  {
    case (COPS_MOD_Auto):
    case (COPS_MOD_Man):
    case (COPS_MOD_Both):
      /*
       *-------------------------------------------------------------
       * call to ACI function when no answer on a further ACI
       * function call is expected
       *-------------------------------------------------------------
       */
      if (currRegCmd EQ AT_CMD_NONE)
      {  
        switch (CREGstat)
        {
          /*
           *---------------------------------------------------------
           * no deregistration necessary
           *---------------------------------------------------------
           */   
          case (CREG_STAT_NoSearch):
          case (CREG_STAT_Denied):
            COPSqryrsn      = RSN_CHANGE;
            currRegCmd      = AT_CMD_COPS;
            mmi_data->state = MMI_WAIT_FOR_DEREG;
            rAT_OK (currRegCmd);
            break;

          /*
           *---------------------------------------------------------
           * deregistration necessary
           *---------------------------------------------------------
           */   
          case (CREG_STAT_Reg):
          case (CREG_STAT_Roam):
            ret = sAT_PlusCOPS (CMD_SRC_LCL,
                                COPS_MOD_Dereg,
                                COPS_FRMT_NotPresent,
                                NULL);

            COPSqryrsn      = RSN_CHANGE;
            currRegCmd      = AT_CMD_COPS;
            mmi_data->state = MMI_WAIT_FOR_DEREG;

            /*
             *-------------------------------------------------------
             * process result code of ACI function call
             *-------------------------------------------------------
             */   
            switch (ret)
            {
              case (AT_CMPL):
                ui_signal (UI_SIG_DEREGISTERING);
                rAT_OK (currRegCmd);
                break;

              case (AT_EXCT):
                ui_signal (UI_SIG_DEREGISTERING);
                break;

              default:
                rAT_PlusCME (currRegCmd, CME_ERR_Unknown);
                break;
            }
            break;
        
          /*
           *---------------------------------------------------------
           * unsufficient registration status
           *---------------------------------------------------------
           */   
          default:
            ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
            break;
        }
      }
      else
      {
        /*
         *-----------------------------------------------------------
         * error handling while waiting for answer on further ACI
         * function call
         *-----------------------------------------------------------
         */
        ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
      }
      break;
    
    default:
      ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
      break;
  }
  
  return ret;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : rAT_PlusCOPS             |
+--------------------------------------------------------------------+

  PURPOSE : This function is called when the operator list calculated
            by the ACI is available. The operator list is only 
            requested, when an manual registration should be
            performed.

            <lastIdx>: index of last operator in list
            <operLst>: operator list
*/
GLOBAL void rAT_PlusCOPS  (SHORT lastIdx, T_ACI_COPS_OPDESC* operLst)
{
  CHAR*  lstItem[MAX_OPER + 1]; /* holds the operator list */
  USHORT i = 0;                 /* used for counting       */

  TRACE_FUNCTION ("rAT_PlusCOPS ()");

  if (lastIdx EQ ACI_NumParmNotPresent OR
      operLst EQ NULL)
    return;

  /*
   *-----------------------------------------------------------------
   * separate the operator names of the available operators and
   * inform the user interface
   *-----------------------------------------------------------------
   */
  while (i < MAX_OPER                  AND
         operLst[i].longOper  NEQ NULL AND
         operLst[i].shortOper NEQ NULL    )
  {
    if (operLst[i].status EQ COPS_STAT_Available)
    {
      if (COPSfrmt EQ COPS_FRMT_Long)
        lstItem[i] = operLst[i].longOper;
      else
        lstItem[i] = operLst[i].shortOper;
    }

    i++;
  }

  lstItem[i] = NULL;

  ui_signal (UI_SIG_SELECT_PLMN, &lstItem[0]);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : reg_startReg             |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to start a registration.

            returns: status information concerning the registration
                     progress
*/
GLOBAL T_ACI_RETURN reg_startReg (void)
{
  T_ACI_RETURN ret = AT_FAIL; /* holds status information */

  TRACE_FUNCTION ("reg_startReg ()");

  if (COPSmode EQ COPS_MOD_Man OR
      COPSmode EQ COPS_MOD_Both  )
  {
    /*
     *---------------------------------------------------------------
     * start manual registration 
     *---------------------------------------------------------------
     */
    ret = reg_startManReg ();
  }
  else
  {
    /*
     *---------------------------------------------------------------
     * call to ACI function when no answer on a further ACI function
     * call is expected
     *---------------------------------------------------------------
     */
    if (currRegCmd EQ AT_CMD_NONE)
    {  
      switch (CREGstat)
      {
        case (CREG_STAT_NoSearch):
        case (CREG_STAT_Denied):
        case (CREG_STAT_Unknown):
          /*
           *---------------------------------------------------------
           * start registration with predefined registration mode
           *---------------------------------------------------------
           */
          ret = sAT_PlusCOPS (CMD_SRC_LCL,
                              COPSmode,
                              COPSfrmt,
                              COPSoper);

          if (ui_isScrnWidthMin ())
            COPSfrmt = COPS_FRMT_Short;
          else
            COPSfrmt = COPS_FRMT_Long;

          COPSoper        = NULL;
          currRegCmd      = AT_CMD_COPS;
          mmi_data->state = MMI_WAIT_FOR_REG;

          /*
           *---------------------------------------------------------
           * process result code of ACI function call
           *---------------------------------------------------------
           */   
          switch (ret)
          {
            case (AT_CMPL):
              ui_signal (UI_SIG_REGISTERING);
              rAT_OK (currRegCmd);
              break;

            case (AT_EXCT):
              ui_signal (UI_SIG_REGISTERING);
              break;

            default:
              rAT_PlusCME (currRegCmd, CME_ERR_Unknown);
              break;
          }
          break;

        default:
          /*
           *---------------------------------------------------------
           * mobile equipment must be deregistered before trying to
           * register again
           *---------------------------------------------------------
           */
          ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
          break;
      }

    }
    else
    {
      if (currRegCmd NEQ AT_CMD_COPS)
      {
        /*
         *-----------------------------------------------------------
         * error handling while waiting for answer on further ACI
         * function call
         *-----------------------------------------------------------
         */
        ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
      }
    }
  }

  return ret;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : reg_setReg               |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to set registration parameter.

            <cops>: holds registration parameter
            
            returns: status information concerning the setting
                     progress
*/
GLOBAL T_ACI_RETURN reg_setReg (T_KSD_COPS *cops)
{
  T_ACI_RETURN ret = AT_FAIL; /* holds status information */

  TRACE_FUNCTION ("reg_setReg ()");

  /*
   *-----------------------------------------------------------------
   * do not disturb any registration / deregistration
   *-----------------------------------------------------------------
   */
  if (currRegCmd EQ AT_CMD_COPS)
  {
    ui_signal (UI_SIG_UNHND_CME_ERR, CME_ERR_Unknown);
  }
  else
  {
    if (cops->mode NEQ COPS_MOD_NotPresent)
      COPSmode = cops->mode;

    if (cops->frmt NEQ COPS_FRMT_NotPresent)
      COPSfrmt = cops->frmt;

    if (cops->oper NEQ NULL)
      COPSoper = cops->oper;

    ret = AT_CMPL;
  }

  return ret;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : reg_setOperName          |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to set the operator name used for
            the next manual registration.

            <oper>: operator name
*/
GLOBAL void reg_setOperName (CHAR* oper)
{
  COPSoper = oper;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : rAT_PlusCREG             |
+--------------------------------------------------------------------+

  PURPOSE : This function is used to indicate the registration of the 
            mobile equipment.

            <stat>: registration status
*/
GLOBAL void rAT_PlusCREG (T_ACI_CREG_STAT stat,
                            USHORT          lac,
                            USHORT          cid)
{
  CHAR            oper[MAX_ALPHA_OPER_LEN]; /* operator name */
  T_ACI_COPS_MOD  mode;                     /* COPS mode     */
  T_ACI_COPS_FRMT frmt;                     /* COPS format   */
  T_ACI_NRG_RGMD  regMode;
  T_ACI_NRG_SVMD  srvMode;
  T_ACI_NRG_FRMT  oprFrmt;
  T_ACI_NRG_SVMD  srvStat;

  TRACE_FUNCTION ("rAT_PlusCREG ()");

  if (stat NEQ CREG_STAT_NotPresent)
    CREGstat = stat;

  qAT_PercentNRG( CMD_SRC_LCL,
                  &regMode,
                  &srvMode,
                  &oprFrmt,
                  &srvStat,
                  oper);

  switch (srvStat)
  {
    case (NRG_SVMD_Full):
      sAT_PlusCOPS (CMD_SRC_LCL, 
                    COPS_MOD_SetOnly,
                    COPSfrmt,
                    NULL);

      /*
       *-------------------------------------------------------------
       * get the operator name and inform the user interface
       *-------------------------------------------------------------
       */
      if (qAT_PlusCOPS (CMD_SRC_LCL, &mode, &frmt, oper) NEQ AT_CMPL)
        oper[0] = NULL_TERM; 

      /*
       *---------------------------------------------------------------
       * if operator unknown show MCC MNC
       *---------------------------------------------------------------
       */
      if (strlen(oper) EQ 0)
      {
        sAT_PlusCOPS (CMD_SRC_LCL, 
                      COPS_MOD_SetOnly,
                      COPS_FRMT_Numeric,
                      NULL);

        if (qAT_PlusCOPS (CMD_SRC_LCL, &mode, &frmt, oper) NEQ AT_CMPL)
          oper[0] = NULL_TERM; 
      }

      mmi_data->serviceType = SRV_NORMAL;
      ui_signal (UI_SIG_PLMN, &oper[0]);
      break;

    case (NRG_SVMD_Limited):
      mmi_data->serviceType = SRV_LIMITED;
      ui_signal (UI_SIG_LIMITED_SERVICE);
      break;

    case (NRG_SVMD_NoSrv):
      mmi_data->serviceType = SRV_NONE;
      ui_signal (UI_SIG_NO_CELL);
      break;

    default:
      break;
  }

  switch (stat)
  {
    case (CREG_STAT_Search):
      ui_signal (UI_SIG_REGISTERING);
      break;

    default:
      break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : SMI_REG                  |
| STATE   : code                  ROUTINE : reg_pinState             |
+--------------------------------------------------------------------+

  PURPOSE : This function sets whether PIN or PUK is entered
            successfully.
*/
GLOBAL void reg_pinState (BOOL cnf, BOOL need)
{
  pinCnf  = cnf;
  pinNeed = need;
}