mfw_gprs.c

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

/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_gprs.c      $|
| $Author: root $Revision: 1.1.1.1 $|
| CREATED: 13.02.2001                   $Modtime::  13.02.2001       |
| STATE  : code                                                      |
+--------------------------------------------------------------------+

   MODULE  : MFW_GPRS

   PURPOSE : This modul contains functions needed for the GPRS 
             management in MFW.

*/

/* include necessary header files ----------------------------------*/

#ifndef NEW_FRAME
  #error GPRS need NEW_FRAME
#endif  /* NEW_FRAME */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "typedefs.h"
#include "mfw_mfw.h"
#include "vsi.h"
#include "custom.h"
#include "gsm.h"

#include "message.h"
#include "prim.h"
#include "aci_cmh.h"  /* include types declared in ACI              */
#include "gaci_cmh.h" /* include types declared in GACI             */

//#include "cus_aci.h"
#include "p_sim.h"
#include "pcm.h"

#include "mfw_win.h"
#include "mfw_gprs.h"

/* import of external globals --------------------------------------*/
EXTERN MfwHdr *current_mfw_elem;

/* definition of globals -------------------------------------------*/

/* definition of constants -----------------------------------------*/

/* definition of internal functions --------------------------------*/

static BOOL gprs_sign_exec ( T_MFW_HDR *cur_elem, T_MFW_EVENT event, 
                             T_MFW_GPRS_PARA *para );

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


   PURPOSE : initialize for GPRS magangement

*/
void gprs_init ( void )
{
  TRACE_FUNCTION ("gprs_init()");

  /* 
   * set callback for MFW commands 
   */
  mfwCommand[MfwTypGprs] = (MfwCb) gprsCommand;
}


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


   PURPOSE : finalize for GPRS magangement

*/
void gprs_exit ( void )
{
  TRACE_FUNCTION ("gprs_exit()");
}


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


   PURPOSE : create event for gprs management

   PARAMETERS :

   RETURNS :
*/
T_MFW_HND gprs_create ( T_MFW_HND   h,
                        T_MFW_EVENT event,
                        T_MFW_CB    cbfunc )
{
  T_MFW_HDR      *hdr;
  T_MFW_GPRS     *gprs_data;
  T_CGATT_STATE   state; 
  T_CGCLASS_CLASS cls;
  T_CGREG_STAT    regState;
  USHORT      lac;
  USHORT      ci;
  MfwHdr *insert_status =0;

  TRACE_FUNCTION ("gprs_create()");

  hdr     = (T_MFW_HDR  *) mfwAlloc(sizeof (T_MFW_HDR));
  gprs_data = (T_MFW_GPRS *) mfwAlloc(sizeof (T_MFW_GPRS));

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

   		if(gprs_data)
   			mfwFree((U8*)gprs_data,sizeof(T_MFW_GPRS));
   		
	   	return FALSE;
  	}

  /*
   * initialisation of the handler 
   */
  gprs_data->emask   = event;
  gprs_data->handler = cbfunc;
  
  hdr->data = gprs_data;      /* store gprs control block in node */
  hdr->type = MfwTypGprs;     /* store type of event handler      */


  /*
   * initialisation of gprs data 
   */
  gprs_data->data.numContexts = 0;

  //gprs_data->data.tclass = NULL;
  //gprs_data->data.regState = NULL;
  //gprs_data->data.attached = NULL;

  memset( &gprs_data->data.tclass, 0, sizeof( T_CGCLASS_CLASS ) );
  memset( &gprs_data->data.regState, 0, sizeof( T_CGREG_STAT ) );
  memset( &gprs_data->data.attached, 0, sizeof( T_CGATT_STATE ) );

  gprs_data->data.contexts = 
    (T_MFW_GPRS_CONTEXT *) mfwAlloc(sizeof(T_MFW_GPRS_CONTEXT) * MAX_CID_PLUS_EINS);

  /* 
   * installation of the handler 
   */
  insert_status = mfwInsert((T_MFW_HDR *)h, hdr);
  
  if(!insert_status)
	{
  		TRACE_ERROR("ERROR: gprs_create() Failed to Install Handler. ");
   		mfwFree((U8*)hdr,sizeof(MfwHdr));
   		mfwFree((U8*)gprs_data,sizeof(T_MFW_GPRS));
		return 0;
  	}
    return insert_status;
}


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


   PURPOSE : delete event for gprs management

   PARAMETERS :

   RETURNS :
             MFW_RES_OK,      on success
             MFW_RES_ILL_HND, on failure
*/
T_MFW_RES gprs_delete ( T_MFW_HND h )
{
  T_MFW_GPRS *gprs_data;

  TRACE_FUNCTION ("gprs_delete()");

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

  /* 
   * deinstallation of the handler
   */

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

  gprs_data = ((T_MFW_HDR *) h)->data;

  while ( gprs_data->data.numContexts )
  {
    mfwFree((U8 *)&(gprs_data->data.contexts[gprs_data->data.numContexts]),
            sizeof(T_MFW_GPRS_CONTEXT));
    gprs_data->data.numContexts--;
  }
  mfwFree((U8 *)&(gprs_data->data), sizeof(T_MFW_GPRS_DATA));
  mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_GPRS));
  mfwFree((U8 *)h,sizeof(T_MFW_HDR));

  return MFW_RES_OK;
}


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

  PURPOSE : handle mfw windows command

  PARAMETERS :

  Returns : 0, on failure
            1, on success
*/

int gprsCommand (U32 cmd, void *h)
{
  switch ( cmd )
  {
    case MfwCmdDelete:              /* delete me */
      if ( !h )
        return 0;
      gprs_delete(h);
      return 1;
    default:
      break;
  }

  return 0;
}


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

   PURPOSE : send a event signal.

   PARAMETERS :
             event : current event
             *para : pointer to the event parameters

*/
void gprs_signal( T_MFW_EVENT event, 
                  void       *para)
{/*MC, SPR 1389, we have to enable the display whenever 
	we send an event up to the MMI*/
  UBYTE temp = dspl_Enable(0);
	
  TRACE_FUNCTION ("gprs_signal()");

  if ( mfwSignallingMethod EQ 0 )
  {
    /* 
     * focus is on a window
     */
    if ( mfwFocus )
    {
      /*
       * send event to sim management handler if available 
       */
      if (gprs_sign_exec (mfwFocus, event, para))
     { dspl_Enable(temp);/*MC, SPR 1389*/
	        return;
	 }
    }

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

    /* 
     * Focus set, then start here
     */
    if ( mfwFocus )
    h = mfwFocus;

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

    /* 
     * while elements found
     */
    while ( h )
    {
      /*
       * Signal consumed, then return 
       */
      if ( gprs_sign_exec (h, event, para) )
      { dspl_Enable(temp);/*MC, SPR 1389*/
	        return;
	  }

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

      /* 
       * get parent window 
       */
      h = mfwParent(mfwParent(h));

      /* 
       * look for next element 
       */
      if ( h )
        h = ((MfwWin * )(h->data))->elems;
    }
    gprs_sign_exec (mfwRoot, event, para);
  }
 dspl_Enable(temp);/*MC, SPR 1389*/

}


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


   PURPOSE : Handle a signal if GPRS management handler.

   PARAMETERS :

   RETURNS : 
             TRUE,  if signal is processed
             FALSE, if signal is not processed
*/
BOOL gprs_sign_exec ( T_MFW_HDR     *cur_elem, 
                      T_MFW_EVENT    event, 
                      T_MFW_GPRS_PARA *para )
{
  int i,j;
  T_CGATT_STATE state;
  T_GPRS_CONT_REC tst_ctrc[MAX_CID_PLUS_EINS];
  SHORT tst_cid;
  USHORT      lac;
  USHORT      ci;

  TRACE_FUNCTION ("gprs_sign_exec()");

  /* 
   * while event handler is available 
   */
  while ( cur_elem )
  {
    /*
     * if handler is GPRS management handler
     */
    if ( cur_elem->type EQ MfwTypGprs )
    {
      T_MFW_GPRS *gprs_data;
      gprs_data = (T_MFW_GPRS *)cur_elem->data;

      /* 
       * if event is expected by the call back function
       */
      if ( gprs_data->emask & event )
      {
        gprs_data->event = event;

        switch ( event )
        {
          case E_MFW_GPRS_S_CNTXT:
            /*
             * Check if contexts is defined in ACI ( if too many context
             * are defined, the new one will not be defined
             */
            qAT_PlusCGDCONT(CMD_SRC_LCL, &tst_ctrc, &tst_cid);
  
            if ( tst_cid >= gprs_data->data.numContexts + 1)
            {

              /* 
               * insert the new context
               */ 
              memcpy (&(gprs_data->data.contexts[gprs_data->data.numContexts]), para, 
                sizeof (T_MFW_GPRS_CONTEXT));
              gprs_data->data.numContexts++;
            }
            break;

          case E_MFW_GPRS_S_ATT:
          case E_MFW_GPRS_R_EREP_ATT:
			/* SPR#1983 - SH -'attached' is now of correct type.
			 * Don't check if unchanged, as this rejects some cases
			 * where signal needs to be sent to BMI
			 */
			 
            gprs_data->data.attached = para->attached;
            
            /*
             * set all contexts to deactivated after detach
             */
            if ( gprs_data->data.attached == CGATT_STATE_DETACHED )
            {
              for ( i=0; i > gprs_data->data.numContexts; i++)
              {
                  gprs_data->data.contexts[i].activated = CGACT_STATE_DEACTIVATED;
              }
            }