runtime_md.c

java 1.1 gemini 08_16

*
* DESCRIPTION
* Get the system time in ms since 1970
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/ 
kal_uint64
CurrentTime_md(void)
{
	return CurrentTIME + TICK_2_MS(jvm_get_currenttime_tick());
}

void
J2ME_PauseScreenTime_md(void)
{
	/* get current system ticks */
	saved_pausescreentime_ticks = jvm_get_currenttime_tick();
}

void
J2ME_ResumeScreenTime_md(void)
{
	kal_uint32 current_time_ticks;

	/* get current system ticks */
	current_time_ticks = jvm_get_currenttime_tick();
	CurrentTIME -= TICK_2_MS(current_time_ticks-saved_pausescreentime_ticks);
	saved_pausescreentime_ticks = 0;
}

/*************************************************************************
* FUNCTION
*  Calendar_md
*
* DESCRIPTION
* Get the system time in ms since 1970
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/ 
unsigned long *
Calendar_md(void)
{
	jvm_get_calendar_time(date);
	return (unsigned long*)date;
}

/*************************************************************************
* FUNCTION
*  nativeFinalization
*
* DESCRIPTION
* Called at start up to perform machine-specific finalization.
*
* PARAMETERS
*
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/ 
void InitializeNativeCode() 
{
	InitializeSystemTime();
}

void FinalizeNativeCode() 
{ 

}

void
jvm_vendor_init()
{
	/* initilize jam functions */
	jam_adp_call_back_init(&jam_call_back_functions);
	
	/* Configure IJET VM property */
	Default_IMPL_PROPERTY_FILE = g_jvm_resource_info.default_imp_property;
	Default_APPL_PROPERTY_FILE = g_jvm_resource_info.default_app_property;

	set_jvm_heap_size(javaheap_size);

	/* Initialize runtime memory management */
	jvm_mem_config(midpMallocImpl, midpFreeImpl);

	jam_comm_register_io_ind_handler(COMM_ReadInd_Handler, COMM_WriteInd_Handler);

    InitializeNativeCode();

#ifdef APPMEM_SUPPORT
	javaruntime_space = (long*)midslist_mem_pool;
	midpInitializeMemory(javaruntime_space, MIDSLIST_MEM_POOL_SIZE);
	javaheap_space = NULL;
#else
	midpInitializeMemory(javaruntime_space, javaruntime_size);
#endif /* APPMEM_SUPPORT */

}

/*************************************************************************
* FUNCTION
*	Process Event Handlers
*
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool
jvm_vendor_process_event(ilm_struct* ilm_ptr)
{
	return KAL_FALSE;
}

kal_bool 
jdaemon_vendor_process_event(ilm_struct* ilm_ptr)
{
	return KAL_FALSE;
}

#ifdef M3D_DEBUG
	#if !defined(__MTK_TARGET__) || defined(__M3D_WINUT__)
int debug_fp;

typedef struct mem_node_t {
	kal_uint8* ptr;
	kal_uint32 size;
	char *file;
	kal_uint32 line;
	struct mem_node_t* next_p;
} mem_node;

mem_node headp = {0};
mem_node *currentp = &headp;

void _add_node(kal_uint8* ptr, kal_uint32 size, char *file, kal_uint32 line)
{
	mem_node *new_node = (mem_node*)malloc(sizeof(mem_node));
	new_node->ptr = ptr;
	new_node->size = size;
	new_node->line = line;
	new_node->file = (char*)malloc(sizeof(char)*strlen(file)+1);
	memcpy(new_node->file, file, strlen(file)+1);
	new_node->file[strlen(file)] = '\0';
	new_node->next_p = NULL;
	currentp->next_p = new_node;
	currentp = new_node;
}

void _search_and_delete(kal_uint8* ptr, kal_uint32 size)
{
	mem_node *cur_p = &headp;
	while (cur_p->next_p) {
		if (cur_p->next_p->ptr == ptr && cur_p->next_p->size == size) {
			mem_node *tmp_p = cur_p->next_p;
			if (cur_p->next_p==currentp)
				currentp = cur_p;
			cur_p->next_p = cur_p->next_p->next_p;
			free(tmp_p->file);
			free(tmp_p);
			return;
		} else {
			cur_p = cur_p->next_p;
		}
	}
}

void _traverse_and_print(void)
{
	FILE *fp = fopen("m3d_debug.txt", "wt");
	mem_node *cur_p = headp.next_p;
	while (cur_p) {
		fprintf(fp, "%#8X: %d %s %d\n", cur_p->ptr, cur_p->size, cur_p->file, cur_p->line );
		cur_p = cur_p->next_p;
	}
	fclose(fp);
}
	#else
FILE *debug_fp = NULL;	
	#endif /* Maui */
		
kal_uint32 _m3d_mem_allocated = 0;

void* 
_m3d_dbg_malloc(kal_uint32 size, char *file, kal_uint32 line)
{
	void* ptr = NULL;
#if !defined(__MTK_TARGET__) || defined(__M3D_WINUT__)
	ptr = malloc(size);
	_m3d_mem_allocated += _msize(ptr);
	_add_node(ptr, _msize(ptr), file, line);
#else
	ptr = midpMalloc(size); 
	sprintf(_kvmLogStr, "%>> %s %d alloc %d %0x\n", filename, lineno, size, ptr);
	Kwrite(debug_fp, _kvmLogStr, strlen(_kvmLogStr));
#endif /* Maui */

	return ptr;
}

void 
_m3d_free(void* ptr, char *file, kal_uint32 line)
{
#if !defined(__MTK_TARGET__) || defined(__M3D_WINUT__)
	_m3d_mem_allocated -= _msize(ptr);
	_search_and_delete(ptr, _msize(ptr));
	free(ptr);
#else
	sprintf(_kvmLogStr, "-- %s %d free %0x\n", filename, lineno, ptr);
	Kwrite(debug_fp, _kvmLogStr, strlen(_kvmLogStr));
	midpFree(ptr);
#endif /* Maui */
}
#else
void* 
_m3d_malloc(kal_uint32 size)
{
	void* ptr = NULL;

	if (size>512*1024) {
		kal_print("too huge memory allocation\n");
		return NULL;
	}

#if !defined(__MTK_TARGET__) || defined(__M3D_WINUT__)
	ptr = malloc(size);
#else
	ptr = midpMalloc(size); 
#endif /* Maui */
	return ptr;
}

void 
_m3d_free(void* ptr)
{
#if !defined(__MTK_TARGET__) || defined(__M3D_WINUT__)
	free(ptr);
#else
	midpFree(ptr);
#endif /* Maui */
}
#endif /* M3D_DEUG */

extern kal_uint32 m3d_object_index;

kal_int32
jm3g_initialize() 
{
	kal_int32 result = 0;
	
#ifdef SUPPORT_JSR_184	
	#ifdef M3D_SUPPORT
		/* MMI must finalize M3D before Java initialize */
		ASSERT(m3d_graphics3d.cur_app != M3D_APP_MMI);
		/* guarantee we can succeed to initialize, because jm3g_register_graphics3d() will be 
		 * called before jm3g_initialize() */	
		if (m3d_graphics3d.cur_app == M3D_APP_JAVA) _m3d_deregister(M3D_APP_JAVA);

		#ifdef M3G_DEBUG
	result =  M3D_Initialize(M3D_APP_JAVA, _m3d_dbg_malloc, _m3d_dbg_free);	
		#else
	result =  M3D_Initialize(M3D_APP_JAVA, _m3d_malloc, _m3d_free);
		#endif /* M3G_DEBUG */	
	#else
		#ifdef M3G_DEBUG
	result =  M3G_Initialize(M3G_APP_JAVA, _m3g_dbg_malloc, _m3g_dbg_free);	
		#else
	result =  M3G_Initialize(M3G_APP_JAVA, _m3g_malloc, _m3g_free);
		#endif /* M3G_DEBUG */
	#endif /* M3D_SUPPORT */
#endif 	

	return result;
}

kal_int32
jm3g_finalize() 
{
#ifdef SUPPORT_JSR_184		
	/* guarantee we can succeed to finalize */
	if (m3d_graphics3d.cur_app == M3D_APP_NONE) _m3d_register(M3D_APP_JAVA, _m3d_malloc, _m3d_free);

	#ifdef M3D_SUPPORT
	M3D_Finalize(M3D_APP_JAVA);	
	#else
	M3G_Finalize();
	#endif /* M3D_SUPPORT */
#endif 
	return 0;
}

kal_int32
jm3g_register_graphics3d()
{
#ifdef SUPPORT_JSR_184			
        /* To support 3D Wallpaper + Java pause/resume */
	#ifdef M3D_SUPPORT
	if (jm3d_mutex) kal_take_mutex(jm3d_mutex);	

	_m3d_register(M3D_APP_JAVA, _m3d_malloc, _m3d_free);		
	if (m3d_graphics3d.context != EGL_NO_CONTEXT) _gl_dcm_load_and_restore();

	if (jm3d_mutex) kal_give_mutex(jm3d_mutex);	
	#else
	if (jm3g_mutex) kal_take_mutex(jm3g_mutex);	
	if (m3g_graphics3d.context != EGL_NO_CONTEXT) _gl_dcm_load_and_restore();
	if (jm3g_mutex) kal_give_mutex(jm3g_mutex);
	#endif /* M3D_SUPPORT */
#endif /* SUPPORT_JSR_184 */		
		
	return KAL_TRUE;
}

kal_int32
jm3g_unregister_graphics3d()
{	
#ifdef SUPPORT_JSR_184		
	#ifdef M3D_SUPPORT
	if (jm3d_mutex) kal_take_mutex(jm3d_mutex);		
	
	if (m3d_graphics3d.context != EGL_NO_CONTEXT) _gl_dcm_backup_and_release();
	_m3d_deregister(M3D_APP_JAVA);
		
	if (jm3d_mutex) kal_give_mutex(jm3d_mutex);		
	#else
	if (jm3g_mutex) kal_take_mutex(jm3g_mutex);		
	if (m3g_graphics3d.context != EGL_NO_CONTEXT) _gl_dcm_backup_and_release();
	if (jm3g_mutex) kal_give_mutex(jm3g_mutex);	
	#endif /* M3D_SUPPORT */
#endif /* SUPPORT_JSR_184 */	
	
	return KAL_TRUE;
}