mminetwork.c

GSM手机设计软件代码

        {
          switch (data->network_list_status)
          {
            case NETWORK_LIST_REGISTRATION:
              /*
               * Present list of available PLMNs again
               *
               * NOTE: if NETWORK_LIMITED_SERVICE has indicated
               *       that THE manually selected network is now forbidden
               *       the menu list must be updated (but don't ask me how).
               */
              network_stop_animation ();
              data->network_list_status = NETWORK_LIST_DISPLAY_FIRST;
              listDisplayListMenu (win, data->network_list, (ListCbFunc)network_list_cb,0);
              network_forbidden_plmn();
              break;
            case NETWORK_LIST_SELECTED:
              /*
               * After registration start, MFW returns the current status
               */
              data->network_list_status= NETWORK_LIST_REGISTRATION;
              data->keep_plmn_list = TRUE;
              break;
          }
        }
      }
#ifdef MMI_HOMEZONE_ENABLED
	/* sh - tell homezone there is no network */
	homezoneUpdate(0,0);
#endif
      break;

    case NETWORK_SEARCH_NETWORK:
      TRACE_EVENT ("NETWORK SEARCH NETWORK");
      SEND_EVENT (idle_get_window(), NETWORK_SEARCH_NETWORK, 0, 0);
      break;

    case NETWORK_FULL_SERVICE:
      TRACE_EVENT ("NETWORK FULL SERVICE");
      /*
       * Set Status
       */
      data->status = NETWORK_FULL_SERVICE;

      /*
       * Copy Network Name in textual and numerical format
       *
       * NOTE: Service Provider Name is not used
       *       Operator Name from SIM needs CPHS support by MFW
       */
      plmn_ident = (T_MFW_NETWORK_STRUCT *)parameter;

#ifdef NO_ASCIIZ
      memcpy (data->plmn_name, &plmn_ident->network_long.data, SIZE_PLMN_NAME);
#else
      memcpy (data->plmn_name, plmn_ident->network_long, SIZE_PLMN_NAME);
#endif      
      memcpy (data->network_name, plmn_ident->network_numeric, SIZE_NETWORK_NAME);

      /*
       * If network name is not known use numeric representation as default.
       */
#ifdef NO_ASCIIZ
      if (plmn_ident->network_long.len EQ 0)
#else       
      if (strlen ((char *)(plmn_ident->network_long)) EQ 0)
#endif
        strcpy ((char *)data->plmn_name, (char *)data->network_name);

      /*
       * Store Roaming Indicator
       */
      data->roaming_indicator = plmn_ident->roaming_indicator;

      network_stop_animation ();
      /*
       * Inform Idle screen
       */
      SEND_EVENT (idle_get_window(), NETWORK_FULL_SERVICE, 0, 0);

      /*
       * If network list is available
       */
      if (data->network_list NEQ NULL)
      {
        switch (data->network_list_status)
        {
          case NETWORK_LIST_REGISTRATION:
            if(data->keep_plmn_list EQ FALSE)
            {
	            TRACE_EVENT("NETWORK_LIST_REGISTRATION No 1");

			    FREE_MEMORY ((UBYTE *)data->network_list->List, MAX_PLMN_ID * sizeof (T_MFW_MNU_ITEM));

                FREE_MEMORY ((UBYTE *)data->network_list, sizeof (ListMenuData));
                data->network_list = NULL;
            }
            data->keep_plmn_list = FALSE;
            break;
          case NETWORK_LIST_SELECTED:
            /*
             * After registration start, MFW returns the current status
             */
            TRACE_EVENT("NETWORK_LIST_REGISTRATION");
            data->network_list_status= NETWORK_LIST_REGISTRATION;
			/* Commented out and moved
       		network_selected(); */
            break;
        }
        // API - Moved from previous position
		network_selected(); 
      }
      break;

    case NETWORK_NO_NETWORK:
      TRACE_EVENT ("NETWORK NO NETWORK");
      /*
       * No PLMN found after search for available PLMNs
       */
      network_stop_animation ();
      if (network_log_enabled ())
      {
        data->status = NETWORK_NO_SERVICE;
        SEND_EVENT (idle_get_window(), NETWORK_NO_PLMN_XXX_AVAIL, 0, 0);
      }
      else
      {
        /*
         * No Networks found.
         */
        data->status = NETWORK_NO_SERVICE;
        SEND_EVENT (idle_get_window(), NETWORK_NO_SERVICE, 0, 0);
      }
#ifdef MMI_HOMEZONE_ENABLED
	/* sh - tell homezone there is no network */
	homezoneUpdate(0,0);
#endif
      break;

    case NETWORK_PLMN_LIST:
      TRACE_EVENT ("NETWORK PLMN LIST");
       TRACE_EVENT (">>NETWORK PLMN LIST");
      /*
       * PLMN list found
       */
	  if (network_data.aborted != TRUE)
	  {
		  if (network_log_enabled ())
		  {
			data->status = NETWORK_NO_SERVICE;
			SEND_EVENT (idle_get_window(), NETWORK_NO_PLMN_XXX_AVAIL, 0, 0);
		  }
		  else
		  {
			T_MFW_PLMN_LIST * plmn_list;
			/*
			 * Networks founds.
			 */
			data->status = NETWORK_NO_SERVICE;
			/*
			 * If network list is available, destroy
			 */
			if (data->network_list NEQ NULL)
			{
			 
			  FREE_MEMORY ((UBYTE *)data->network_list->List, MAX_PLMN_ID * sizeof (T_MFW_MNU_ITEM));
			  
			  FREE_MEMORY ((UBYTE *)data->network_list, sizeof (ListMenuData));
			  data->network_list = NULL;
			}

			/*
			 * If list is empty, show info screen
			 */
			plmn_list = (T_MFW_PLMN_LIST *)parameter;
			if (plmn_list->count EQ 0)
			{
			  network_stop_animation ();
			  network_no_plmns ();
			}
			else
			{
			  /*
			   * Create and present list of available PLMNs
			   *
			   */
			  data->network_list = network_create_list (data, parameter);
			  data->network_list_status = NETWORK_LIST_DISPLAY_FIRST;
			  network_stop_animation ();
			  listDisplayListMenu (win, data->network_list,  (ListCbFunc)network_list_cb,0);
			  SEND_EVENT (idle_get_window(), NETWORK_NO_SERVICE, 0, 0);
			}
		}
      }
	  else
	  {
		  network_data.aborted = FALSE;
	  }
#ifdef MMI_HOMEZONE_ENABLED
	/* sh - tell homezone there is no network */
	homezoneUpdate(0,0);
#endif
      break;

    case NETWORK_LIST_SELECT_PLMN:
      TRACE_EVENT ("NETWORK LIST_SELECT");
       TRACE_EVENT (">> NETWORK LIST_SELECT");
      /*
       * A network has been selected from the PLMN available list
       * Start manual registration and start Search animation.
       */
      network_start_animation_plmn_selection (value);
      data->network_list_status = NETWORK_LIST_SELECTED;
      nm_select_plmn ((U8 *)network_data.network_search_name[value]);
      break;
   case NETWORK_PPLMN_MEM_LIST:
	  {
      T_MFW_PPLMN_MEM *pplmn_mem;
	  UBYTE i;

      TRACE_EVENT ("NETWORK PPLMN MEM LIST");

      TRACE_EVENT (">> NETWORK PPLMN MEM LIST");
      /*  Save the number of PLMN records:
       *  maxRcd  = maximum preferred PLMN records on the SIM card
       *  usedRcd = used preferred PLMN records on the SIM card
       */
      pplmn_mem = (T_MFW_PPLMN_MEM *)parameter; 

	  network_data.pplmn_mem.maxRcd  = pplmn_mem->maxRcd;
	  network_data.pplmn_mem.usedRcd = pplmn_mem->usedRcd;

      /*
       * Request preferred PLMN list from the SIM
       */

      	
	    network_data.pplmn = (T_MFW_NETWORK_STRUCT *)ALLOC_MEMORY ((pplmn_mem->maxRcd) * sizeof (T_MFW_NETWORK_STRUCT));
      	
		if (network_data.pplmn EQ 0)
		{
			return;
		}

	 	if (pplmn_mem->usedRcd > 0)
		 {
		 	 // request MFW to fill up the pref. PLMN list
		     nm_pref_plmn_list(network_data.pplmn, pplmn_mem->maxRcd, 1);
		 }
	 	else
	 	{
	 		// doesnt make sense to request the MFW to fill up the list
	 		// when the "pplmn_mem->usedRcd" is  0

			 for (i=0; i < (network_data.pplmn_mem.maxRcd); i++)
			 {
#ifdef NO_ASCIIZ
				network_data.pplmn[i].network_long.len = 0;
				network_data.pplmn[i].network_short.len = 0;
#else			 	
				memset(network_data.pplmn[i].network_long,   '\0', LONG_NAME);
				memset(network_data.pplmn[i].network_short,   '\0', SHORT_NAME);
#endif
				memset(network_data.pplmn[i].network_numeric, '\0', NUMERIC_LENGTH);
			 }
			
		    data->network_list = network_create_pref_list (data);
		    listDisplayListMenu (win, data->network_list,(ListCbFunc)network_pref_list_cb,0);
	 	}

      }
      break;

   case NETWORK_PREFERRED_LIST:
	  {			

	  UBYTE i;

	  
      TRACE_EVENT (">>NETWORK PREFERRED LIST");
      /*
       *  Create and present the preferred list of PLMNs
       * 
       */

      //nm      network_stop_animation ();

      
    data->network_list = network_create_pref_list (data);
    listDisplayListMenu (win, data->network_list,(ListCbFunc)network_pref_list_cb,0);
      }   
      break;

  case NETWORK_CELL_SELECT:
  	{
  	/* If Homezone is active, inform it of the new cell data */
  	T_MFW_CELL_STRUCT *cell_data;
  	
  	TRACE_EVENT(">>NETWORK CELL SELECT");

	cell_data = (T_MFW_CELL_STRUCT *)parameter;

#ifdef MMI_HOMEZONE_ENABLED
	/* SPR759 - SH - send cell reselection info to homezone */
	homezoneUpdate(cell_data->lid, cell_data->ci);
#endif
	break;

  }
  }
}

/*

/*******************************************************************************

 $Function:    	network_win_cb

 $Description:	network top window

 $Returns:		

 $Arguments:	
 
*******************************************************************************/
static int network_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  /*
   * Top Window has no output
   */
  return 1;
}


/*******************************************************************************

 $Function:    	network_nm_cb

 $Description:	network handler (mfw callback handler)

 $Returns:		

 $Arguments:	
 
*******************************************************************************/
static int network_nm_cb (T_MFW_EVENT event, T_MFW_HND para)
{
  TRACE_FUNCTION("network_nm_cb");

  switch(event)
  {
    case E_NM_FULL_SERVICE:
      SEND_EVENT (network_data.network_win, NETWORK_FULL_SERVICE, 0, para);
      break;

    case E_NM_LIMITED_SERVICE:
      SEND_EVENT (network_data.network_win, NETWORK_LIMITED_SERVICE, 0, para);
      break;

    case E_NM_NO_SERVICE:
      SEND_EVENT (network_data.network_win, NETWORK_NO_SERVICE, 0, para);
   	  break;

    case E_NM_SEARCH_NETWORK:
	  SEND_EVENT (network_data.network_win, NETWORK_SEARCH_NETWORK, 0, para);
   	  break;

    case E_NM_NO_NETWORK:
	  SEND_EVENT (network_data.network_win, NETWORK_NO_NETWORK, 0, para);
  	  break;

	case E_NM_PLMN_LIST:
	  SEND_EVENT (network_data.network_win, NETWORK_PLMN_LIST, 0, para);
      break;

	case E_NM_DEREGISTRATION:
		TRACE_EVENT("MmiNetwork:E_NM_DEREGISTRATION");
		mainShutdown();
		break;
	case E_NM_PREF_PLMN_LIST:
		TRACE_EVENT("MmiNetwork:E_NM_PREF_PLMN_LIST");
        SEND_EVENT (network_data.network_win, NETWORK_PREFERRED_LIST, 0, para);
		break;
	case E_NM_PPLMN_MEM:
		TRACE_EVENT("MmiNetwork:E_NM_PPLMN_MEM");
        SEND_EVENT (network_data.network_win, NETWORK_PPLMN_MEM_LIST, 0, para);
		break;
	/* SH 29-04-02 - Cell reselection */
	case E_NM_CELL_SELECT:
		TRACE_EVENT("MmiNetwork:E_NM_CELL_SELECT");
		SEND_EVENT (network_data.network_win, NETWORK_CELL_SELECT, 0, para);
		break;
	/* SPR919 - SH - Band selection */
	case E_NM_BAND:
		TRACE_EVENT("MmiNetwork:E_NM_BAND");
		nm_registration (nm_get_mode (),0, 0);
		break;
		
    default:
  	  return 0;
  }
  return 1;
}

/*******************************************************************************

 $Function:    	nm_flag_log_off

 $Description:	 Attribut function for menu entries.
    	       It defines whether the network log off function shall
	            be displayed or not.

 $Returns:		

 $Arguments:	
 
*******************************************************************************/
USHORT nm_flag_log_off (T_MFW_MNU * m, T_MFW_MNU_ATTR * ma, T_MFW_MNU_ITEM * mi)
{
  if (FFS_flashData.net_log_status EQ NM_LOG_AVAIL_USED)
    return 0;

  return MNU_ITEM_HIDE;
}
/*******************************************************************************

 $Function:    	nm_flag_log_off

 $Description:	 Attribut function for menu entries.
    	       It defines whether the network log off function shall
	            be displayed or not.

 $Returns:		

 $Arguments:	
 
*******************************************************************************/
USHORT nm_flag_log_on (T_MFW_MNU * m, T_MFW_MNU_ATTR * ma, T_MFW_MNU_ITEM * mi)
{
  if (FFS_flashData.network_name == NULL)
  {
    return MNU_ITEM_HIDE;
  }
  if (FFS_flashData.net_log_status EQ NM_LOG_AVAIL_NOT_USED)
    return 0;

  return MNU_ITEM_HIDE;
}

/*******************************************************************************

 $Function:    	network_set_mode_auto

 $Description:	 Start a automatic registration
    	     
 $Returns:		

 $Arguments:	
 
*******************************************************************************/
int network_set_mode_auto(T_MFW_MNU *m, T_MFW_MNU_ITEM *i)
{
  TRACE_FUNCTION ("network_set_mode_auto()");

  /*
   * Save the automatic mode in PCM for next power on
   */
  nm_set_mode(NM_AUTOMATIC);

  /*
   * Start the registration of full service
   */
  nm_registration (NM_AUTOMATIC,0, FALSE);

  /*
   * remove network log if needed