mfw_sms.c

GSM手机设计软件代码

            }
        }

        if (ret == -1)
        {
            /* Index was not already in msg_info, so look for unused slot */
            for (i = 0; (i < MAX_MESSAGES) && (ret == -1); i++)
            {
                if (msg_info[i].index == -1)
                {
                    /* First unused slot in msg_info found */
                    ret = i;
               		if (update_mem)
            			memory.used++;
               }
            }
        }
    }

    TRACE_EVENT_P1("find_slot_in_msg_info returning %d", ret);

    return ret;
}


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

   PURPOSE :  Store message information

*/

T_MFW sms_store_new_msg_info(UBYTE index, T_ACI_CMGL_SM* sm, UBYTE update_mem)
{
  int j;
  T_SMS_TYPE received_sms_type;
  T_CONC_ASSEMBLY_RETURN concatenated_status;
  T_SM_DATA_EXT conc_data_ext;

#ifdef CONC_TEST
  int i;
  USHORT ref_num;
#endif

  TRACE_FUNCTION("sms_store_new_msg_info");

	sms_type = MFW_SMS_MESSAGE;

	if ((j = find_slot_in_msg_info(index, update_mem)) != -1)
	{
	    received_sms_type = SMS_getSMSType(&sm->udh);

	    TRACE_EVENT_P1("SMS Type is = %d", received_sms_type);
	 	
	    if (received_sms_type == CONCATE)
	   	{
	   	#ifdef CONC_TEST
	   	 /* 8-bit reference number */
		  if (sm->udh.data[0] EQ SMS_IEI_CONC_8BIT)
		  {
		    ref_num = sm->udh.data[2];
		  }

		  /* 16-bit reference number */
		  if (sm->udh.data[0] EQ SMS_IEI_CONC_16BIT)
		  {
		    /* MSB */
		    ref_num = (sm->udh.data[2] & 0x00FF) << 8u;    /* 23.040 9.1.2.1 */

		    /* LSB */
		    ref_num += sm->udh.data[3];
		  }

	   	  for (i=0; i<MAX_MESSAGES; i++)
	   	  {
	   	  	if (concList[i].ref == ref_num)
   	  		{
	   	  		index = concList[i].first_index;
	   	  		TRACE_EVENT_P1("First index = %d",index);
	   	  		concList[i].ref = 0xFFFF;
	   	  		concList[i].first_index = 0xFF;
	   	  		break;
   	  		}
	   	  }
	   	#endif
	   	}

   	    sm->index = index;
   		msg_info[j].index = index;

		msg_info[j].stat = sms_decodeStatus(sm->stat);
		strcpy((char *)msg_info[j].addr.number, sm->adress);
		msg_info[j].addr.ton = phb_cvtTon(sm->toa.ton);
		msg_info[j].addr.npi = phb_cvtNpi(sm->toa.npi);
#ifdef NO_ASCIIZ
		memcpy(msg_info[j].addr.tag,
		sm->alpha.data,
		sm->alpha.len);
		msg_info[j].addr.len = sm->alpha.len;
#else
		phb_Alpha2Gsm(&sm->alpha,
		(UBYTE *)msg_info[j].addr.tag);
#endif
		memcpy(&msg_info[j].rctp, &sm->scts, sizeof(T_MFW_SMS_SCTP));

		// check voice mail status
		if (sms_check_voice_mail(sm->pid, sm->dcs, sm->adress,
		&sm->toa, &sm->udh) EQ MFW_SMS_VOICE)
		msg_info[j].msg_type = MFW_SMS_VOICE;
		else
		msg_info[j].msg_type = MFW_SMS_NotVOICE;

		coll_sms_read = MFW_SMS_FREE;
        f_update = MFW_SMS_FREE;
        TRACE_EVENT_P1("UDH Length is = %d", sm->udh.len);
	}
}



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

   PURPOSE :  Send a new message indication to the MMI

*/

T_MFW sms_send_new_msg_ind(UBYTE index, UBYTE mem, UBYTE received_sms_type, UBYTE concatenated_status)
{
	TRACE_FUNCTION("sms_send_new_msg_ind");

	if (received_sms_type == CONCATE)
	{
		switch (concatenated_status)
		{
			case CONC_ERR_UNKN:
			TRACE_EVENT("Concatenated SMS error");break;
			case CONC_ERR_BUF_FULL:
			TRACE_EVENT("Concatented SMS buffer Full Error");break;
			case CONC_CONTINUED: //not last SMS
			TRACE_EVENT("Concatenation Continued");
			break;
			case CONC_COMPLETED:
			{
				TRACE_EVENT("Concatenation Completed");
				memset(&sms_mt, 0, sizeof(sms_mt));

				if(initialising_flag == TRUE)
					sms_signal(E_SMS_MT, &sms_mt);
				else
				sms_signal(E_SMS_MT_RECEIVED, &sms_mt);
			}
		}
	}
	else
	{
		memset(&sms_mt, 0, sizeof(sms_mt));

		if(initialising_flag == TRUE)
		sms_signal(E_SMS_MT, &sms_mt);
		else
		sms_signal(E_SMS_MT_RECEIVED, &sms_mt);
	}
}

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

   PURPOSE :  Receive a new cell broadcast message.

*/

void rAT_PlusCBM(SHORT           sn,
                 SHORT           mid,
                 SHORT           dcs,
                 UBYTE           page,
                 UBYTE           pages,
                 T_ACI_CBM_DATA* data)
{
  TRACE_FUNCTION ("rAT_PlusCBM()");

  /* copy parameter */
  sms_cb.sn     = sn;
  sms_cb.msg_id = mid;
  sms_cb.dcs    = (UBYTE)dcs;
  sms_cb.page   = page;
  sms_cb.pages  = pages;
  sms_cb.msg_len = data->len;
  memcpy((char *)sms_cb.cb_msg, (char *)data->data, data->len);

  /* send cell broadcast message event */
  sms_signal(E_SMS_CB, &sms_cb);
}


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

   PURPOSE :  Receive a new cell broadcast message identifier.

*/

void rAT_PlusCBMI(T_ACI_SMS_STOR mem, UBYTE index)
{
  TRACE_FUNCTION ("rAT_PlusCBMI()");

  switch ( mem )
  {
    case ( SMS_STOR_Me ):
        sms_id.mem = MFW_MEM_ME;
        break;
    case ( SMS_STOR_Sm ):
        sms_id.mem = MFW_MEM_SIM;
        break;
    default:
        break;
  }

  sms_id.index = index;

  /* send a short message identifier event */
  sms_signal(E_SMS_CB_RECEIVED, &sms_id);
}


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

   PURPOSE :  Receive a status report message.

*/

void rAT_PlusCDS(T_ACI_CDS_SM *st)
{
  T_MFW_SMS_STATUS sms_status;
  T_MFW_PHB_ENTRY  phb_entry;
  T_MFW_PHB_LIST   phb_list;
  UBYTE            phb_index;
#ifdef NO_ASCIIZ
  T_MFW_PHB_TEXT  findText;
#endif

  TRACE_FUNCTION ("rAT_PlusCDS()");

  memset(&phb_entry, 0, sizeof(phb_entry));
  memset(&phb_list, 0, sizeof(phb_list));
  phb_list.entry = &phb_entry;

  sms_status.msg_id  = 0x03 & (UBYTE)st->fo;
  sms_status.msg_ref = st->msg_ref;
  strcpy(sms_status.addr.number, st->addr);
  sms_status.addr.ton = phb_cvtTon(st->toa.ton);
  sms_status.addr.npi = phb_cvtNpi(st->toa.npi);

#ifdef NO_ASCIIZ
  strcpy((char *)findText.data, st->addr);
  findText.len = (UBYTE)strlen(st->addr);
  if (phb_find_entries  (PHB_ADN,   &phb_index,
                         MFW_PHB_NUMBER,
                         1, &findText,
                         &phb_list) EQ MFW_PHB_OK)
  {
    if (phb_list.num_entries)
    {
      memcpy(sms_status.addr.tag,
             phb_list.entry->name.data,
             phb_list.entry->name.len);
      sms_status.addr.len = phb_list.entry->name.len;
    }
  }
#else
  if (phb_find_entries  (PHB_ADN,	&phb_index,
                         MFW_PHB_NUMBER,
                         1,
                         st->ra,
                         &phb_list) EQ MFW_PHB_OK)
  {
    if (phb_list.num_entries)
    {
      strcpy((char *)sms_status.addr.tag, (char *)phb_list.entry->name);
    }
  }
#endif

  sms_status.status  = st->tp_status;

  memcpy((char *)sms_status.rctp.year, (char *)st->vpabs_scts.year, MAX_SCTP_DIGITS);
  memcpy((char *)sms_status.rctp.month, (char *)st->vpabs_scts.month, MAX_SCTP_DIGITS);
  memcpy((char *)sms_status.rctp.day, (char *)st->vpabs_scts.day, MAX_SCTP_DIGITS);
  memcpy((char *)sms_status.rctp.hour, (char *)st->vpabs_scts.hour, MAX_SCTP_DIGITS);
  memcpy((char *)sms_status.rctp.minute, (char *)st->vpabs_scts.minute, MAX_SCTP_DIGITS);
  memcpy((char *)sms_status.rctp.second, (char *)st->vpabs_scts.second, MAX_SCTP_DIGITS);
  sms_status.rctp.timezone = st->vpabs_scts.timezone;

  /* send status report message event */
  sms_signal(E_SMS_STATUS, &sms_status);
}


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

   PURPOSE :  Set preferred message storage.

*/

T_MFW sms_set_pref_memory(UBYTE mem)
{
  TRACE_FUNCTION ("sms_set_pref_memory()");

int_init_req = FALSE;

  if (sAT_PlusCPMS(CMD_SRC_LCL,
                   sms_mem_cvt(mem),
                   sms_mem_cvt(mem),
                   sms_mem_cvt(mem)) NEQ AT_EXCT)
    return MFW_SMS_FAIL;
  return MFW_SMS_OK;
}


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

   PURPOSE :  Read a SMS message.

*/

T_MFW sms_read(UBYTE type, UBYTE index)
{
  TRACE_FUNCTION ("sms_read()");

  coll_sms_read = MFW_SMS_WAIT;

  if (sAT_PlusCMGR(CMD_SRC_LCL, index, SMS_READ_Preview) NEQ AT_EXCT)
    return MFW_SMS_FAIL;
  sms_type = type;

  flag = index;
  memset(&sms_mt, 0, sizeof(sms_mt));
  sms_mt.index = index;

  return MFW_SMS_OK;
}


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


   PURPOSE :  Call back for read message.

*/

void rAT_PlusCMGR(T_ACI_CMGL_SM  * sm, T_ACI_CMGR_CBM * cbm)
{
  T_ACI_RETURN ret;
  T_SMS_TYPE received_sms_type;
  T_CONC_ASSEMBLY_RETURN concatenated_status;
  T_SM_DATA_EXT conc_data_ext;
  char debug[20];
  int j, s = 0;

  UBYTE decoded_dcs;

  TRACE_FUNCTION ("rAT_PlusCMGR()");

  switch (sms_type)
  {
    case MFW_SMS_MESSAGE:
    {
      switch (0x03 & sm->fo)
      {
        case 0x00:
    	received_sms_type = SMS_getSMSType( &sm->udh);
		TRACE_EVENT_P1("SMS Type is = %d", received_sms_type);
  		if (received_sms_type == CONCATE)
  		{
		  concatenated_status =concSMS_Collect(&conc_data_ext, sm, FALSE);
		  TRACE_EVENT_P2("conc status: %d, conc length: %d", concatenated_status, conc_data_ext.len);
  		}

        if (f_update NEQ MFW_SMS_UPDATE)
        { UBYTE conc_msg_ref, conc_index;
          TRACE_EVENT_P1("UDH Length is = %d", sm->udh.len);

	  	  if (received_sms_type == CONCATE)
	      {
			switch (concatenated_status)
			{
			  case CONC_ERR_UNKN:
			    TRACE_EVENT("Concatenated SMS error");
			    break;
			  case CONC_ERR_BUF_FULL:
			    TRACE_EVENT("Concatented SMS buffer Full Error");
				break;
			  case CONC_CONTINUED: //not last SMS
				TRACE_EVENT("Concatenation Continued");
				break;
			  case CONC_COMPLETED:
			  {
			    TRACE_EVENT("Concatenation Completed");
				memset(&sms_mt, 0, sizeof(sms_mt));
				conc_msg_ref =concSMS_GetMsgRef ( sm );
				conc_index = concSMS_GetFirstIndex(conc_msg_ref);

#ifdef NO_ASCIIZ
				memcpy(sms_mt.orig_addr.tag,
					         sm->alpha.data,
					         sm->alpha.len);
				sms_mt.orig_addr.len = sm->alpha.len;
#else
				phb_Alpha2Gsm(sm->alpha, (UBYTE *)sms_mt.orig_addr.tag);
#endif
				strcpy(sms_mt.orig_addr.number, sm->adress);
				sms_mt.orig_addr.ton =
					      phb_cvtTon(sm->toa.ton);
			    sms_mt.orig_addr.npi =
					      phb_cvtNpi(sm->toa.npi);
				if (sm->tosca.ton == TON_International)
				  sprintf(sms_mt.sc_addr, "+%s", sm->sca);
				else
				  strcpy(sms_mt.sc_addr, sm->sca);
				sms_mt.prot_id = (UBYTE)sm->pid;
				sms_mt.dcs     = (UBYTE)sm->dcs & 0xFC;	/* Ignore message class */

				/*MC*/