phonebook.cpp

mtk simulator v2 new source code

				for (i = 0; i < gTotalPbookEntrySim; i++)  {
					if ( phbEntriesSim[i].index ==  deleteEntryReq->index)
						break;
				}
				for (j = i; j < gTotalPbookEntrySim - 1; j++)  phbEntriesSim[j] = phbEntriesSim[j+1];
				/* Reduce Number Of Entries*/
				gTotalPbookEntrySim--;
				/*Write Updates Data To File*/
				WriteToFile(MMI_SIM);
			}
			/*Storage is for Phone*/
			if (deleteEntryReq->storage==2) {	
				for (i = 0; i < gTotalPbookEntryPhone; i++) {
					if ( phbEntriesPhone[i].index ==  deleteEntryReq->index)
						break;
				}
				for (j = i; j < gTotalPbookEntryPhone - 1; j++)  phbEntriesPhone[j] = phbEntriesPhone[j+1];

				gTotalPbookEntryPhone--;
				WriteToFile(MMI_NVRAM);
			}
		}
		/*If Delete All Request Is True*/
		else if (deleteEntryReq->del_all == 1) {
			/*For Sim*/
			if (deleteEntryReq->storage==1) {	
				gTotalPbookEntrySim=0;
				WriteToFile(1);
			}
			if (deleteEntryReq->storage==2) {	
			/*For Phone*/
				gTotalPbookEntryPhone=0;
				WriteToFile(2);
			}
		}
	}

	deleteEntryRsp = (MSG_PHB_DELETE_ENTRY_RSP_STRUCT *)CMemAllocator::MyMallocDataPtr(sizeof(MSG_PHB_DELETE_ENTRY_RSP_STRUCT));
	memset( deleteEntryRsp, '\0', sizeof(MSG_PHB_DELETE_ENTRY_RSP_STRUCT) );
	deleteEntryRsp->result.flag = 0;
	deleteEntryRsp->no_list = gTotalPbookEntry;
	return (void *) deleteEntryRsp;
}


/*****************************************************************************
* FUNCTION
*	HandleGetAllEntriesRequest
* DESCRIPTION
*	This API fill the phone book/fdn/sdn/msisdn database for simulator.
* PARAMETERS
*	void
* RETURNS
*	void * -	MSG_PHB_GET_ENTRY_BY_INDEX_RSP_STRUCT structure pointer hold  
*				phone book data base.
*****************************************************************************/

void *HandleGetAllEntriesRequest() {
	U16 k;
	U16 i;
	MSG_PHB_GET_ENTRY_BY_INDEX_REQ_STRUCT *readbyIndexReq = (MSG_PHB_GET_ENTRY_BY_INDEX_REQ_STRUCT *)gBuffer;

	ReadFromFile(readbyIndexReq->type);

	greadByIndexRsp = (MSG_PHB_GET_ENTRY_BY_INDEX_RSP_STRUCT*)CMemAllocator::MyMallocDataPtr(sizeof(MSG_PHB_GET_ENTRY_BY_INDEX_RSP_STRUCT));
	greadByIndexRsp->result.flag = 0;  //OK
	greadByIndexRsp->result.cause = 0; //L4C_NO_CAUSE

	/* Request is for phonebook database */
	if(readbyIndexReq->type == MMI_PHB_PHONEBOOK) {
		/* If request is for the SIM database fill the simulator structure for sim*/
		if (readbyIndexReq->storage == MMI_SIM) 
			greadByIndexRsp->no_list = gTotalPbookEntrySim;
		/*If request is for Phone database*/
		if (readbyIndexReq->storage == MMI_NVRAM) 
			greadByIndexRsp->no_list = gTotalPbookEntryPhone;
		/*If the request is for both */
		if (readbyIndexReq->storage == MMI_STORAGE_NONE) 
			greadByIndexRsp->no_list = gTotalPbookEntrySim+gTotalPbookEntryPhone;
		/*Fills the simultor structre for Sim Database*/
		for (i = 0,k=0; i < gTotalPbookEntrySim; i++,k++) {
			greadByIndexRsp->list[k] = phbEntriesSim[i];
		}
		/*Fills the simulator structre for Phone Database*/
		for (i = 0; i < gTotalPbookEntryPhone; i++,k++) {
			greadByIndexRsp->list[k] = phbEntriesPhone[i];
		}
	}
	/*If the database req is for the FDN number*/
	else if(readbyIndexReq->type == MMI_PHB_FDN) {
		if (readbyIndexReq->storage==1) 
			greadByIndexRsp->no_list = gTotalFDNEntries;
		for (i = 0,k=0; i < gTotalFDNEntries; i++,k++) {
			greadByIndexRsp->list[k] = FDNEntries[i];
		}
	}
	/*If database req is for MSISDN*/
	else if(readbyIndexReq->type == MMI_PHB_MSISDN) {	
		greadByIndexRsp->no_list = gTotalPbookEntryMSISDN;
		for (i = 0;i < gTotalPbookEntryMSISDN;i++)
			greadByIndexRsp->list[i] = phbEntries[i];
	}
	/*If Database req is for SDN*/
	else if(readbyIndexReq->type == MMI_PHB_SDN) {	
		greadByIndexRsp->no_list = gTotalPbookEntrySDN;
		for (i = 0;i < gTotalPbookEntrySDN;i++)
			greadByIndexRsp->list[i] = phbEntries[i];
	}
	/*If database req is for ECC*/
	else if(readbyIndexReq->type == MMI_PHB_ECC) {
		greadByIndexRsp->no_list = 5;
		for (i = 0; i < 5; i++) {
			greadByIndexRsp->list[i].storage = MMI_SIM;
			greadByIndexRsp->list[i].type	= 0;
			greadByIndexRsp->list[i].record_index = i+1;
			greadByIndexRsp->list[i].index = i+1;
			greadByIndexRsp->list[i].tel.type = 129;
			greadByIndexRsp->list[i].tel.length = 3;
			greadByIndexRsp->list[i].alpha_id.name_length = 0;
			greadByIndexRsp->list[i].alpha_id.name_dcs = 0;
			memset(greadByIndexRsp->list[i].alpha_id.name, 0, 2);
		}
		strcpy((PS8)greadByIndexRsp->list[0].tel.number, "112");
		strcpy((PS8)greadByIndexRsp->list[1].tel.number, "113");
		strcpy((PS8)greadByIndexRsp->list[2].tel.number, "114");
		strcpy((PS8)greadByIndexRsp->list[3].tel.number, "115");
		strcpy((PS8)greadByIndexRsp->list[4].tel.number, "116");
	}

	return (void *) greadByIndexRsp;	
}

/*****************************************************************************
* FUNCTION
*	RepHandleGetAllEntriesRequest
* DESCRIPTION
*	This API returns the phone book/fdn/sdn/msisdn database to MMI.
* PARAMETERS
*	void
* RETURNS
*	void * -	MSG_PHB_GET_ENTRY_BY_INDEX_RSP_STRUCT structure pointer hold  
*				phone book data base.
*****************************************************************************/
void *RepHandleGetAllEntriesRequest()
{
	return (void *) greadByIndexRsp;
}

/*****************************************************************************
* FUNCTION
*	HandleGetStorageRequest
* DESCRIPTION
*	This API returns the used/max entires of phone book perfferd storage 
*	location.
* PARAMETERS
*	void
* RETURNS
*	void * -	MSG_PHB_GET_PREFERRED_STORAGE_RSP_STRUCT structure holds
*				the used/max entires of phone book perfferd storage location.
*****************************************************************************/
void * HandleGetStorageRequest() { 
	MSG_PHB_GET_PREFERRED_STORAGE_RSP_STRUCT *getStorageRsp;

	getStorageRsp = (MSG_PHB_GET_PREFERRED_STORAGE_RSP_STRUCT *)CMemAllocator::MyMallocDataPtr(sizeof(MSG_PHB_GET_PREFERRED_STORAGE_RSP_STRUCT));
	memset( getStorageRsp, '\0', sizeof(MSG_PHB_GET_PREFERRED_STORAGE_RSP_STRUCT) );
	getStorageRsp->result = PB_TRUE;
	getStorageRsp->storage = PreferredStorageLocation;
	/* If Prefferd Storage Location Is SIM*/
	if (getStorageRsp->storage==1) {	
		getStorageRsp->used = gTotalPbookEntrySim;
		getStorageRsp->total = MAX_PB_ENTRIES_SIM;
	}
	/* If Prefferd Storage Location Is Phone*/
	if (getStorageRsp->storage==2) {	
		getStorageRsp->used = gTotalPbookEntryPhone;
		getStorageRsp->total = MAX_PB_ENTRIES_PHONE;
	}
	
	return (void*)getStorageRsp;
}

/*****************************************************************************
* FUNCTION
*	HandleSetStorageRequest
* DESCRIPTION
*	This API save the phone book perfferd storage location.
* PARAMETERS
*	void
* RETURNS
*	void * -	MSG_PHB_SET_PREFERRED_STORAGE_RSP_STRUCT structure holds
*				Sucess or Failure of the request.
*****************************************************************************/
void * HandleSetStorageRequest() {
	MSG_PHB_SET_PREFERRED_STORAGE_REQ_STRUCT *setPBookStorageReq = (MSG_PHB_SET_PREFERRED_STORAGE_REQ_STRUCT *)gBuffer;
	MSG_PHB_SET_PREFERRED_STORAGE_RSP_STRUCT *setStorageRsp;
	static int i;
	setStorageRsp = (MSG_PHB_SET_PREFERRED_STORAGE_RSP_STRUCT *)CMemAllocator::MyMallocDataPtr(sizeof(MSG_PHB_SET_PREFERRED_STORAGE_RSP_STRUCT));	

	memset( setStorageRsp, '\0', sizeof(MSG_PHB_SET_PREFERRED_STORAGE_RSP_STRUCT) );
	if (!strcmp((const char*)setPBookStorageReq->pin, "11111")) {
		setStorageRsp->result = PB_TRUE;
		PreferredStorageLocation = (PHB_STORAGE_LOCATION_ENUM)setPBookStorageReq->storage;
	}
	else 
		setStorageRsp->result = PB_FALSE;
	if (i==0) 
	{	PreferredStorageLocation=MMI_SIM;
		i=1;}
	else if (i==1) 
	{	PreferredStorageLocation=MMI_NVRAM;
		i=0;
	}
	

	return setStorageRsp;
}

/*****************************************************************************
* FUNCTION
*	ReadFromFile
* DESCRIPTION
*	Read database from file for phonebook/fdn/msisdn/sdn
* PARAMETERS
*	U8 - Type Of Database phonebook/fdn/msisdn/sdn
* RETURNS
*	void
*****************************************************************************/
void ReadFromFile(U8 PbookType) {
	S8 str[100];
	S8 *token;
	gTotalPbookEntryPhone = 0;
	gTotalPbookEntrySim=0;
	gTotalFDNEntries=0;
	gTotalPbookEntryMSISDN=0;
	gTotalPbookEntry=0;
	gTotalPbookEntrySDN = 0;

	/* If the read request is for the FDN number*/
	if(PbookType == MMI_PHB_FDN) {
		if((pb = fopen("Phonebook_fdn.txt", "r")) == NULL) 
			return;
		else {
			while (fgets(str,100,pb)) {
				str[strlen(str) - 1]='\0';
				token = strtok(str, ",");
				FDNEntries[gTotalFDNEntries].index = atoi(token);
				token = strtok(NULL, ",");
 				FDNEntries[gTotalFDNEntries].record_index = atoi(token);
				token = strtok(NULL, ",");
				if(!strcmp(token,"NULL"))
					FDNEntries[gTotalFDNEntries].alpha_id.name[0] ='\0';
				else
					strcpy((S8 *)FDNEntries[gTotalFDNEntries].alpha_id.name, token);
				token = strtok(NULL, ",");
				FDNEntries[gTotalFDNEntries].alpha_id.name_dcs = atoi(token);
				token = strtok(NULL, ",");
				FDNEntries[gTotalFDNEntries].alpha_id.name_length = atoi(token);
				token = strtok(NULL, ",");
				FDNEntries[gTotalFDNEntries].tel.length = atoi(token);
				token = strtok(NULL, ",");
				FDNEntries[gTotalFDNEntries].tel.type = atoi(token);
				token = strtok(NULL, ",");
				if(!strcmp(token,"NULL"))
					FDNEntries[gTotalFDNEntries].tel.number[0] =  '\0';
				else
					strcpy((S8 *)FDNEntries[gTotalFDNEntries].tel.number, token);
				token = strtok(NULL, ",");
				FDNEntries[gTotalFDNEntries].storage = atoi(token);
			
				gTotalFDNEntries++;
			}
		}
		fclose(pb);

		if((pb = fopen("Phonebook_phone.txt", "r")) == NULL)
			return;
		else {
			while (fgets(str,100,pb)) {
				str[strlen(str) - 1]='\0';
				token = strtok(str, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].index = atoi(token);
				token = strtok(NULL, ",");
	 			phbEntriesPhone[gTotalPbookEntryPhone].record_index = atoi(token);
 				token = strtok(NULL, ",");
				if(!strcmp(token,"NULL"))
					phbEntriesPhone[gTotalPbookEntryPhone].alpha_id.name[0] ='\0';
				else
					strcpy((S8 *)phbEntriesPhone[gTotalPbookEntryPhone].alpha_id.name, token);
				token = strtok(NULL, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].alpha_id.name_dcs = atoi(token);
				token = strtok(NULL, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].alpha_id.name_length = atoi(token);
				token = strtok(NULL, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].tel.length = atoi(token);
				token = strtok(NULL, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].tel.type = atoi(token);
				token = strtok(NULL, ",");
				if(!strcmp(token,"NULL"))
					phbEntriesPhone[gTotalPbookEntryPhone].tel.number[0] =  '\0';
				else
					strcpy((S8 *)phbEntriesPhone[gTotalPbookEntryPhone].tel.number, token);
				token = strtok(NULL, ",");
				phbEntriesPhone[gTotalPbookEntryPhone].storage = atoi(token);
			
				gTotalPbookEntryPhone++;
			}
		}
	
		fclose(pb);
	}
	/*If the read request is for the phonebook*/
	else if(PbookType == MMI_PHB_PHONEBOOK) {
		if((pb = fopen("Phonebook_sim.txt", "r")) == NULL) 
			return;
		else {
			while (fgets(str,100,pb)) {
				str[strlen(str) - 1]='\0';
				token = strtok(str, ",");
				phbEntriesSim[gTotalPbookEntrySim].index = atoi(token);
				token = strtok(NULL, ",");
	 			phbEntriesSim[gTotalPbookEntrySim].record_index = atoi(token);
 				token = strtok(NULL, ",");
				if(!strcmp(token,"NULL"))
					phbEntriesSim[gTotalPbookEntrySim].alpha_id.name[0] ='\0';
				else
					strcpy((S8 *)phbEntriesSim[gTotalPbookEntrySim].alpha_id.name, token);
				token = strtok(NULL, ",");
				phbEntriesSim[gTotalPbookEntrySim].alpha_id.name_dcs = atoi(token);
				token = strtok(NULL, ",");