mmsagent.c

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

		data->fp    = ffs_open(g_fullname, FFS_O_RDONLY);
		if(data->fp    <=0 )
		{
			TRACE_EVENT("open file error");
			handle_mms_queue_end();
			return;
		}
		first = TRUE;
		data_length = MMS_MESSAGE_FIRSTGROUP_SIZE;
	}
	else 
	{
		first = FALSE;
		data_length = MMS_MESSAGE_GROUP_SIZE;
	}
	if(data_length > data->sizeTotal  - data->sizeUsed)
		data_length = data->sizeTotal  - data->sizeUsed;
	 
	MMS_new(buffer,data_length);

	ffs_read(data->fp, buffer,  data_length);
	data->sizeUsed += data_length;

	WAP_TRACE_EVENT(("%d, %d, %d",data_length,data->sizeUsed,data->sizeTotal));
	//WAP_TRACE_EVENT(("%02x %02x %02x %02x",buffer[0],buffer[1],buffer[2],buffer[3]));
	
	if( data->sizeUsed == data->sizeTotal)
	{
		moreData = FALSE;//FALSE
	}
	else
	{
		moreData = TRUE;  
	}


	if(first)
	{ 
		T_MMI_WAP_POSTCONTENT_IND parameter;
		parameter.moreData = moreData;
		parameter.urlID = data->urlID;
		parameter.addr_length= strlen(data->pubbuff.mmscaddr)+1;
		parameter.addr = (char *)data->pubbuff.mmscaddr;
		parameter.reload = TRUE;						//reload
		parameter.acceptHeader = (char *)acceptHeader;
		parameter.acceptHeader_length = strlen(acceptHeader )+1;
		parameter.data = buffer;
		parameter.data_length = data_length;
		parameter.contentType = (char *)ContentType;
		parameter.contentType_length = strlen(ContentType) + 1;
		parameter.sendMode = 3;//SENDMODE_BINARY;
		parameter.contentDisp = 0;
		parameter.contentDisp_length = 0;
		parameter.totalSize = data->sizeTotal;
  
		ATB_wap_content_post(&parameter);
	}
	else
	{
		T_MMI_WAP_POSTMORECONTENT_IND parameter;
		parameter.moreData = moreData;
		parameter.urlID = data->urlID;
		parameter.data = buffer;
		parameter.data_length = data_length;
		
		ATB_wap_morecontent_post(&parameter);
	}

	MMS_free(buffer, data_length);
}


/*************************************************
$Description:
	determine if mms queu is empty
****************************************************/
T_MMS_WAP_DATA*  mms_recvnew(char *filename, char *url)
{
	T_MMS_WAP_DATA* mmsrecv ;
	TRACE_FUNCTION("mms_recvnew:");
	TRACE_FUNCTION(filename);
	TRACE_FUNCTION(url);
	
	MMS_new(mmsrecv,sizeof(T_MMS_WAP_DATA));

	if(mmsrecv ==0)return 0;

	mmsrecv->status = MMS_WAP_NOSTATUS;
	
	mmsrecv->type = MMS_TYPE_RECV;
	mmsrecv->urlID = URLID_MMS_RECV;

	mmsrecv->fp = 0;
	
	{
		char *p = strrchr(filename,'/' );
		p ++;
		//memcpy(mmsrecv->filename,filename,strlen(filename) + 1);
		sprintf(mmsrecv->filename,"%s%s",MMS_DIR,p);
	}
	memcpy(mmsrecv->pubbuff.url , url, strlen(url) + 1);

	mmsrecv->next = 0;
	
	append_mmslist(mmsrecv);
	
	return mmsrecv;
}


void mms_recvdelete(T_MMS_WAP_DATA* data)
{
	TRACE_FUNCTION("mms_recvdelete");
	
	handle_mms_queue_end();
	
}


void handle_mmsrecv(T_MMS_WAP_DATA* data, T_WAP_MMI_CONTENT_REQ *parameter)
{


	TRACE_FUNCTION("handle_mmsrecv");
		
	if(data == 0)
	{
		if(mmslist_process == 0)
		{	
			TRACE_FUNCTION("handle_mmsrecv error--data is null");
			return;
		}	
		data = mmslist_process;
	}
	
	if(data->fp <=0 && parameter == 0)/*first*/
	{
		T_MMI_WAP_GETCONTENT_IND parameter2;
		data->sizeUsed = 0;
		data->sizeTotal = 0;
		
		data->fp    = ffs_open(data->filename, FFS_O_CREATE |FFS_O_WRONLY );
		if(data->fp    <=0 )
		{
			WAP_TRACE_EVENT(("open file error---%s", data->filename));
			handle_mms_queue_end();
			return;
		}

		parameter2.urlID = data->urlID;
		parameter2.reload = TRUE;
		parameter2.addr = data->pubbuff.url;
		parameter2.addr_length = strlen(parameter2.addr);
		parameter2.acceptHeader = (char *)acceptHeader;
		parameter2.acceptHeader_length = strlen(parameter2.acceptHeader);
		
		M_MMI_WAP_GETCONTENT_IND(&parameter2);
	}
	else  if(parameter)
	{
		if(parameter->data == NULL)
		{//error
			TRACE_EVENT("handle_mmsrecv error-no data");
			handle_mms_queue_end();
			return ;
		}
		if(data->sizeTotal ==0)
			data->sizeTotal = parameter->totalSize;
		data->sizeUsed += parameter->data_length;
		ffs_write(data->fp, parameter->data, parameter->data_length);
		WAP_TRACE_EVENT(("hyl,handle_mmsrecv %d Bytes", data->sizeUsed));
		if(parameter->moreData)
		{
			T_MMI_WAP_ACKCONTENT_IND parameter2;
			parameter2.urlID = data->urlID;
			M_MMI_WAP_ACKCONTENT_IND(&parameter2);
		}
		else
		{
			ffs_close(data->fp);
			data->fp = 0;
			TRACE_EVENT("handle_mmsrecv finished");
			//handle_mms_queue_end();
			//notify get complete
			return;
		}	
	}
	else
	{
		TRACE_FUNCTION("handle_mmsrecv error--parameter is null");
	}
	
}

/*****************************************
$Description:
	
*********************************************/
void handle_mms_queue_begin()
{
	TRACE_FUNCTION("handle_mms_queue_begin");
	if(mmslist_head == 0)
	{
		WAP_TRACE_EVENT(("Error, mmslist_head is null"));
		//MMS_WAP_Close();
		return;
	}
	if(mmslist_process !=0)/*process has begined,return*/
	{
		WAP_TRACE_EVENT(("Error, process has begined "));
		return;
	}
	mmslist_process = mmslist_head;
	switch(mmslist_head->type)
	{
	case MMS_TYPE_SEND:
		mmslist_process->status = MMS_WAP_SENDING;
		handle_mmssend(mmslist_process );
		break;
	case MMS_TYPE_RECV:
		mmslist_process->status = MMS_WAP_RECVING;
		handle_mmsrecv(mmslist_process , NULL);
		break;
	}
}

/*****************************************
$Description:
	
*********************************************/
void handle_mms_queue_end()
{
	TRACE_FUNCTION("handle_mms_queue_end");

	if(mmslist_process == 0)
	{
		TRACE_EVENT("handle_mms_queue_end-error");
		return;
	}
	
	remove_mmslist(mmslist_process);
	
	if(mmslist_process->fp >0)
	{
		ffs_close(mmslist_process->fp);
	}
	MMS_free(mmslist_process, sizeof(T_MMS_WAP_DATA) );

	mmslist_process = 0 ;
}

/*****************************************
$Description:
	
*********************************************/
void handle_mms_queue_err(SHORT errorCode)
{

	TRACE_FUNCTION("handle_mms_queue_err");


	switch(mmslist_process->urlID)
	{
	case URLID_MMS_RECV:
		strcpy(g_filename,get_mmslist_head(MMS_TYPE_RECV)->filename);
		handle_mms_queue_end();
		wap_mms_evt_cb(
					     NET_GET_CONTENT_IND,
					     MMI_MMS_FAILED, 
					     g_filename
					     );
		break;
	case URLID_MMS_SEND:
		handle_mms_queue_end();
		//here reprot a error to mms
		wap_mms_evt_cb(
					     NET_POST_CNF,
					     MMI_MMS_FAILED, 
					     NULL
					     );
		break;

	}

}


/*****************************************
$Description:
	encapsulate WAP_MMS_EVENT and call MMS_NET_EVENT_HANDLE
$Argument
	@type: MMS_WAP_EVENT_TYPE
	@status:MMI_MMS_EVENT_STATUS
	@filename
*********************************************/
void wap_mms_evt_cb(
			UBYTE    type, 
			UBYTE    status, 
			char *    filename 
			)
{
	pWAP_MMS_EVENT evt;
 

	TRACE_FUNCTION("wap_mms_evt_cb()");

 	/*initialize manager and codec*/
	MI_manager_on_initialize(MANAGER_MASK_MMSAGT);
	/*{
		extern T_MMS_NET_SETTINGS mmsSettings;
		manager_set_autorecv(mmsSettings.allSettings[mmsSettings.curSettingsIndex].recvSettings.stateAutoRecv);
	}*/
  	WAP_TRACE_EVENT(("type:%d, status:%d",type,status));
	WAP_DELAY(30);
	 
	MMS_new(evt, sizeof(WAP_MMS_EVENT));
	if(!evt)
	{
		TRACE_FUNCTION("memory alloc error");
		return;
	}
	
#if 0	
	MmsBusy = TRUE; 
#endif	
	evt->type = type;
	switch(type)
	{
	case NET_ERROR:
		TRACE_FUNCTION("NET_ERROR");
		
		MMS_NET_EVENT_HANDLE(evt);
		break;
		
	case NET_CONFIGURE_CNF:
		TRACE_EVENT("NET_CONFIGURE_CNF");
		MMS_new(evt->data.pconfiguredata, sizeof(CONFIGURE_CNF_DATA));
		evt->data.pconfiguredata->status = status;
		
		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.pconfiguredata, sizeof(CONFIGURE_CNF_DATA));
		break;
		
	case NET_CLOSE_CNF:
		TRACE_EVENT("NET_CLOSE_CNF");
		MMS_new(evt->data.pclosedata,sizeof(CLOSE_CNF_DATA));
		evt->data.pclosedata->status = status;
		
		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.pclosedata, sizeof(CLOSE_CNF_DATA));
#if 0
		RcvFromMenu = FALSE;
#endif
		break;
		
	case NET_CANCEL_CNF:
		TRACE_EVENT("NET_CANCEL_CNF");
		MMS_new(evt->data.pcanceldata,sizeof(CANCEL_CNF_DATA));
		evt->data.pcanceldata->status = status;
		
		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.pcanceldata, sizeof(CANCEL_CNF_DATA));
#if 0
		RcvFromMenu = FALSE;
#endif
		break;
		
	case NET_POST_CNF:
		TRACE_EVENT("NET_POST_CNF");
		
		MMS_new(evt->data.ppostdata,sizeof(POST_CNF_DATA));
		evt->data.ppostdata->status = status;
		evt->data.ppostdata->filename = filename;
		
		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.ppostdata, sizeof(POST_CNF_DATA));
		break;
		
	case NET_GET_CONTENT_IND:
		MMS_TRACE_EVENT(("NET_GET_CONTENT_IND,file: %s",filename));
		MMS_new(evt->data.pgetdata,sizeof(GET_CONTENT_IND_DATA));
		evt->data.pgetdata->status = status;
		evt->data.pgetdata->filename = filename;

		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.pgetdata,sizeof(GET_CONTENT_IND_DATA));

		break;
		
	case NET_PUSH_IND:
		TRACE_EVENT("NET_PUSH_IND");
#if 0
		if(mmspushlist_wait && mmspushlist_wait->type == MMS_PQ_TYPE_FILE&&isPushInRecvFolder(filename))
		{/*is in recv folder,ingore it*/
			WAP_TRACE_EVENT(("push file is in recv folder-%s",filename));
			//MMS_free(mmspushlist_wait );
			 //mmspushlist_wait = 0;
			 mmspushlist_wait->type == MMS_PQ_TYPE_DLVRYIND;
			 break;
		}
#endif
		MMS_new(evt->data.ppushdata,sizeof(PUSH_IND_DATA));
		evt->data.ppushdata->status = status;
		evt->data.ppushdata->filename= filename;
		evt->data.ppushdata->forcerecv = FORCERECV;
		
		MMS_NET_EVENT_HANDLE(evt);
		MMS_free(evt->data.ppushdata, sizeof(PUSH_IND_DATA));
		break;
		
	default:
		TRACE_FUNCTION("default");
		break;
	}

	MMS_free(evt, sizeof(WAP_MMS_EVENT));
	WAP_TRACE_EVENT(("end wap_mms_evt_cb"));
	WAP_DELAY(30);
}

/************************************
$Description:
	force recv mms for delag recv
*****************************************/
void MMS_Force_Recv(char* filename)
{
	FORCERECV = 1;
	wap_mms_evt_cb(NET_PUSH_IND,MMI_MMS_SUCCESS,filename);
	FORCERECV = 0;
}

/*****************************************
$Description:
	handle repuest from CLNTa_Content(send cnf and receive acknowledge)
	handle mms push message
	handle mms delivery ind
*********************************************/
void MMS_Content_REQ(
						UBYTE urlID,
						char *data,
						ULONG data_length,
						BOOL moreData,
						ULONG totalSize,
						SHORT errorNo)
{
	static BYTE wait_urlID = 0;
	static UBYTE MessageType = 0;
	static ULONG totalsize = 0;
	TRACE_FUNCTION("MMS_Content_REQ");
	
	if (!data)
	{
		TRACE_FUNCTION("Content REQ wap data error");
		//total_size = 0;
		return;
	}
	
	if(errorNo != 0)//a error occur
	/*4001,ERR_WTP_ErrorNORESPONSE*/
	{
		WAP_TRACE_EVENT(("MMS_Content_REQ-errorNo: %d",errorNo ));
		/*determine error type, assign to send or receive */