cphs_mod.c

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

 }


 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_Exit() |
+--------------------------------------------------------------------+


*/
/* de-initializes CPHS module                                          */
T_CPHS_RET cphs_Exit()
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	free(cphs_data);

	return CPHS_IS_OK;
}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getOPN  |
+--------------------------------------------------------------------+


*/
  /* reads from SIM the operator long name and if available the short    */
  /* name, too  */
T_CPHS_RET cphs_getOPN            ( T_CPHS_OPN *opn )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (opn EQ NULL)
  		return CPHS_FAIL;
	memcpy(opn, &cphs_data->opName, sizeof(T_CPHS_OPN));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getRoamingInd |
+--------------------------------------------------------------------+


*/

/* checks if roaming is active                                         */
T_CPHS_RET cphs_getRoamingInd     ( T_CPHS_ROAMING_IND *indicator )
{	T_ACI_COPS_MOD  mode;
  	T_ACI_COPS_FRMT  format;
    CHAR  oper[30];
    T_OPER_NTRY* plmn_entry;
    SHORT mccBuf, mncBuf;
    char debug[50];
    UBYTE numeric[8];
    char ** end;
    memset(oper, 0, 30);

	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (indicator EQ NULL)
		return CPHS_FAIL;
	memcpy(indicator, &cphs_data->roaming_ind, sizeof(T_CPHS_ROAMING_IND));
/*

		qAT_PlusCOPS (CMD_SRC_NONE,&mode,&format,oper );
		//get current MCC
		if (format == COPS_FRMT_Long OR format == COPS_FRMT_Short)
		{	sAT_PlusCOPSE(oper, format, NULL, NULL, numeric);
		//	plmn_entry = cmhMM_FindName( oper, format );
			numeric[3] = 0;//terminate string before MNC
			plmn_entry->mcc = strtol((char*)numeric,end,16 );
		}

		if (format == COPS_FRMT_Numeric)
		{	//plmn_entry = cmhMM_FindNumeric( oper );
			oper[3] = 0;
			plmn_entry->mcc = strtol((char*)oper, end, 16);
		}
		//get "Home MCC"
		cmhSIM_GetHomePLMN ( &mccBuf, &mncBuf );
		//currently qAT_PlusCOPS is not returning the correct format
		//cmhMM_FindName/Numeric rely on PCM which does not work
		sprintf(debug, "Home MCC %d, current MCC %d COPS fmt:%d", plmn_entry->mcc, mccBuf, format);
		TRACE_EVENT(debug);
		if (plmn_entry->mcc == mccBuf)
			*indicator = CPHS_ROAMING_OFF;
		else
			*indicator = CPHS_ROAMING_ON;
*/
	return CPHS_IS_OK;

}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getVoiceMessageInd |
+--------------------------------------------------------------------+


*/

 /* reads from SIM if voice mails are waiting for the available lines   */
  /* (line1, line2, fax, data)                                           */
T_CPHS_RET cphs_getVoiceMessageInd( T_CPHS_LINE_IND *indicator )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (indicator EQ NULL)
  		return CPHS_FAIL;
	memcpy(indicator, &cphs_data->mbStatus, sizeof(T_CPHS_LINE_IND));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setVoiceMessageInd |
+--------------------------------------------------------------------+


*/
/* sets on SIM the voice mail waiting flag for the given lines in the  */
  /* parameter line_mask. The bitmask will be created by oring the lines.*/
  /* The bits for the lines are defined in T_CPHS_LINE_INDEX.            */
T_CPHS_RET cphs_setVoiceMessageInd( UBYTE              line_mask,
                                    T_CPHS_FLAG_STATUS flag )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (CPHS_LINE_INDEX_LINE1 & line_mask)
	{	cphs_data->mbStatus.line1 = flag;
		TRACE_EVENT("Setting Line 1 VM");
		Cphs_set_mailbox_status(flag,CPHS_FLAG_NOT_PRESENT ,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}

	if (CPHS_LINE_INDEX_LINE2 & line_mask)
	{	TRACE_EVENT("SEtting line 2 VM");
		cphs_data->mbStatus.line2 = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, flag,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_FAX & line_mask)
	{	cphs_data->mbStatus.fax = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,flag,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_DATA & line_mask)
	{	cphs_data->mbStatus.data = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT,flag);
	}



	return CPHS_EXEC;
}
  /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getDivertCallInd   |
+--------------------------------------------------------------------+
*/


  /* reads from SIMif calls shall be diverted for the available lines    */
  /* (line1, line2, fax, data) */
T_CPHS_RET cphs_getDivertCallInd  (T_CPHS_LINE_IND *indicator )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (ind EQ NULL)
		return CPHS_FAIL;
	memcpy(indicator, &cphs_data->dvStatus, sizeof(T_CPHS_LINE_IND));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setDivertCallInd |
+--------------------------------------------------------------------+
*/
  /* sets on SIM the divert call flag for the given lines in the         */
  /* parameter line_mask. The bitmask will be created by oring the lines.*/
  /* The bits for the lines are defined in T_CPHS_LINE_INDEX.            */
T_CPHS_RET cphs_setDivertCallInd  ( UBYTE              line_mask,
                                    T_CPHS_FLAG_STATUS flag )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (CPHS_LINE_INDEX_LINE1 & line_mask)
	{	cphs_data->dvStatus.line1 = flag;
		TRACE_EVENT("Setting line 1 divert");
		Cphs_set_divert_status(flag,CPHS_FLAG_NOT_PRESENT ,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}

	if (CPHS_LINE_INDEX_LINE2 & line_mask)
	{	cphs_data->dvStatus.line2 = flag;
		TRACE_EVENT("Setting line 2 divert");
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, flag,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_FAX & line_mask)
	{	cphs_data->dvStatus.fax = flag;
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,flag,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_DATA & line_mask)
	{	cphs_data->dvStatus.data = flag;
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT,flag);
	}

	return CPHS_EXEC;

}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getAlsInfo |
+--------------------------------------------------------------------+
*/
  /* reads from SIM the information of alternate line service            */
  /* ( selected line, alternate line service locked/unlocked)            */
T_CPHS_RET cphs_getAlsInfo        ( T_CPHS_ALS_INFO *info )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (info EQ NULL)
		return CPHS_FAIL;

	//memcpy(info, &cphs_data->alsStatus, sizeof( T_CPHS_ALS_INFO));
	Cphs_read_eeprom_als(info);
	return CPHS_IS_OK;

}
   /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setAlsInfo|
+--------------------------------------------------------------------+
*/
  /* sets on SIM the informtion of alternate line service / selects the  */
  /* active line */
T_CPHS_RET cphs_setAlsInfo        ( T_CPHS_ALS_INFO *info )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (info EQ NULL)
  		return CPHS_FAIL;
	//memcpy(&cphs_data->alsStatus, info, sizeof(T_CPHS_ALS_INFO));
 	return Cphs_write_eeprom_als(info);
 	//return CPHS_EXEC;
 }
   /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getAlsLineDescr |
+--------------------------------------------------------------------+
*/
 /* reads the (alpha)numeric description for the given line             */
T_CPHS_RET cphs_getAlsLineDescr   ( T_CPHS_ALS_LINE* line )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (line EQ NULL)
		return CPHS_FAIL;
	Cphs_read_eeprom_als_desc();
 	if (line->line EQ CPHS_LINE_INDEX_LINE1)
	{	memcpy(line,&cphs_data->Line1_desc,  sizeof(T_CPHS_ALS_LINE));
 		return CPHS_IS_OK;
 	}

 	if (line->line EQ CPHS_LINE_INDEX_LINE2)
	{	memcpy( line, &cphs_data->Line2_desc,sizeof(T_CPHS_ALS_LINE));
 		return CPHS_IS_OK;
 	}

	return CPHS_FAIL;
 }
  /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE :cphs_setAlsLineDescr |
+--------------------------------------------------------------------+
*/
 /* sets a (alpha)numeric description for the given line                */
T_CPHS_RET cphs_setAlsLineDescr   ( T_CPHS_ALS_LINE line )

 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

 	if (line.line EQ CPHS_LINE_INDEX_LINE1)
	{	memcpy(&cphs_data->Line1_desc,&line,  sizeof(T_CPHS_ALS_LINE));
 		Cphs_write_eeprom_als_desc(&cphs_data->Line1_desc);
 		return CPHS_IS_OK;
 	}

 	if (line.line EQ CPHS_LINE_INDEX_LINE2)
	{	memcpy(&cphs_data->Line2_desc, &line, sizeof(T_CPHS_ALS_LINE));
 		Cphs_write_eeprom_als_desc(&cphs_data->Line2_desc);
 		return CPHS_IS_OK;
 	}

	return CPHS_FAIL;
 }
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setRoamingInd |
+--------------------------------------------------------------------+

*/
T_CPHS_RET cphs_setRoamingInd ( T_CPHS_ROAMING_IND* indicator )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (*indicator EQ CPHS_ROAMING_OFF OR *indicator EQ CPHS_ROAMING_ON)
	{	cphs_data->roaming_ind  = *indicator;
		return CPHS_IS_OK;
	}
	else
		return CPHS_FAIL;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_checkEmergencyCall |
+--------------------------------------------------------------------+
*/

/* check if the current call number(ASCII encoded) is an emergency number supported     */
/* by CPHS.                                                              */
T_CPHS_RET cphs_checkEmergencyCall( char* num )
{	char** end;


	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (num EQ NULL)
		return CPHS_FAIL;

	if (strtol(num, end, 10)EQ CPHS_EMERGENCY_NUM_112 OR
		strtol(num, end, 10)EQ CPHS_EMERGENCY_NUM_999)
		return CPHS_IS_OK;
	else
		return CPHS_FAIL;
}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getCPHSInfo  |
+--------------------------------------------------------------------+
*/
 /* reads from SIM the phase of the SIM and which optional datafields   */
  /* are present in the SIM                                              */
  /* (operator name shortform, mailbox numbers, service string table,    */
  /*  information numbers)                                               */
T_CPHS_RET cphs_getCPHSInfo       ( T_CPHS_INFO *info )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (info !=NULL)
  {
    info->phase = cphs_data->cphsPhase;
    info->csp   = Cphs_ssc(CPHS_CSP,          cphs_data->cphsServTab);
    info->mailbox_num = Cphs_ssc(CPHS_MB_NUMBER,    cphs_data->cphsServTab);

    if (cphs_data->cphsPhase EQ 1) /* phase 1 only */
      info->sst = Cphs_ssc(CPHS_SST,          cphs_data->cphsServTab);
    else                /* not support */
      info->sst = NO_ALLOCATED;

    if (cphs_data->cphsPhase EQ 2) /* phase 2 only */
    {
      info->opn_short  = Cphs_ssc(CHPS_NAME_SHORT,   cphs_data->cphsServTab);
      info->info_num  = Cphs_ssc(CHPS_INFO_NUMBERS, cphs_data->cphsServTab);
    }
    else                /* not support */
    {
      info->opn_short  = NO_ALLOCATED;
      info->info_num  = NO_ALLOCATED;
    }
    return CPHS_IS_OK;
  }
  return CPHS_FAIL;

 }

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getCSP |
+--------------------------------------------------------------------+

*/
 /* reads all entries of the customer service profile and fills         */
T_CPHS_RET cphs_getCSP            ( T_CPHS_CSP *csp )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (csp EQ NULL)
		return CPHS_FAIL;

	memcpy(csp, &cphs_data->csProfile, sizeof(T_CPHS_CSP));
	return CPHS_IS_OK;
 }