phb_se.c

最新MTK手机软件源码

 *  phb_se_ext_index_find
 * DESCRIPTION
 *  Find the ext_index
 * PARAMETERS
 *  record_index        [IN]        
 *  phb_type            [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
kal_uint8 phb_se_ext_index_find(kal_uint16 record_index, phb_type_enum phb_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (record_index == (kal_uint16) PHB_INVALID_VALUE)
    {
        return (kal_uint8) PHB_INVALID_VALUE;
    }

    for (i = 0; i < EXT1_MAX_ENTRIES_COUNT; i++)
    {
    #ifdef __PHB_USIM_SUPPORT__
        if (ext_index_table[i].record_index == record_index && ext_index_table[i].type == phb_type)
    #else 
        if (ext_index_table[i].record_index == record_index)
    #endif 
            return (i + 1);
    }
    return (kal_uint8) PHB_INVALID_VALUE;
}

#ifdef __PHB_USIM_SUPPORT__


/*****************************************************************************
 * FUNCTION
 *  phb_se_iap_index_set
 * DESCRIPTION
 *  Append the ext_index
 * PARAMETERS
 *  adn_index       [IN]        
 *  data_index      [IN]        
 *  data_type       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void phb_se_iap_index_set(kal_uint16 adn_index, kal_uint8 data_index, data_desc_enum data_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ASSERT(data_index >= 1);
    if (data_type == DATA_DESC_ANRA)
    {
        anr_index_table[data_index - 1] = adn_index;
    }
    else if (data_type == DATA_DESC_EMAIL)
    {
        email_index_table[data_index - 1] = adn_index;
    }
    else if (data_type == DATA_DESC_SNE)
    {
        sne_index_table[data_index - 1] = adn_index;
    }
    else
    {
        ASSERT(0);
    }
}   /* end of phb_se_iap_index_set */


/*****************************************************************************
 * FUNCTION
 *  phb_se_iap_index_delete
 * DESCRIPTION
 *  Append the ext_index
 * PARAMETERS
 *  adn_index       [IN]        
 *  data_type       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void phb_se_iap_index_delete(kal_uint16 adn_index, phb_type_enum data_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ASSERT(adn_index >= 1);
    if (data_type == DATA_DESC_ANRA)
    {
        for (i = 0; i < ANR_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (anr_index_table[i] == adn_index)
            {
                anr_index_table[i] = (kal_uint8) PHB_INVALID_VALUE;
                return;
            }
        }
    }
    else if (data_type == DATA_DESC_EMAIL)
    {
        for (i = 0; i < EMAIL_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (email_index_table[i] == adn_index)
            {
                email_index_table[i] = (kal_uint8) PHB_INVALID_VALUE;
                return;
            }
        }
    }
    else if (data_type == DATA_DESC_SNE)
    {
        for (i = 0; i < SNE_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (sne_index_table[i] == adn_index)
            {
                sne_index_table[i] = (kal_uint8) PHB_INVALID_VALUE;
                return;
            }
        }
    }
    else
    {
        ASSERT(0);
    }
}   /* end of phb_se_iap_index_append */


/*****************************************************************************
 * FUNCTION
 *  phb_se_iap_index_find
 * DESCRIPTION
 *  Find the ext_index
 * PARAMETERS
 *  adn_index       [IN]        
 *  data_type       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
kal_uint16 phb_se_iap_index_find(kal_uint16 adn_index, data_desc_enum data_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int i = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (adn_index == (kal_uint16) PHB_INVALID_VALUE || adn_index == 0)
    {
        return (kal_uint16) PHB_INVALID_VALUE;
    }

    if (data_type == DATA_DESC_ANRA)
    {
        for (i = 0; i < ANR_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (anr_index_table[i] == adn_index)
            {
                return (i + 1);
            }
        }
    }
    else if (data_type == DATA_DESC_EMAIL)
    {
        for (i = 0; i < EMAIL_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (email_index_table[i] == adn_index)
            {
                return (i + 1);
            }
        }
    }
    else if (data_type == DATA_DESC_SNE)
    {
        for (i = 0; i < SNE_INDEX_MAX_ENTRIES_COUNT; i++)
        {
            if (sne_index_table[i] == adn_index)
            {
                return (i + 1);
            }
        }
    }
    return (kal_uint16) PHB_INVALID_VALUE;
}
#endif /* __PHB_USIM_SUPPORT__ */ /* __PHB_USIM_SUPPORT */


/*****************************************************************************
 * FUNCTION
 *  phb_se_get_index_values
 * DESCRIPTION
 *  
 * PARAMETERS
 *  type                [IN]        
 *  tel_number          [?]         
 *  signature           [?]         
 *  num                 [?]         
 *  name_num_index      [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_se_get_index_values(
                phb_type_enum type,
                l4_addr_bcd_struct *tel_number,
                kal_uint8 *signature,
                kal_uint8 *num,
                name_num_index_type **name_num_index)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_SE_GET_INDEX_VALUES);

#ifdef __PHB_SORT_ENABLE__
    if ((type == PHB_PHONEBOOK) || (type == PHB_FDN) || (type == PHB_BDN))
#else 
    if ((type == PHB_FDN) || (type == PHB_BDN))
#endif 
    {

      /**
       * Because FDN matching is prefix matching,
       * telephone number sorting of FDN is according to first 2 digits,
       * and signature is not used.
       */
        if (type == PHB_FDN)
        {
            *name_num_index = &phb_ptr->indices.fdn_index;
            *signature = (kal_uint8) PHB_INVALID_VALUE;
            *num = tel_number->addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET];
        }
        /* (type == PHB_PHONEBOOK) ||(type == PHB_BDN) */
        else
        {
        #ifdef __PHB_SORT_ENABLE__      /* support phonebook sort only no MMI */
            /* Telephone number sorting of PHONEBOOK is according to last 2 digits. */
            if (type == PHB_PHONEBOOK)
            {
                *name_num_index = &phb_ptr->indices.phb_index;
            }

            else if (type == PHB_BDN)
        #endif /* __PHB_SORT_ENABLE__ */ 
                *name_num_index = &phb_ptr->indices.bdn_index;

            *signature = phb_se_cal_signature_num(
                            tel_number->addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET],
                            &tel_number->addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET],
                            (kal_uint8) (tel_number->addr_length - L4_ADDR_BCD_TEL_NUM_OFFSET),
                            num);
        }
    }
}   /* end of phb_se_reset */


/*****************************************************************************
 * FUNCTION
 *  phb_se_build_index_convert_name
 * DESCRIPTION
 *  Build index of certain type
 * PARAMETERS
 *  pNameString     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
/* 20030202 Wilson, temporary solution for PinYin sorting hang problem */
#if defined(__PINYIN_SORTING_ZI__)

#elif  defined(__PINYIN_SORTING_KA__)
extern const signed char *GetPYString(unsigned char *HZ);
#endif 

#if defined(__PINYIN_SORTING_ZI__) || defined(__PINYIN_SORTING_KA__)
void phb_se_build_index_convert_name(kal_uint8 *pNameString)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int8 in_count, out_count, i;
    kal_uint8 InputString[32];  /* Original Input String, Should be the same as L4_MAX_NAME or smaller */
    kal_uint8 *pInputString;    /* Pointer to Original Input String */

#if defined(__PINYIN_SORTING_ZI__)
    kal_uint16 code;
    kal_uint8 pResultBuffer[32 * 2];
#elif  defined(__PINYIN_SORTING_KA__)
    kal_uint8 code[2];
    const kal_int8 *pResultBuffer;
#endif 

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    memcpy(InputString, pNameString, 32);
    memset(pNameString, 0, 32);
    pInputString = (kal_uint8*) InputString;
    in_count = out_count = 0;

    while (!((*pInputString == 0) && (*(pInputString + 1) == 0)) && in_count < 32)
    {

    #if defined(__PINYIN_SORTING_ZI__)
        code = *((kal_uint16*) pInputString);
        code = (code << 8) | (code >> 8);
        if ((code >= 0x4e00) && (code <= 0x9fa5) && Zi8GetCharInfo(code, (kal_uint16*) pResultBuffer, 32 * 2, 1))
    #elif defined(__PINYIN_SORTING_KA__)
        code[0] = pInputString[1];
        code[1] = pInputString[0];
        if ((pResultBuffer = GetPYString(code)) != NULL)
    #endif 
        {   /* A Chinese, convert to its PinYin string */
            i = 0;
            while ((pResultBuffer[i] != 0x00) && (out_count < 32) && (i < 32 * 2))
            {
                pNameString[out_count] = pResultBuffer[i];
                out_count++;
            #if defined(__PINYIN_SORTING_ZI__)
                i = i + 2;
            #elif defined(__PINYIN_SORTING_KA__)
                i = i + 1;
            #endif 
            }
            /* Add space between convert result for KA */
        #if defined(__PINYIN_SORTING_KA__)
            pNameString[out_count++] = 0x20;
        #endif 
        }
        else    // if(*pInputString == 0)   /*NOT a Chinese character, Is a ASCII character. Ex. 'A' "0x0041"*/
        {
            pNameString[out_count] = *(pInputString + 1);
            out_count++;
            /* Add space between convert result for KA */
        #if defined(__PINYIN_SORTING_KA__)
            pNameString[out_count++] = 0x20;
        #endif 
        }

        in_count += 2;
        pInputString += 2;
    }

}