mainserv.c

这是一个linux下基于MiniGUI的手机界面设计源码

 
#ifndef _MAINSERV_C_
#define _MAINSERV_C_ 0
#include "../DataProcessing/MySHM.h"
#include "../DataProcessing/Wrapper.c"
#include "sysSrcInfo.h"
#include "MobileSystem.h"

char 	 buffer[10];
char 	 buffer1[210];

extern	 void  *SendDataGram( void *arg  );
extern  void ShowMessage (int mess);
void 	 ProcTerminate( COUNTERTYPE counterType, int value ); 
void 	 UnloadData( SOURCETYPE sType, MESGTYPE mesgType );


/* Check if the id of a thread is out of range */
void CheckTidCount( void )
{
	if( tidProcessing > MAXNTHREADS )
		tidProcessing = 0;
	else
		tidProcessing++;
}



int CompareLocTime( QueryFilter filter, LOCINFO **p  )
{
	if( p == NULL )
		err_sys("Error occurred-> Empty records in memory!");
	printf("Time is %d %d %d\n ",(*p)->dwxx.hour,(*p)->dwxx.minute,(*p)->dwxx.second);
	printf("Filter stime is %d %d %d\n",filter.sTime.hour,filter.sTime.min,filter.sTime.sec);
	printf("Filter etime is %d %d %d\n",filter.eTime.hour,filter.eTime.min,filter.eTime.sec);

	/* Compare the current record with given search condition */
	if( ( ((*p)->dwxx.hour >= filter.sTime.hour) && ((*p)->dwxx.hour <= filter.eTime.hour)) && (( (*p)->dwxx.minute >= filter.sTime.min) && ( (*p)->dwxx.minute <= filter.eTime.min) ) && ( ( (*p)->dwxx.second >= filter.sTime.sec) && ( (*p)->dwxx.second <= filter.eTime.sec) ))
		return 1;
	else
		return 0;

} 


int GetOverFlowBit( void )
{
	int result;
	
	Pthread_mutex_lock( &overflowBit_Mutex );
	result = overflowBit;
	Pthread_mutex_unlock( &overflowBit_Mutex );
	return result;	
	
}


void SetOverFlowBit( int value )
{
	Pthread_mutex_lock( &overflowBit_Mutex );
	overflowBit = value;
	ProcTerminate( OVERFLOWED, overflowBit );
	Pthread_mutex_unlock( &overflowBit_Mutex );
}


/* Return  the count of current New messages  */
int  GetCountNMesg( void )
{
	int counter = 0;
	
	Pthread_mutex_lock( &countNewMesg_Mutex );
	counter = countNewMesg;
	Pthread_mutex_unlock( &countNewMesg_Mutex );
	return counter;
}



/* Modify the count of current  New messages */
void AddCountNMesg( int increment )
{
	
	Pthread_mutex_lock( &countNewMesg_Mutex );
	countNewMesg += increment;
	Pthread_mutex_unlock( &countNewMesg_Mutex );
}



void ReduceCountNMesg( int decrement )
{
	
	Pthread_mutex_lock( &countNewMesg_Mutex );
	countNewMesg -= decrement;
	//if( countNewMesg < 0)
	//	countNewMesg = 0;
	Pthread_mutex_unlock( &countNewMesg_Mutex );
	

}
/* Reset the count of current  New messages */
void ReSetNMesg( int value )
{
	Pthread_mutex_lock( &countNewMesg_Mutex );
	countNewMesg = value;
	Pthread_mutex_unlock( &countNewMesg_Mutex );

}

/* Return  the count of current unread messages  */
int  GetCountUnRead( void )
{
	int counter = 0;
	
	Pthread_mutex_lock( &countUnRead_Mutex );
	counter = countOfUnread;
	Pthread_mutex_unlock( &countUnRead_Mutex );
	return counter;
}



/* Modify the count of current  unread messages */
void AddCountUnRead( int increment )
{
	
	Pthread_mutex_lock( &countUnRead_Mutex );
	countOfUnread += increment;
	ProcTerminate( UNREAD, countOfUnread );
	Pthread_mutex_unlock( &countUnRead_Mutex );

}


void ReduceCountUnRead( int decrement )
{
	
	Pthread_mutex_lock( &countUnRead_Mutex );
	countOfUnread -= decrement;
	printf("**********Enter ReduceCountUnRead( ) countOfUnread %d**********\n",countOfUnread);
	//if( countOfUnread < 0)
	//	countOfUnread = 0;
	ProcTerminate( UNREAD, countOfUnread );
	Pthread_mutex_unlock( &countUnRead_Mutex );
	

}

void ReCountUnRead( int value )
{
	Pthread_mutex_lock( &countUnRead_Mutex );
	countOfUnread = value;
	ProcTerminate( UNREAD, countOfUnread );
	Pthread_mutex_unlock( &countUnRead_Mutex );

}

void	 ReCountMain( SOURCETYPE sType, int value )
{
	if( sType == INBOX )
	{
		Pthread_mutex_lock( &countTXMAIN_Mutex );
		countTXMAIN = value;
		ProcTerminate( TX_MAIN, countTXMAIN );
		Pthread_mutex_unlock( &countTXMAIN_Mutex );
	
	}
	else if( sType == OUTBOX )
	{
		countTXMNOut = value;
		ProcTerminate( TX_MNOut, countTXMNOut );
	
	}
	

}

int	GetCountMain( SOURCETYPE sType )
{
	int counter;	
		
	if( sType == INBOX )
	{
		Pthread_mutex_lock( &countTXMAIN_Mutex );
		counter = countTXMAIN;
		Pthread_mutex_unlock( &countTXMAIN_Mutex );
	
	}
	else if( sType == OUTBOX )
	{
		counter = countTXMNOut;
	}
	return counter;
	
}

int  AddCountMain( SOURCETYPE sType, int increment )
{
	int counter;

	if( sType == INBOX )
	{
		Pthread_mutex_lock( &countTXMAIN_Mutex );
		counter = countTXMAIN = countTXMAIN + increment;
		ProcTerminate( TX_MAIN, countTXMAIN );
		Pthread_mutex_unlock( &countTXMAIN_Mutex );
	
	}
	else if( sType == OUTBOX )
	{
		counter = countTXMNOut = countTXMNOut + increment;
		ProcTerminate( TX_MNOut, countTXMNOut );
	}
	return counter;
}

int ReduceCountMain( SOURCETYPE sType, int increment )
{
	int counter;	

	if( sType == INBOX )
	{
		Pthread_mutex_lock( &countTXMAIN_Mutex );
		counter = countTXMAIN = countTXMAIN - increment;
		//if( countTXMAIN < 0)
		//	countTXMAIN = 0;
		ProcTerminate( TX_MAIN, countTXMAIN );
		Pthread_mutex_unlock( &countTXMAIN_Mutex );
	}
	else if( sType == OUTBOX )
	{
		counter = countTXMNOut = countTXMNOut - increment;
		//if( countTXMNOut < 0)
		//	countTXMNOut = 0;
		ProcTerminate( TX_MNOut, countTXMNOut );
	}	
	return counter;

}

/* Reset the count of current  different message */
void   ResetCount( SOURCETYPE sType, MESGTYPE mesgType, int value)
{
	
	switch( mesgType )
	{
	case	TYPE_OF_DWXX: 
		
		Pthread_mutex_lock( &countDW_Mutex );
		countDWXX = value;
		ProcTerminate( DW, countDWXX );
		Pthread_mutex_unlock( &countDW_Mutex );

		break;
	case	TYPE_OF_TXXX:

		if( sType == INBOX )
		{
			Pthread_mutex_lock( &countTXINDEX_Mutex );
			countTXINDEX = value;
			if( countTXINDEX < AUTOROLLVAL_TX )
				SetOverFlowBit( FALSE );
			ProcTerminate( TX_INDEX, countTXINDEX );
			Pthread_mutex_unlock( &countTXINDEX_Mutex );	
		}
		else if( sType == OUTBOX )
		{
			countTXIDXOut = value;
			ProcTerminate( TX_IDXOUT, countTXIDXOut );
		}
		
		break;
	case	TYPE_OF_ICXX:
		break;
	case	TYPE_OF_ZJXX:
		break;
	case	TYPE_OF_SJXX:
		break;
	case	TYPE_OF_BBXX:
		break;
	case	TYPE_OF_FKXX:

		Pthread_mutex_lock( &countFK_Mutex );
		countFKXX = value;
		ProcTerminate( FK, countFKXX );
		Pthread_mutex_unlock( &countFK_Mutex );
		break;
	}
	
}

/* Return  the count of current  different message in the file */
int  GetCount( SOURCETYPE sType, MESGTYPE mesgType)
{
	int counter = 0;
	
	switch( mesgType )
	{
	case	TYPE_OF_DWXX: 
		Pthread_mutex_lock( &countDW_Mutex );
		counter = countDWXX;
		Pthread_mutex_unlock( &countDW_Mutex );

		break;
	case	TYPE_OF_TXXX:
	
		if( sType == INBOX )
		{
			Pthread_mutex_lock( &countTXINDEX_Mutex );
			counter = countTXINDEX;
			Pthread_mutex_unlock( &countTXINDEX_Mutex );
		}
		else if( sType == OUTBOX )
		{
			counter = countTXIDXOut;
		}
		
		break;
	case	TYPE_OF_ICXX:
		break;
	case	TYPE_OF_ZJXX:
		break;
	case	TYPE_OF_SJXX:
		break;
	case	TYPE_OF_BBXX:
		break;
	case	TYPE_OF_FKXX:

		Pthread_mutex_lock( &countFK_Mutex );
		counter = countFKXX;
		
		Pthread_mutex_unlock( &countFK_Mutex );
		
		break;
	}
	return counter;
}



/* Modify the count of current  different message in the file */
void AddCount( SOURCETYPE sType, MESGTYPE mesgType,int increment)
{
	
	switch( mesgType )
	{
	case	TYPE_OF_DWXX: 

		Pthread_mutex_lock( &countDW_Mutex );
		countDWXX += increment;
		ProcTerminate( DW, countDWXX );
		Pthread_mutex_unlock( &countDW_Mutex );

		break;
	case	TYPE_OF_TXXX:
		
		if( sType == INBOX )
		{
			Pthread_mutex_lock( &countTXINDEX_Mutex );
			if( (countTXINDEX+increment) <= AUTOROLLVAL_TX)
			{
				countTXINDEX += increment;
				if( countTXINDEX == AUTOROLLVAL_TX)
					SetOverFlowBit( TRUE );
				ProcTerminate( TX_INDEX, countTXINDEX );
			}
			Pthread_mutex_unlock( &countTXINDEX_Mutex );
		}
		else if( sType == OUTBOX )
		{
			countTXIDXOut += increment;
			ProcTerminate( TX_IDXOUT, countTXIDXOut );
		}
		
		break;
	case	TYPE_OF_ICXX:
		break;
	case	TYPE_OF_ZJXX:
		break;
	case	TYPE_OF_SJXX:
		break;
	case	TYPE_OF_BBXX:
		break;
	case	TYPE_OF_FKXX:

		Pthread_mutex_lock( &countFK_Mutex );
		countFKXX += increment;
		ProcTerminate( FK, countFKXX );
		Pthread_mutex_unlock( &countFK_Mutex );
		break;
	}
	

}


void ReduceCount( SOURCETYPE sType, MESGTYPE mesgType,int decrement )
{
	
	switch( mesgType )
	{
	case	TYPE_OF_DWXX:
 
		Pthread_mutex_lock( &countDW_Mutex );
		countDWXX -= decrement;
		//if( countDWXX < 0)
		//	countDWXX = 0;
		ProcTerminate( DW, countDWXX );
		Pthread_mutex_unlock( &countDW_Mutex );

		break;
	case	TYPE_OF_TXXX:

		if( sType == INBOX )
		{
			Pthread_mutex_lock( &countTXINDEX_Mutex );
			countTXINDEX -= decrement;
			if( countTXINDEX < AUTOROLLVAL_TX )
				SetOverFlowBit( FALSE );
			//if( countTXINDEX < 0)
			//	countTXINDEX = 0;
			ProcTerminate( TX_INDEX, countTXINDEX );
			Pthread_mutex_unlock( &countTXINDEX_Mutex );
		}
		else if( sType == OUTBOX )
		{
			countTXIDXOut -= decrement;
			ProcTerminate( TX_IDXOUT, countTXIDXOut );
		}
		
		break;
	case	TYPE_OF_ICXX:
		break;
	case	TYPE_OF_ZJXX:
		break;
	case	TYPE_OF_SJXX:
		break;
	case	TYPE_OF_BBXX:
		break;
	case	TYPE_OF_FKXX:
		break;
	}
	

}




/* Load the information of DWXX and TXXX  */
void 	LoadData( SOURCETYPE sType, MESGTYPE mesgType, int mesgCount )
{
	int i;
	FILE *fp;
	LOCINFO **p;
	COMMINFO **q;
	struct stat buf; 
	printf("Enter LoadData now.\n");
	
	loadedMesg.countOfUnread = 0; 
	if( mesgCount == 0)
	{
		loadedMesg.countOfMesg = mesgCount;
		printf("NULL records in the file!\n");
		return;
		
	}
	else
		printf("%d records in the file!\n",mesgCount);

	
	
	switch( mesgType )
	{
	case	TYPE_OF_DWXX:
		
		UnloadData( INBOX, TYPE_OF_DWXX);
		
		Pthread_mutex_lock( &fLock.DW_FLOCK );
		Pthread_mutex_lock( &countDW_Mutex );
		MergeRecords( TYPE_OF_DWXX );
		/* Alloacate the memory of message array.*/
		if( mesgCount <= AUTOROLLVAL_DW )
		{
			loadedMesg.locInfo = (LOCINFO  *)malloc( LEN_LOCINFO * mesgCount);
			fp = Fopen( "DWXX.data","r+");
			rewind(fp);
			for( i=0; i<mesgCount; i++)
				/******Problem here,can't use the wrapper function Fread()*******/
     				if( fread( &( (loadedMesg.locInfo)[i].dwxx), LEN_DWXX, 1, fp) != 1)
     				{
       				if( feof(fp))
       					{
         					Fclose(fp);
         					break;
       					}
       				perror("File read error!");
     				}
				else
				{