mfw_sms.c

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

			}

			seg_slot = push_sbuf_removeSeg(ref_num, merge_slot->next_seg);
			if (seg_slot == NULL)
			{
				return MERGE_STA_CONTINUE;
			}

			add_data        = seg_slot->data;
			add_data_len    = seg_slot->len;            
			MFREE(seg_slot);
		}
	}
}

/****
*  Timer callback for delete SMS carrying PUSH PDU, should be called
*  before any executing of SMS rAT_xxx functions
*/
int push_sms_del_timCB(MfwEvt e, MfwHnd h)
{
	UBYTE idx;  
	T_ACI_RETURN    ret;

	idx = push_delLst_get();
	PUSH_DET_TRACE(("push_sms_del_timCB(), idx=%d", idx));

	if (idx != 0xff) /* if 0xff, empty, no more index to be delete */
	{
		if ((ret = sAT_PlusCMGD(CMD_SRC_LCL, idx)) NEQ AT_EXCT)
		{
			PUSH_DET_TRACE(("push_sms_del_timCB(): delete error, ret=%d", ret));

			/* restart timer for next try */
			if (ret == AT_BUSY)
				timStart(pushDelList.t_post);

			return 0;
		}

		coll_sms_delete = MFW_SMS_WAIT;
		deleting_index  = idx;
		return 1;
	}

	return 0;
}

/****
*  Add one or more index to delete waiting list (a ring buffer)
*/

void push_delLst_add(UBYTE* idx, UBYTE len)
{
	UBYTE i;
	UBYTE flag;

	while (len--)
	{
		PUSH_DET_TRACE(("push_delLst_add():add to list, idx =%d, wr=%d, len=%d", *idx, pushDelList.wr, len));

		pushDelList.mem_idx[pushDelList.wr++] = *idx++;

		pushDelList.wr = pushDelList.wr % MAX_DEL_STORE;
	}

	if (pushDelList.t_post == NULL)
	{
		flag = Set_regflag(0);
		pushDelList.t_post = (MfwHnd)timCreate(0, 500, push_sms_del_timCB);
		PUSH_DET_TRACE(("push_delLst_add():create timer for post process, timer=%d", (UINT32)pushDelList.t_post));
		Set_regflag(flag);
		
		if (pushDelList.t_post != NULL)
		{
			PUSH_DET_TRACE(("push_delLst_add(): timer first run!"));
			timStart(pushDelList.t_post);           
		}
	}

	if (!timFindOut(pushDelList.t_post)) //if timer is not running
	{
		PUSH_DET_TRACE(("push_delLst_add(): start timer!"));
		timStart(pushDelList.t_post);
	}
}

/****
*  Remove the first index from delete waiting list
*/
void push_delLst_remove(void)
{
	PUSH_DET_TRACE(("push_delLst_remove(): rd=%d, idx=%d", pushDelList.rd, pushDelList.mem_idx[pushDelList.rd]));

	pushDelList.mem_idx[pushDelList.rd++]   = 0xFF;	// marked as empty
	pushDelList.rd = pushDelList.rd % MAX_DEL_STORE;
}

/****
*  Get current index to be delete from waiting list
*/
UBYTE push_delLst_get(void)
{
	PUSH_DET_TRACE(("push_delLst_get(): wr=%d, rd=%d, idx=%d", pushDelList.wr, pushDelList.rd, pushDelList.mem_idx[pushDelList.rd]));       

	return(pushDelList.mem_idx[pushDelList.rd]);
}

#endif //_PUSH_DETECT_ENABLE_

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

   PURPOSE : initialize for SMS management

*/


void sms_init(void)
{
  UBYTE i;

  TRACE_FUNCTION ("sms_init()");

  /* Setting the default SMS parameter */
  sms_type = MFW_NO_MESSAGE;
  mt_type = MFW_NO_MESSAGE;
  flag = 0;
  status_change_index = 0;
  deleting_index = 0;
  mt_flag = 0;
  smsReady = 0;
  phbReady = 0;
  sms_id.index = sms_id_wait.index = 0;

  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;
    msg_info[i].first_index = -1; /*SPR 2260*/
	msg_info[i].concat_status = MFW_SMS_NO_CONC;

  }
  /* PATCH-6363 VO 30.01.01 */
  memory.mem = SMS_STOR_Sm;
  memory.used = 0;
  memory.total = 0;
  /* PATCH-6363 end */

/* robert.chen add, 2004-08-10, integrated MMS module */
#if (_PUSH_DETECT_ENABLE_ == 1)	
	push_init();
#endif

  
  /* glowing,2004-06-11, import from M188 */
  sAT_PlusCMGF(CMD_SRC_LCL, CMGF_MOD_Txt);    // Marcus: Issue 1388: 06/01/2003
  /* glowing,2004-06-11, end of import */

}


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

   PURPOSE : initialize for SMS management

*/

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

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

   PURPOSE : finished initialize from the SIM card

*/

void sms_phbReady_ind(void)
{
  if (smsReady)
  {
    TRACE_FUNCTION("sms_phbReady_ind");

    f_update = MFW_SMS_NEW;
    TRACE_EVENT("all free");
    coll_sms_send = coll_sms_read = coll_sms_delete = coll_sms_req = MFW_SMS_FREE;
    sms_read_msg_info();
    smsReady = 0;
    phbReady = 0;
  }
  else
    phbReady = 1;
}

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

   PURPOSE : finished initialize from the SIM card

*/

void rAT_sms_ready(void)
{
    TRACE_FUNCTION("rAT_sms_ready()");

    if (phbReady)
    {
      f_update = MFW_SMS_NEW;
      sms_read_msg_info();
      smsReady = 0;
      phbReady = 0;
    }
    else
      smsReady = 1;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : MFW_CB             |
| STATE   : code                        ROUTINE : rAT_SignalSMS      |
+--------------------------------------------------------------------+

  PURPOSE : handles rAT_SignalSMS call back

*/

GLOBAL void rAT_SignalSMS ( UBYTE state )
{
  TRACE_FUNCTION("rAT_SignalSMS()");
  switch (state)
  {
	case SMS_STATE_INITIALISING: initialising_flag = TRUE; break;
  	case SMS_STATE_READY: initialising_flag = FALSE; break;
  }
}


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

   PURPOSE : create SMS control

*/

T_MFW_HND sms_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc)
{
  T_MFW_HDR *hdr;
  T_MFW_SMS *sms_para;
  MfwHdr *insert_status =0;
  
  TRACE_FUNCTION ("sms_create()");

  hdr      = (T_MFW_HDR *) mfwAlloc(sizeof(T_MFW_HDR));
  sms_para = (T_MFW_SMS *) mfwAlloc(sizeof(T_MFW_SMS));

  if (!hdr OR !sms_para)
  	{
    	TRACE_ERROR("ERROR: sms_create() Mem Alloc Failed.");
			
	   	if(hdr)
   			mfwFree((U8*)hdr,sizeof(MfwHdr));

   		if(sms_para)
   			mfwFree((U8*)sms_para,sizeof(T_MFW_SMS));
   		
	   	return FALSE;
    }
  /* initialisation of the handler */
  sms_para->emask   = event;
  sms_para->handler = cbfunc;

  hdr->data = sms_para;         /* store parameter in node */
  hdr->type = MFW_TYP_SMS;     /* store type of event handler */

  /* installation of the handler */

  insert_status =  mfwInsert((T_MFW_HDR *)hWin, hdr);/*SPR 1968, inserted inadvertently deleted function call*/
  
  if(!insert_status)
  	{
  		TRACE_ERROR("ERROR: sms_create() Failed to Install Handler. ");
   		mfwFree((U8*)hdr,sizeof(MfwHdr));
   		mfwFree((U8*)sms_para,sizeof(T_MFW_SIM)); 	
		return 0;
  	}
    return insert_status;
}


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

   PURPOSE : delete SMS control

*/

T_MFW_RES sms_delete(T_MFW_HND h)
{
  TRACE_FUNCTION ("sms_delete()");

  if (!h OR !((T_MFW_HDR *)h)->data)
    return MFW_RES_ILL_HND;

  if (!mfwRemove((T_MFW_HDR *) h))
    return MFW_RES_ILL_HND;

  mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_SMS));
  mfwFree((U8 *)h,sizeof(T_MFW_HDR));

 return MFW_RES_OK;
}


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

   PURPOSE : send a event.

*/

void sms_signal(T_MFW_EVENT event, void * para)
{
	UBYTE temp = dspl_Enable(0);
  TRACE_FUNCTION ("sms_signal()");
 if (mfwSignallingMethod EQ 0)
  {
  /* focus is on a window */
  if (mfwFocus)
    /* send event to sim management handler if available */
    if (sms_sign_exec (mfwFocus, event, para))
	{
	  dspl_Enable(temp);
      return;
	}

  /* acutal focussed window is not available or has no
   * network management registration handler, then search
   * all nodes from the root. */
   if (mfwRoot)
     sms_sign_exec (mfwRoot, event, para);
  }
  else
    {
      MfwHdr * h = 0;

      /*
       * Focus set, then start here
       */
      if (mfwFocus)
        h = mfwFocus;
      /*
       * Focus not set, then start root
       */
      if (!h)
        h = mfwRoot;

      /*
       * No elements available, return
       */

      while (h)


      {
        /*
         * Signal consumed, then return
         */
        if (sms_sign_exec (h, event, para))
	{
	  dspl_Enable(temp);
      return;
	}

        /*
         * All windows tried inclusive root
         */
        if (h == mfwRoot)
	{
	  dspl_Enable(temp);
      return;
	}

        /*
         * get parent window
         */
        h = mfwParent(mfwParent(h));
		if(h)
			h = ((MfwWin * )(h->data))->elems;
      }
      sms_sign_exec (mfwRoot, event, para);
    }
	  dspl_Enable(temp);
      return;
 }


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

   PURPOSE : Send a signal if there is an SMS management handler.

*/

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_EVENT (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;