mfw_sms.c

GSM手机设计软件代码

BOOL sms_sign_exec (T_MFW_HDR * cur_elem,
                    T_MFW_EVENT event,
                    T_MFW_SMS_PARA * para)
{char debug[50];
	sprintf(debug, "sms_sign_exec(): %d", event);
  TRACE_FUNCTION (/*"sms_sign_exec()"*/debug);

  while (cur_elem)
  {
    /* event handler is available */
    if (cur_elem->type EQ MFW_TYP_SMS)
    {
      T_MFW_SMS * sms_data;
      /* handler is SMS management handler */
      sms_data = (T_MFW_SMS *)cur_elem->data;
      if (sms_data->emask & event)
      {
        /* event is expected by the call back function */
        sms_data->event = event;
        switch (event)
        {
          case E_SMS_MO_AVAIL:
            memcpy (&sms_data->para.index, para, sizeof (UBYTE));
            break;
          case E_SMS_CMD_AVAIL:
            memcpy (&sms_data->para.index, para, sizeof (UBYTE));
            break;
          case E_SMS_SAVE_AVAIL:
            memcpy (&sms_data->para.index, para, sizeof (UBYTE));
            break;
          case E_SMS_MT:
            memcpy (&sms_data->para.sms_mt, para, sizeof (T_MFW_SMS_MT));
            break;
          case E_SMS_MO:
            memcpy (&sms_data->para.sms_mo, para, sizeof (T_MFW_SMS_MO));
            break;
          case E_SMS_CB:
            memcpy (&sms_data->para.sms_cb, para, sizeof (T_MFW_SMS_CB));
            break;
          case E_SMS_CB_RECEIVED:
            memcpy (&sms_data->para.sms_id, para, sizeof (T_MFW_SMS_ID));
            break;
          case E_SMS_MT_RECEIVED:
            memcpy (&sms_data->para.sms_id, para, sizeof (T_MFW_SMS_ID));
            break;
          case E_SMS_STATUS:
            memcpy (&sms_data->para.sms_status, para, sizeof (T_MFW_SMS_STATUS));
            break;
          case E_SMS_MEM:
            memcpy (&sms_data->para.sms_mem, para, sizeof (T_MFW_SMS_MEM_INFO));
            break;
          case E_SMS_OK:
#ifdef WIN32
			  // EF we only copy if non null
			  if (para != NULL)
#endif
			  memcpy (&sms_data->para.cmd_ind, para, sizeof (UBYTE));
            break;
          case E_SMS_ERR:
            memcpy (&sms_data->para.cmd_ind, para, sizeof (UBYTE));
            break;
        }

        /* if call back defined, call it */
        if (sms_data->handler)
        {
          // PATCH LE 06.06.00
          // store current mfw elem
          current_mfw_elem = cur_elem;
          // END PATCH LE 06.06.00
          if ((*(sms_data->handler)) (sms_data->event, (void *)&sms_data->para))
          {
            TRACE_EVENT("send SMS event");
            return TRUE;
          }
        }
      }
    }
    cur_elem = cur_elem->next;
  }

  return FALSE;
}


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

  PURPOSE : This function is used to read total information about SMS.
*/

void sms_read_msg_info()
{
    int i;

    TRACE_FUNCTION("sms_read_msg_info()");

    first_id = 1;

    for (i=0; i<MAX_MESSAGES; i++)
    {
        msg_info[i].index = -1;
        msg_info[i].addr.number[0] = '\0';
        msg_info[i].addr.tag[0] = '\0';
        msg_info[i].addr.ton = MFW_TON_UNKNOWN;
        msg_info[i].addr.npi = MFW_NPI_UNKNOWN;
    }

    f_update = MFW_SMS_NEW;
    if (sAT_PlusCMGL (CMD_SRC_LCL, SMS_STAT_All,
                      /*first_id*/0, READ_PREVIEW) NEQ AT_EXCT)
    {
        TRACE_EVENT("sAT_PlusCMGL error");
        f_update = MFW_SMS_FREE;
    }
}


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

  PURPOSE : Response of read SMS list from ACI
*/

void rAT_PlusCMGL ( T_ACI_CMGL_SM * smLst )
{
  int i;
  int j;
  int n;
  T_SMS_TYPE received_sms_type;
  T_CONC_ASSEMBLY_RETURN concatenated_status;
  T_SM_DATA_EXT conc_data_ext;

#ifdef CONC_TEST
  USHORT ref_num;
  UBYTE max_num, seq_num;

  TRACE_FUNCTION ("rAT_PlusCMGL()");

  received_sms_type = SMS_getSMSType( &smLst->udh);
  TRACE_EVENT_P1("SMS Type is = %d", received_sms_type);

 /* 8-bit reference number */
  if (smLst->udh.data[0] EQ SMS_IEI_CONC_8BIT)
  {
    ref_num = smLst->udh.data[2];
    max_num = smLst->udh.data[3];
    seq_num = smLst->udh.data[4];
  }

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

    /* LSB */
    ref_num |= smLst->udh.data[3];

    max_num = smLst->udh.data[4];
    seq_num = smLst->udh.data[5];
  }
  TRACE_EVENT_P3("ref_num: 0x%04x, max_num: %u, seq_num: %u", ref_num, max_num, seq_num);
  TRACE_EVENT_P1("smLst->index: %d", smLst->index);
#endif

  if (received_sms_type == CONCATE)
	  {
	  if(initialising_flag == TRUE)
	  	concatenated_status =concSMS_Collect(&conc_data_ext, smLst, FALSE);
	  else
		concatenated_status =concSMS_Collect(&conc_data_ext, smLst, TRUE);
		TRACE_EVENT_P2("conc status: %d, conc length: %d", concatenated_status, conc_data_ext.len);

	  #ifdef CONC_TEST
	  if (seq_num==1)
	  	{
		    for (i=0; i<MAX_MESSAGES; i++)
		    {
		    	if (concList[i].ref==0xFFFF)
		    	{
		    	    concList[i].ref = ref_num;
		    		concList[i].first_index = smLst->msg_ref;
		    		break;
		    	}
		    }
	  	}
	  #endif

	  }

  if ((received_sms_type == CONCATE && concatenated_status==CONC_COMPLETED)
  	|| received_sms_type !=CONCATE)
	sms_store_new_msg_info(smLst->msg_ref, smLst, FALSE);

#ifdef NO_CONCAT
        n = 0;

            /* SBH */
       received_sms_type = SMS_getSMSType( &smLst->udh);
		TRACE_EVENT_P1("SMS Type is = %d", received_sms_type);
  		if (received_sms_type == CONCATE)
  		{
			concatenated_status =concSMS_Collect(&conc_data_ext, smLst, FALSE);
			TRACE_EVENT_P2("conc status: %d, conc length: %d", concatenated_status, conc_data_ext.len);
  		}
  		if ((received_sms_type == CONCATE && concatenated_status==CONC_COMPLETED)
			|| received_sms_type != CONCATE)
		{
  		/* SBH end */

            for (j=0; j<MAX_MESSAGES; j++)
            {
                if (msg_info[j].index == -1)
                    break;
            }
		TRACE_EVENT_P1("SMS new index: %d ", smLst->msg_ref);
            msg_info[j].index = /*smLst->index*/smLst->msg_ref;

            /*
             * store message reference
             */
             TRACE_EVENT_P1("Staus of MSG in MFW = %d",smLst->stat);
            msg_info[j].msg_ref = smLst->msg_ref;
            msg_info[j].stat  = sms_decodeStatus(smLst->stat);
            if (smLst->adress NEQ NULL)
            {
                strcpy((char *)msg_info[j].addr.number, smLst->adress);
                msg_info[j].addr.ton = phb_cvtTon(smLst->toa.ton);
                msg_info[j].addr.npi = phb_cvtNpi(smLst->toa.npi);
            }

#ifdef NO_ASCIIZ
            memcpy(msg_info[j].addr.tag,
                   smLst->alpha.data,
                   smLst->alpha.len);
            msg_info[j].addr.len = smLst->alpha.len;
#else
            phb_Alpha2Gsm(&smLst->alpha, (UBYTE *)msg_info[j].addr.tag);
#endif
            memset(&msg_info[j].rctp, 0, sizeof(msg_info[j].rctp));
            if (&smLst->scts.month[0] NEQ 0
                AND &smLst->scts.month[1] NEQ 0
                AND &smLst->scts.day[0] NEQ 0
                AND &smLst->scts.day[1] NEQ 0)
                memcpy(&msg_info[j].rctp, &smLst->scts, sizeof(T_MFW_SMS_SCTP));

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

            n++;
        }
 //       first_id = smLst[MAX_SM_ENTR-1].index + 1;
#endif
			f_update = MFW_SMS_NEW;
{
	TRACE_EVENT_P4("CMGL Msg table: %d,%d,%d, %d", msg_info[0].index, msg_info[1].index,msg_info[2].index,msg_info[3].index);
	TRACE_EVENT_P4("CMGL Msg table: %d,%d,%d, %d", msg_info[4].index, msg_info[5].index,msg_info[6].index,msg_info[7].index);
}
}


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

  PURPOSE : message list update is ready
*/

void sms_update_ready(void)
{
  TRACE_FUNCTION("sms_update_ready()");

    sms_signal(E_SMS_MT_RECEIVED, &sms_id);
  sms_id.index = 0;

  if (memory.used == memory.total)
    sms_signal(E_SMS_MEM_FULL, 0);
}


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

  PURPOSE : update the SMS information list
*/

void sms_update_msg_info(T_MFW_SMS_STAT stat)
{
    int i;

    TRACE_FUNCTION("sms_update_msg_info()");

    for (i=0; i<MAX_MESSAGES; i++)
    {
        if (msg_info[i].index EQ status_change_index)
        	{
            	msg_info[i].stat = stat;
        	}
    }

    status_change_index = 0;
}


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

  PURPOSE : This function is used to convert the type of memory
            used by MFW to the type of memory used by ACI.
*/
LOCAL T_ACI_SMS_STOR sms_mem_cvt(UBYTE mem)
{
  switch ( mem )
  {
    case ( MFW_MEM_ME ):  return SMS_STOR_Me;
    case ( MFW_MEM_SIM ): return SMS_STOR_Sm;
    default:          return SMS_STOR_NotPresent;
  }
}


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

   PURPOSE :  MMI selects, how the receiving of new messages
              from the network is indicated.

*/

void sms_set_mt_ind(T_MFW_SMS_MT_IND mt_ind)
{
  TRACE_FUNCTION("sms_set_mt_ind()");

  switch (mt_ind)
  {
    case MT_IND_IDX:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_SmsDeliverInd,
                     CNMI_BM_NotPresent,
                     CNMI_DS_SmsStatRpt );
      break;

    case MT_IND_MSG:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_SmsDeliver,
                     CNMI_BM_NotPresent,
                     CNMI_DS_SmsStatRpt );
      break;

    case MT_IND_NO_IDX:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_NoSmsDeliverInd,
                     CNMI_BM_NotPresent,
                     CNMI_DS_SmsStatRpt );
      break;

    case MT_CB_IDX:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_NotPresent,
                     CNMI_BM_CbmInd,
                     CNMI_DS_NotPresent );
      break;

    case MT_CB_MSG:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_NotPresent,
                     CNMI_BM_Cbm,
                     CNMI_DS_NotPresent );
      break;

    case MT_CB_NO_IDX:
      sAT_PlusCNMI ( CMD_SRC_LCL,
                     CNMI_MT_NotPresent,
                     CNMI_BM_NoCbmInd,
                     CNMI_DS_NotPresent );
      break;

    default:
      break;
  }
}


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

   PURPOSE :  Change SMS status from MFW_SMS_UNREAD to MFW_SMS_READ

GW-SPR#779-Modified code to abort if status has already been updated or if no match is found

*/

T_MFW sms_change_read_status(SHORT index)
{
    SHORT i;
    //UBYTE fg;
    T_ACI_RETURN ret;
    TRACE_FUNCTION("sms_change_read_status()");

    fg = 0;
    for (i=0; i<MAX_MESSAGES; i++)
    {
        if (msg_info[i].index == index)
        {
            if ((msg_info[i].stat == MFW_SMS_UNREAD) ||
               (msg_info[i].stat == MFW_SMS_STOR_UNSENT))
            {
            	fg = 1;
            }
            else
            {
            	/* status is not unread/unsent - no need to change it*/
            	return (1);
            }
            /* Stop search as soon as the index matches */
            break;
        }
    }

/* This change is no completely right, because the SIM will be always updated,
but it makes possible that the read message doesn't come up as new every time
that the mobile is switched on.
GW - Replaced code that returns if no match is found