messages.cpp

mtk simulator v2 new source code

		else fread(&outbox, sizeof(outbox), 1, fp );
	}
	if( fp != NULL )fclose(fp);
}//abhi:Start:editing of voicemail numbers
void ReadVoiceMailFile()
{
	FILE *fp;
	if( (fp = fopen( "voicemail.txt", "rb" )) == NULL )
		SaveVoiceMailBoxNumbers();
	else 
	{
		fread(&voicemailbox, sizeof(voicemailbox), 1, fp );
		fclose(fp);
}
}
void WriteVoiceMailFile()
{
	FILE *fp;

	fp = fopen( "voicemail.txt", "wb" );
	
	fwrite(&voicemailbox, sizeof(voicemailbox), 1, fp );

	if( fp != NULL )fclose(fp);
}
//abhi:End

////////////////////////////////////////////////////////////
///////////New SMS Box Implementation///////////////////////
////////////////////////////////////////////////////////////
sms_box_struct sms_box;

void write_sms_box_file()
{
	FILE *fp;
	fp = fopen( SMS_BOX_FILE, "wb" );
	if(fp!=NULL)
	{
		fwrite(&sms_box, sizeof(sms_box), 1, fp );
		fclose(fp);
	}
}
void read_sms_box_file()
{
	FILE *fp;
	fp = fopen( SMS_BOX_FILE, "rb" );
	if(fp!=NULL)
	{
		fread(&sms_box, sizeof(sms_box), 1, fp );
		fclose(fp);
	}
	else
	{
		U8 i;
		memset(&sms_box,0,sizeof(sms_box));
		for(i=0;i<MAX_SMS_BOX_LIMIT;i++)
			sms_box.sms_box_entries[i].status=0xff;
		write_sms_box_file();
	}
}

void* SMSBootUpBeginInd()
{
	read_sms_box_file();
	return NULL;
}

void* SMSSendBootupReadInd()
{	 
	static entries_sent=0;///count of entries sent till now
	static last_index_sent=0;
	mmi_sms_startup_read_msg_ind_struct *SMSBootUpReadInd= 
		(mmi_sms_startup_read_msg_ind_struct*)CMemAllocator::MyMallocDataPtr(sizeof(mmi_sms_startup_read_msg_ind_struct));

	memset( SMSBootUpReadInd, 0, sizeof(mmi_sms_startup_read_msg_ind_struct));

	if(entries_sent+1>=sms_box.total_box_entries)
		SMSBootUpReadInd->startup_seq_num=1;///send it 1.. so that mmi does not send ReadNext request
											////for last entry or no entry case
	if(entries_sent<sms_box.total_box_entries)
	{//fil the valid entries
		for(;(last_index_sent<MAX_SMS_BOX_LIMIT)
			&&(sms_box.sms_box_entries[last_index_sent].status==0xff)
			;last_index_sent++);
		if(last_index_sent<MAX_SMS_BOX_LIMIT)
		{
			sms_box_entry *entry=&(sms_box.sms_box_entries[last_index_sent]);
			memcpy(&SMSBootUpReadInd->addr_number,&entry->addr_number,sizeof(l4c_number_struct));
			SMSBootUpReadInd->concat_info=entry->concat_info;
			SMSBootUpReadInd->dcs=entry->dcs;
			memcpy(SMSBootUpReadInd->dt,entry->dt,sizeof(entry->dt));
			SMSBootUpReadInd->fo=entry->fo;
			SMSBootUpReadInd->index=last_index_sent;
			SMSBootUpReadInd->mr=entry->mr;
			SMSBootUpReadInd->msg_data[0]=0;
			SMSBootUpReadInd->msg_len=0;
			SMSBootUpReadInd->mti=entry->mti;
			SMSBootUpReadInd->no_msg_data=0;
			SMSBootUpReadInd->ori_dcs=entry->ori_dcs;
			SMSBootUpReadInd->pid=entry->pid;
			memcpy(SMSBootUpReadInd->scts,entry->scts,sizeof(entry->scts));
			SMSBootUpReadInd->st=entry->st;
			SMSBootUpReadInd->status=entry->status;
			SMSBootUpReadInd->vp=entry->vp;
			entries_sent++;
			last_index_sent++;
		}
		else
			SMSBootUpReadInd->status=0xff;
	}
	else
		SMSBootUpReadInd->status=0xff;
	return SMSBootUpReadInd;
}

void *SaveSMSMessage()
{
	mmi_sms_set_msg_req_struct *SMSSetReq = ( mmi_sms_set_msg_req_struct * )gSMSBuffer;
	SYSTEMTIME  sysTime;
	//struct OutBoxStructType outBoxStruct ;

	mmi_sms_set_msg_rsp_struct *SMSSaveRsp = (mmi_sms_set_msg_rsp_struct *)CMemAllocator::MyMallocDataPtr(sizeof(mmi_sms_set_msg_rsp_struct));
	memset( SMSSaveRsp, 0, sizeof(mmi_sms_set_msg_rsp_struct));

	if( sms_box.total_box_entries< MAX_SMS_BOX_LIMIT)
	{
		// read from file
		U8 free_index=0;
		while((free_index<MAX_SMS_BOX_LIMIT)
			&&(sms_box.sms_box_entries[free_index].status!=0xff))
			free_index++;
		if(free_index<MAX_SMS_BOX_LIMIT)
		{
			sms_box_entry *entry= & sms_box.sms_box_entries[free_index];
			U8 total_segs=0,seg=0;
			U16 ref=0;

			memcpy(&entry->addr_number,&SMSSetReq->dest,sizeof(SMSSetReq->dest));
			total_segs=SMSSetReq->udhi & 0x7;
			if(total_segs <= 1)
			{
				total_segs=1;
				seg=1;
				ref=0;
			}
			else
			{
				seg = ((SMSSetReq->udhi >> 3) & 0x7) + 1;
				if(seg == 1)
				{	
					ref = free_index;
					ReferenceNumber  = free_index;
				}
				else
					ref = ReferenceNumber;
			}
			entry->concat_info=0;
			entry->concat_info|=total_segs<<16;				
			entry->concat_info|=seg<<24;
			entry->concat_info|=ref;
			entry->dcs=SMSSetReq->dcs;
			memset(&entry->dt,0,sizeof(entry->dt));///CHECKME
			entry->fo=0;
			entry->length=SMSSetReq->length;
			entry->mr=0;
			memcpy(entry->msg,SMSSetReq->msg,sizeof(entry->msg));
			entry->mti=1;//SMSAL_MTI_SUBMIT; // Outbox message
			entry->ori_dcs=0;
			entry->pid=SMSSetReq->pid;
			memcpy(&entry->sca_number,&SMSSetReq->sc_addr,sizeof(SMSSetReq->sc_addr));

			GetLocalTime (&sysTime);
			entry->scts[2] = ((sysTime.wDay%10) << 4)|(sysTime.wDay/10);
			entry->scts[1] = ((sysTime.wMonth%10) << 4)|(sysTime.wMonth/10);
			entry->scts[0] = ((sysTime.wYear%10) << 4)|((sysTime.wYear/10)%10);

			entry->scts[3] = ((sysTime.wHour%10) << 4)|(sysTime.wHour/10);
			entry->scts[4] = ((sysTime.wMinute%10) << 4)|(sysTime.wMinute/10);
			entry->scts[5] = ((sysTime.wSecond%10) << 4)|(sysTime.wSecond/10);

			entry->st=0;
			entry->status=SMSSetReq->status;
			entry->vp=SMSSetReq->vp;
			sms_box.total_box_entries++;
			write_sms_box_file();
///add to file
			SMSSaveRsp->result= KAL_TRUE;//return true
			SMSSaveRsp->cause = 0;
			SMSSaveRsp->index=free_index;
			SMSSaveRsp->status=SMSSetReq->status;
		}
		else
		{
			SMSSaveRsp->result= KAL_FALSE;
			SMSSaveRsp->cause = 322;
		}
	}
	else
	{
		SMSSaveRsp->result= KAL_FALSE;
		SMSSaveRsp->cause = 322;
	}
	return SMSSaveRsp;
}

void *SendSMSToMMI()
{
	mmi_sms_deliver_msg_ind_struct	*msg_deliver_ind= (mmi_sms_deliver_msg_ind_struct*)
		CMemAllocator::MyMallocDataPtr(sizeof(mmi_sms_deliver_msg_ind_struct));
	int index = 0 ;
	SYSTEMTIME  sysTime;

#define    dummy_sms_text	"Hello Friend - just a test message number .. "
#define    dummy_sms_addr   "981234567812345678"

//	#define    DummySMSSrc   "AirtelLive"
	char mydata[160];
	char mynumber[40];

	//save a new dummy message in InboxFile
	//get current Inbox entries
	if(sms_box.total_box_entries< MAX_MESSAGES_LIMIT) 
	{
		// read from file
		U8 free_index=0;
		while((free_index<MAX_SMS_BOX_LIMIT)
			&&(sms_box.sms_box_entries[free_index].status!=0xff))
			free_index++;
		if(free_index<MAX_SMS_BOX_LIMIT)
		{
			sms_box_entry *entry= &sms_box.sms_box_entries[free_index];
			U8 total_segs=1,seg=1;
			U16 ref=0;
///fill the Entry
			entry->addr_number.length=strlen(dummy_sms_addr);
			entry->addr_number.type=145;//CSMCC_DEFAULT_ADDR_TYPE
			strcpy((char*)&entry->addr_number.number[0],dummy_sms_addr);

			entry->concat_info=0;
			entry->concat_info|=total_segs<<16;				
			entry->concat_info|=seg<<24;
			entry->concat_info|=ref;
			
			entry->dcs=0;//default dcs
			memset(&entry->dt,0,sizeof(entry->dt));
			entry->fo=0;
			entry->length=strlen(dummy_sms_text);
			strcpy((char*)&entry->msg[0],dummy_sms_text);
			entry->mr=0;
			entry->mti=0;//SMSAL_MTI_DELIVER
			entry->ori_dcs-=0;
			entry->pid=0;
			memset(&entry->sca_number,0,sizeof(entry->sca_number));

			GetLocalTime (&sysTime);
			entry->scts[2] = ((sysTime.wDay%10) << 4)|(sysTime.wDay/10);
			entry->scts[1] = ((sysTime.wMonth%10) << 4)|(sysTime.wMonth/10);
			entry->scts[0] = ((sysTime.wYear%10) << 4)|((sysTime.wYear/10)%10);
			entry->scts[3] = ((sysTime.wHour%10) << 4)|(sysTime.wHour/10);
			entry->scts[4] = ((sysTime.wMinute%10) << 4)|(sysTime.wMinute/10);
			entry->scts[5] = ((sysTime.wSecond%10) << 4)|(sysTime.wSecond/10);
			
			entry->st=0;
			entry->status=0;//SMSAL_REC_UNREAD
			entry->vp=0;
///write to file
			sms_box.total_box_entries++;
			write_sms_box_file();
////fill deliver struct
			msg_deliver_ind->concat_info=entry->concat_info;
			msg_deliver_ind->dcs=entry->dcs;
			msg_deliver_ind->dest_port=0;
			msg_deliver_ind->display_type=0;
			msg_deliver_ind->fo=entry->fo;
			msg_deliver_ind->index=free_index;
			msg_deliver_ind->msg_data[0]=0;
			msg_deliver_ind->mti=0;////SMSAL_MTI_DELIVER
			msg_deliver_ind->no_msg_data=0;
			memcpy(&msg_deliver_ind->oa_number,&entry->addr_number,sizeof(entry->addr_number));
			msg_deliver_ind->pid=entry->pid;
			memset(&msg_deliver_ind->sca_number,0,sizeof(msg_deliver_ind->sca_number));
			memcpy(&msg_deliver_ind->scts,&entry->scts,sizeof(entry->scts));
			msg_deliver_ind->src_port=0;
		}
	}
	return (void*)msg_deliver_ind;
}

void *SendSMSContectByIndex( )
{
	mmi_sms_get_msg_req_struct *smsGetReq = (mmi_sms_get_msg_req_struct *)gSMSBuffer;
	//mmi_sms_set_msg_req_struct *SMSSetReq;
	U8 index= (smsGetReq->index);
		mmi_sms_get_msg_rsp_struct *SMSGetResponse=
			(mmi_sms_get_msg_rsp_struct*)
			CMemAllocator::MyMallocDataPtr(sizeof(*SMSGetResponse)+
			160);		
	if((index<MAX_SMS_BOX_LIMIT)
		&&(sms_box.sms_box_entries[index].status!=0xff))
	{
		
		sms_box_entry *entry=&(sms_box.sms_box_entries[index]);

		memset (SMSGetResponse, 0, sizeof(*SMSGetResponse)+
			160);

		memcpy(&SMSGetResponse->addr_number,&entry->addr_number,sizeof(entry->addr_number));
		SMSGetResponse->cause=0;
		SMSGetResponse->dcs=entry->dcs;
		memcpy(&SMSGetResponse->dt,&entry->dt,sizeof(entry->dt));
		SMSGetResponse->fo=entry->fo;
		SMSGetResponse->mr=entry->mr;
		strcpy((char*)&SMSGetResponse->msg_data[0],(char*)&entry->msg[0]);
		SMSGetResponse->no_msg_data=entry->length;
		SMSGetResponse->mti=entry->mti;
		SMSGetResponse->ori_dcs=entry->ori_dcs;
		SMSGetResponse->pid=entry->pid;
		SMSGetResponse->result=KAL_TRUE;
		memcpy(&SMSGetResponse->sca_number,&entry->sca_number,sizeof(entry->sca_number));
		memcpy(SMSGetResponse->scts,entry->scts,sizeof(entry->scts));
		SMSGetResponse->st=entry->st;
		if(smsGetReq->change_status==KAL_TRUE)
		{
			if(entry->status==0)//SMSAL_REC_UNREAD
				entry->status=1;//SMSAL_REC_READ
			write_sms_box_file();
		}
		SMSGetResponse->status=entry->status;
		SMSGetResponse->vp=entry->vp;
	}
	else
	{
		SMSGetResponse->result=KAL_FALSE;
	}
	return (void*)SMSGetResponse;
}
U8 IsBitOnInBitmap(U8* bitmap, U8 index)
{
	U8 ret_val=0;