mfw_phb.c

GSM手机设计软件代码

	  return PHB_LOADING;

	if (stat != PHB_READY)
	  return MFW_PHB_FAIL;

    if (qAT_PlusCLCK(CMD_SRC_LCL, CLCK_FAC_Fd,
                     CLASS_NotPresent, &clsStat) EQ AT_CMPL)
    {
        switch (clsStat.status)
        {
            case STATUS_NotActive:
                return PHB_UNRESTRICTED;

            case STATUS_Active:
                return PHB_RESTRICTED;

            case STATUS_NotPresent:
                return PHB_NOT_ALLOCATED;
        }
    }
    return MFW_PHB_FAIL;
}


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

  PURPOSE :

*/

T_MFW phb_delete_book(UBYTE book)
{
    T_MFW_PHB_STATUS status;
    T_MFW_PHB_ENTRY  entry;
    T_MFW_PHB_LIST   entries;
	T_MFW_PHB_RETURN v_returnedStatus = MFW_PHB_OK;
	TRACE_FUNCTION("phb_delete_book()");

	if (book == PHB_ADN OR
		book == PHB_FDN OR
		book == PHB_BDN OR
		book == PHB_SDN OR
    book == PHB_UPN)
	{
		if (pb_delete_book(book) == PHB_OK)
			return MFW_PHB_OK;
		else
			return MFW_PHB_FAIL;
	}

    entries.entry = &entry;
    status.book = book;
    phb_get_status(&status);

	/*
	 * PATCH CDB 12 04 2000 : This function has been modified to store the RAM copy of the
	 * LDN/LMN/LRN phonebook in E2PROM. As we had returns in the middle of the function,
	 * we have to make a record of each possible returned value of the various function,
	 * then return it. At the end, we return the copied returned value.
	 */
    while (status.used_entries)
    {
        if (phb_read_entries(book, 1, MFW_PHB_INDEX, 1, &entries) != MFW_PHB_OK)
        {
            v_returnedStatus = MFW_PHB_FAIL;
            break;
		}

        if (!entries.num_entries)
		{
			v_returnedStatus = MFW_PHB_OK;
			break;
		}

        if (phb_delete_entry(book, entries.entry->index, &status)!= MFW_PHB_OK)
		{
			v_returnedStatus = MFW_PHB_FAIL;
			break;
		}
    }

    if ((book EQ PHB_LDN) OR (book EQ PHB_LRN) OR (book EQ PHB_LMN))
	{
	  // Don't forget to store it in the E2PROM !!!
	  pb_write_eeprom();
	}

    /*
	 * end of beautiful patch
	 */
    return (v_returnedStatus);
}


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

  PURPOSE :

*/

T_MFW phb_set_auto_off(UBYTE mode)
{
    if (mode == PHB_AUTO_ON)
    {
        if (sAT_PercentPBCF(CMD_SRC_LCL, PBCF_LDN_Enable,
                            PBCF_LRN_Enable, PBCF_LMN_Enable) NEQ AT_CMPL)
            return MFW_PHB_FAIL;
        return MFW_PHB_OK;
    }
    if (mode == PHB_AUTO_OFF)
    {
        if (sAT_PercentPBCF(CMD_SRC_LCL, PBCF_LDN_Disable,
                            PBCF_LRN_Disable, PBCF_LMN_Disable) != AT_CMPL)
            return MFW_PHB_FAIL;
        return MFW_PHB_OK;
    }
}


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

  PURPOSE :

*/

T_MFW phb_get_auto_off(UBYTE *mode)
{
    T_ACI_PBCF_LDN ldn;
    T_ACI_PBCF_LRN lrn;
    T_ACI_PBCF_LMN lmn;
    if (qAT_PercentPBCF(CMD_SRC_LCL, &ldn, &lrn, &lmn) != AT_CMPL)
        return MFW_PHB_FAIL;

    switch (ldn)
    {
        case PBCF_LDN_Disable:
            *mode = PHB_AUTO_OFF;
            return MFW_PHB_OK;
        case PBCF_LDN_Enable:
            *mode = PHB_AUTO_ON;
            return MFW_PHB_OK;
        default:
            return MFW_PHB_FAIL;
    }
}


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

  PURPOSE : switch one entry between ADN and FDN

*/

T_MFW_PHB_RETURN phb_switch_entry  (T_MFW_PHB_ENTRY *entry, UBYTE *passwd)
{
    T_MFW_PHB_STATUS status;
    SHORT            pn1Cnt = -1;
    SHORT            pn2Cnt = -1;
    SHORT            pk1Cnt = -1;
    SHORT            pk2Cnt = -1;
    T_ACI_PVRF_STAT  ps1 = PVRF_STAT_NotPresent;
    T_ACI_PVRF_STAT  ps2 = PVRF_STAT_NotPresent;
    UBYTE			 avail = 0;
    UBYTE            index;

    qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt,
                    &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2);
    if (ps2 != PVRF_STAT_NotRequired)
    {
        if (pn2Cnt < 3)
            return MFW_PHB_PIN2_REQ;
        else
            return MFW_PHB_PUK2_REQ;
    }

    index = entry->index;
    entry->index = 0;

    switch (entry->book)
    {
        case PHB_FDN:
            if (phb_store_entry (PHB_ADN, entry, &status) == MFW_PHB_OK)
            {
                phb_delete_entry (PHB_FDN, index, &status);
                return MFW_PHB_OK;
            }
            break;
        case PHB_ADN:
            if (phb_store_entry (PHB_FDN, entry, &status) == MFW_PHB_OK)
            {
                phb_delete_entry (PHB_ADN, index, &status);
                return MFW_PHB_OK;
            }
            break;
        default:
            break;
    }
	return (MFW_PHB_FAIL);
}


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


   PURPOSE :  Read user personal numbers from EEPROM

*/

void phb_read_upn_eeprom(void)
{
    EF_UPN    efupn;
    USHORT    max_rcd;
    T_ACI_TOA type;
    UBYTE     version;
    UBYTE     i;

    TRACE_FUNCTION("phb_read_upn_eeprom()");

    if (upn_list.count)
    {
        phb_signal(E_PHB_UPN_LIST, &upn_list);
        return;
    }

    pcm_ReadRecord((UBYTE *)EF_UPN_ID,
				    1,
					SIZE_EF_UPN,
					(UBYTE *)&efupn,
					&version,
					&max_rcd);

    for (i=0; i<max_rcd; i++)
    {
	    if (pcm_ReadRecord((UBYTE *)EF_UPN_ID,
						   (USHORT)(i+1),
						   SIZE_EF_UPN,
						   (UBYTE *)&efupn,
						   &version,
						   &max_rcd) == DRV_OK)
        {
            if (efupn.usrNum[0] NEQ 0xff)
            {
                /* copy record */
#ifdef NO_ASCIIZ
/*MC, SPR1257 name strings should use MAX_ALPHA_LEN*/
                cmhPHB_getTagNt (efupn.alphId,
                                 10,            /* alpha length is 10 bytes in eeprom */
                                 (CHAR *)upn_list.upn[cnt].name.data,
                                 /*PHB_MAX_LEN*/MAX_ALPHA_LEN);
#else
/*MC, SPR1257 name strings should use MAX_ALPHA_LEN*/
                                cmhPHB_getTagNt (efupn.alphId,
                                 10,            /* alpha length is 10 bytes in eeprom */
                                 (CHAR *)upn_list.upn[cnt].name,
                                 /*PHB_MAX_LEN*/MAX_ALPHA_LEN);
#endif
                cmhPHB_getAdrStr ((CHAR *)upn_list.upn[cnt].number,
                                  PHB_MAX_LEN - 1,
                                  efupn.usrNum,
                                  efupn.len);

                cmhPHB_toaDmrg (efupn.numTp, &type);
                upn_list.upn[cnt].ton = phb_cvtTon(type.ton);
                upn_list.upn[cnt].npi = phb_cvtNpi(type.npi);
                /* ccp */
                /* ext1 */
                cnt++;
                upn_list.count++;
            }
        }
    }
    phb_signal(E_PHB_UPN_LIST, &upn_list);
}


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


   PURPOSE :  Request user personal numbers

*/

void phb_get_upn(void)
{
    T_MFW_PHB_ENTRY phb_entry;
    T_MFW_PHB_LIST phb_list;
    T_MFW_PHB_STATUS status;
    int i;
    SHORT           start_ind;
    SHORT           stop_ind;
    SHORT           last_ind;

    TRACE_FUNCTION("phb_get_upn()");

    phb_list.entry = &phb_entry;

    memset(&status, 0, sizeof(status));
    status.book = PHB_UPN;
    phb_get_status(&status);

    upn_list.count = 0;
    /* select phonebook */
    if (sAT_PlusCPBS(CMD_SRC_LCL, phb_codePhbType ( PHB_UPN )) NEQ AT_CMPL)
      phb_signal(E_PHB_UPN_LIST, &upn_list);

    start_ind = 1;
    stop_ind = 1;
    upn_list.count = 0;
    for (i=0; i<status.used_entries; i++)
    {

      if (cmhPHB_PlusCPBR(CMD_SRC_LCL,
                          SR_TYP_Index,
                          start_ind,
                          stop_ind,
                          &last_ind,
                          pb_list) EQ AT_CMPL)
      {
        if (pb_list[0].index <= 0)
            break;

        strcpy((char *)upn_list.upn[i].number, (char *)pb_list[0].number);
#ifdef NO_ASCIIZ
        memcpy(upn_list.upn[i].name.data, pb_list[0].text.data, pb_list[0].text.len);
        upn_list.upn[i].name.len = pb_list[0].text.len;
#else
        phb_Alpha2Gsm(&pb_list[0].text, upn_list.upn[i].name);
#endif
        upn_list.upn[i].ton = phb_cvtTon(pb_list[0].type.ton);
        upn_list.upn[i].npi = phb_cvtNpi(pb_list[0].type.npi);
        start_ind++;
        stop_ind++;
        upn_list.count++;
      }
    }

    phb_signal(E_PHB_UPN_LIST, &upn_list);
}

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


   PURPOSE :  Save user personal numbers in EEPROM

*/

T_MFW phb_save_upn(T_MFW_UPN *upn)
{
    T_MFW_PHB_ENTRY entry;
    T_MFW_PHB_STATUS status;

    entry.book = PHB_UPN;
#ifdef NO_ASCIIZ
    memcpy(entry.name.data, upn->name.data, upn->name.len);
    entry.name.len = upn->name.len;
#endif
    strcpy((char *)entry.number, (char *)upn->number);
    // PATCH LE 12.05.00
    // store upn ever on first location
    // zero searches for a free record, which is not
    // available and then the operation fails !

    // old code entry.index = 0;
    entry.index = 1;
    // END PATCH LE 12.05.00
    entry.ton = MFW_TON_UNKNOWN;
    entry.npi = MFW_NPI_UNKNOWN;

    if (phb_store_entry(PHB_UPN, &entry, &status) EQ MFW_PHB_OK)
      return MFW_PHB_OK;
    return MFW_PHB_FAIL;
}

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


   PURPOSE :  convert alpha to GSM string (set bit 7 to 1)

*/

void phb_Alpha2Gsm(T_ACI_PB_TEXT *text, UBYTE *alpha)
{
	int i;

	for (i=0; i<text->len; i++)
	{
		if(i == (PHB_MAX_LEN - 1))
			break;
		alpha[i] = text->data[i] | 0x80;
	}
	alpha[i] = '\0';
}

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


   PURPOSE :  convert zero-terminated GSM string to "data + len"
			  (set bit 7 to 0)

*/

void phb_Gsm2Alpha(UBYTE *alpha, T_ACI_PB_TEXT *text)
{
	int i;

	text->len = strlen((char *)alpha);
  for ( i = 0; i < text->len; i++ )
		alpha[i] = alpha[i] & 0x7F;
	memcpy(text->data, alpha, text->len);
	text->data[text->len] = '\0';
  text->cs = CS_Sim;
}

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


   PURPOSE :  reading phonebook from SIM card is ready.

*/

void rAT_phb_status (T_ACI_PB_STAT status)
{
  if (status EQ PB_STAT_Ready)
  {
    sms_phbReady_ind();
    phb_signal(E_PHB_READY, 0);
  }
  if (status EQ PB_STAT_Blocked)
    phb_signal(E_PHB_BUSY, 0);
}


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


   PURPOSE :

*/

void phb_exit(void)
{
  TRACE_FUNCTION ("phb_exit()");
}