/*****************************************************************************
* FUNCTION
* csb_frm_check_if_card_present
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
pBOOL csb_frm_check_if_card_present(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U32 drive;
S32 status;
pBOOL error_code = FALSE;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
drive = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
status = FS_GetDevStatus(drive, FS_MOUNT_STATE_ENUM);
if(status >= 0)
{
error_code = TRUE;
DisplayPopup((PU8) GetString(STR_GLOBAL_OK), IMG_GLOBAL_ERROR, 5, CSB_NOTIFY_DURATION, 0);
}
else
{
error_code = FALSE;
DisplayPopup((PU8) GetString(STR_ID_CSB_NO_MEMORY_CARD), IMG_GLOBAL_ERROR, 5, CSB_NOTIFY_DURATION, 0);
}
return error_code;
}
/*****************************************************************************
* FUNCTION
* jma_audio_recorder_set_record_location
* DESCRIPTION
* The function sets record location
* PARAMETERS
* mma_type [IN]
* java_recorder [IN]
* path [?]
* RETURNS
* int - 0
*****************************************************************************/
kal_bool jma_mvm_audio_recorder_set_record_location(kal_int32 vm_id, kal_int32 java_recorder, kal_char *path)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 file_handle;
kal_int32 result, length;
kal_wchar *ext_name;
kal_char *file_name;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_MVM_AUDIO_RECORDER_SET_RECORD_LOCATION, vm_id, java_recorder, audio_recorder[vm_id].state);
JMA_CS_ENTER(vm_id, KAL_FALSE);
if (audio_recorder[vm_id].id != java_recorder)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_RESOURCE_ERROR, audio_recorder[vm_id].id);
JMA_CS_LEAVE(KAL_FALSE);
}
mmi_ucs2ncpy((PS8) audio_recorder[vm_id].filename, (PS8) path, J2ME_PATH_BUFFER_SIZE);
length = mmi_ucs2strlen((S8*) audio_recorder[vm_id].filename);
if (length < 4)
{
JMA_CS_LEAVE(KAL_FALSE);
}
/* Drive name can not equal to SYSTEM DRIVE */
if ((int)audio_recorder[vm_id].filename[0] == SRV_FMGR_SYSTEM_DRV)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
/* assign format */
ext_name = &audio_recorder[vm_id].filename[length - 4];
if (kal_wstrcmp(ext_name, L".amr") == 0 || kal_wstrcmp(ext_name, L".AMR") == 0)
{
audio_recorder[vm_id].format = MED_TYPE_AMR;
}
else if (kal_wstrcmp(ext_name, L".wav") == 0 || kal_wstrcmp(ext_name, L".WAV") == 0)
{
audio_recorder[vm_id].format = MED_TYPE_WAV;
}
#if defined (AMRWB_ENCODE)
else if (kal_wstrcmp(ext_name, L".awb") == 0 || kal_wstrcmp(ext_name, L".AWB") == 0)
{
audio_recorder[vm_id].format = MED_TYPE_AMR_WB;
}
#endif
#if defined (__VORBIS_ENCODE__)
else if (kal_wstrcmp(ext_name, L".ogg") == 0 || kal_wstrcmp(ext_name, L".OGG") == 0)
{
audio_recorder[vm_id].format = MED_TYPE_VORBIS;
}
#endif
else
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, audio_recorder[vm_id].format);
/* Check if valid file path and delete the file */
result = FS_GetDevStatus(audio_recorder[vm_id].filename[0], FS_MOUNT_STATE_ENUM);
if (result == FS_NO_ERROR)
{
/* Check if valid file name */
file_name = kal_dchar_strrchr((S8*) audio_recorder[vm_id].filename, '\\');
if (file_name)
{
file_name += 2;
if (!srv_fmgr_path_is_filename_valid((const WCHAR*)file_name))
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
/* File name can not start with space: FS API restriction */
if (*file_name == ' ' && *(file_name + 1) == 0)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
}
else /* Do not contain '\\' */
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
/* Check if dir exist or if valid dir */
*((kal_int16*)file_name) = 0;
file_handle = FS_Open(audio_recorder[vm_id].filename, FS_OPEN_DIR | FS_READ_ONLY);
if (file_handle > 0)
{
FS_Close(file_handle);
}
else
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
JMA_CS_LEAVE(KAL_FALSE);
}
/* Copy again to repair audio_recorder.filename */
mmi_ucs2ncpy((PS8) audio_recorder[vm_id].filename, (PS8) path, J2ME_PATH_BUFFER_SIZE);
/* Check if file exist */
file_handle = FS_Open(audio_recorder[vm_id].filename, FS_READ_ONLY);
if (file_handle > 0)
{
result = FS_Close(file_handle); /* need to close file before delete */
result = FS_Delete(audio_recorder[vm_id].filename);
if (result != FS_NO_ERROR)
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, result);
JMA_CS_LEAVE(KAL_FALSE);
}
}
JMA_CS_LEAVE(KAL_TRUE);
}
else
{
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);
kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, result);
JMA_CS_LEAVE(KAL_FALSE);
}
}
void INT_GetMemDevInfo(MEM_DEV_INFO_T* Info)
{
#if defined(__MTK_TARGET__) && !defined(__SMART_PHONE_MODEM__) && !defined(__RAMDISK__)
WCHAR driveName;
#endif
memset(Info, 0, sizeof(MEM_DEV_INFO_T));
#if defined(__MTK_TARGET__) && !defined(__SMART_PHONE_MODEM__) && !defined(__RAMDISK__)
if (FS_GetDevStatus(FS_DEVICE_TYPE_NOR, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
Info->NORPresent = KAL_TRUE;
else
Info->NORPresent = KAL_FALSE;
if (FS_GetDevStatus(FS_DEVICE_TYPE_NAND, FS_MOUNT_STATE_ENUM) == FS_NO_ERROR)
Info->NANDPresent = KAL_TRUE;
else
Info->NANDPresent = KAL_FALSE;
EMI_QueryCurSetting(&(Info->EMIInfo));
if (Info->NANDPresent == KAL_TRUE)
{
driveName = GetFirstDriveNamebyDeviceType(FS_DEVICE_TYPE_NAND);
if (driveName != 0xFFFF)
{
FS_IOCtrl(&driveName, FS_IOCTRL_QUERY_NAND_INFO, &(Info->NANDDevInfo));
}
#if defined(__EMMC_BOOTING__)
Info->NANDConfInfo.FSBaseAddress = EMMC_BOOTING_CODE_PARTITION_SIZE;
Info->NANDConfInfo.FSTotalSize = 0;
Info->NANDConfInfo.FSFirstDriveSize = 0;
#elif defined(_NAND_FLASH_BOOTING_) || defined(__FS_SYSDRV_ON_NAND__) || (defined(__FOTA_DM__) && defined(__UP_PKG_ON_NAND__) && defined(NAND_SUPPORT))
Info->NANDConfInfo.FSBaseAddress = NAND_FLASH_BASE_ADDRESS;
Info->NANDConfInfo.FSTotalSize = NAND_ALLOCATED_FAT_SPACE;
Info->NANDConfInfo.FSFirstDriveSize = NAND_PARTITION_SECTORS;
#elif defined(NAND_SUPPORT) // NOR booting without (__FOTA_DM__ && __UP_PKG_ON_NAND__) but NAND_SUPPORT is enabled, the whole NAND flash is treated as a public drive.
Info->NANDConfInfo.FSBaseAddress = 0;
Info->NANDConfInfo.FSTotalSize = Info->NANDDevInfo.DeviceInfo.NAND.DeviceSize * 1024 * 1024; // translate to MB
Info->NANDConfInfo.FSFirstDriveSize = 0;
#endif /* _NAND_FLASH_BOOTING_ || __EMMC_BOOTING__ || __FS_SYSDRV_ON_NAND__ && (__FOTA_DM__ && __UP_PKG_ON_NAND__ && NAND_SUPPORT) */
#if defined(__NAND_FDM_50__)
Info->NANDFDMVer = 5;
#else
Info->NANDFDMVer = 4;
#endif /* __NOR_FDM5__ */
}
if (Info->NORPresent == KAL_TRUE)
{
driveName = GetFirstDriveNamebyDeviceType(FS_DEVICE_TYPE_NOR);
if (driveName != 0xFFFF)
{
FS_IOCtrl(&driveName, FS_IOCTRL_QUERY_NOR_INFO, &(Info->NORDevInfo));
}
#if !defined(_NAND_FLASH_BOOTING_) && !defined(__EMMC_BOOTING__) && !defined(__FS_SYSDRV_ON_NAND__)
Info->NORConfInfo.FSBaseAddress = NOR_FLASH_BASE_ADDRESS;
Info->NORConfInfo.FSTotalSize = NOR_ALLOCATED_FAT_SPACE;
Info->NORConfInfo.FSFirstDriveSize = NOR_PARTITION_SECTORS;
#endif /* !_NAND_FLASH_BOOTING_ && !__EMMC_BOOTING__ && !__FS_SYSDRV_ON_NAND__ */
#if defined(__NOR_FDM5__)
Info->NORFDMVer = 5;
#else
Info->NORFDMVer = 4;
#endif /* __NOR_FDM5__ */
}
#endif /* __MTK_TARGET__ && !__SMART_PHONE_MODEM__ */
}
/*
void mmi_gamesimu_exit_from_fmgr(void *filename, int is_short)
{
//DeleteUptoScrID(SCREENID_GAMESIMU_LIST);
DeleteNHistory(1);
GoBackHistory();
}
*/
void EntryRomList(void)
{
#if 0
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
S8 buf_filepath[FMGR_PATH_BUFFER_SIZE];
FS_HANDLE file_handle;
FMGR_FILTER filter;
S32 create_result;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
memset(buf_filepath,0x00,FMGR_PATH_BUFFER_SIZE);
pfnUnicodeStrcpy((S8 *)buf_filepath,(const S8 *)u8_g_game_dir);
#ifndef NAND_SUPPORT
if(fmgr_is_msdc_present() == FALSE)
{
DisplayPopup((PU8)GetString(STR_GLOBAL_NOTIFY_NO_MEMORY_CARD), IMG_GLOBAL_EMPTY,0, 1000, EMPTY_LIST_TONE);
return;
}
#endif
EntryNewScreen(SCREENID_GAMESIMU_LIST, NULL, EntryRomList, NULL);
create_result = mmi_gamesimu_create_file_dir(buf_filepath);
/* check if it is valid path */
file_handle = FS_Open((PU16) buf_filepath, FS_OPEN_DIR | FS_READ_ONLY);
if (file_handle >= 0)
{
FS_Close(file_handle);
FMGR_FILTER_INIT(&filter);
FMGR_FILTER_SET(&filter,FMGR_TYPE_NES);
mmi_fmgr_select_path_and_enter(
APP_GAME_SIMU,
FMGR_SELECT_BROWSE,
filter,
buf_filepath,
(PsExtFuncPtr) mmi_gamesimu_exit_from_fmgr);
/* check if device is busy or not */
if (FS_GetDevStatus(buf_filepath[0], FS_FEATURE_STATE_ENUM) == FS_DEVICE_BUSY)
{
/* mmi_fmgr_select_path_and_enter will also add screen to histry */
DeleteUptoScrID(SCREENID_GAMESIMU_LIST);
/* Delete up to previous screen */
DeleteNHistory(1);
}
}
else
{
{
/* storage is card */
/* photo's path is not exist, and card is write protected, cant create photo folder */
if (create_result == FS_WRITE_PROTECTION)
{
DisplayPopup(
(PU8) GetString(FMGR_FS_WRITE_PROTECTION_TEXT),
IMG_GLOBAL_WARNING,
1,
ST_NOTIFYDURATION,
WARNING_TONE);
}
else if (create_result == FS_DISK_FULL)
{
DisplayPopup(
(PU8) GetString(FMGR_FS_DISK_FULL_TEXT),
IMG_GLOBAL_WARNING,
1,
ST_NOTIFYDURATION,
WARNING_TONE);
}
else if (create_result == FS_ROOT_DIR_FULL)
{
DisplayPopup(
(PU8) GetString(FMGR_FS_ROOT_DIR_FULL_TEXT),
IMG_GLOBAL_WARNING,
1,
ST_NOTIFYDURATION,
WARNING_TONE);
}
else
{
DisplayPopup(
(PU8) GetString(STR_GLOBAL_NOTIFY_NO_MEMORY_CARD),
IMG_GLOBAL_WARNING,
1,
ST_NOTIFYDURATION,
WARNING_TONE);
}
DeleteUptoScrID(SCREENID_GAMESIMU);
return;
}
}
#endif
}
/*****************************************************************************
* FUNCTION
* jpush_alarm_del_file
* DESCRIPTION
* Delete one entry from the alarm registry only in file.
* If file can not be opened or the entry can not be found, return -1.
* PARAMETERS
* del_alarm [?]
* RETURNS
*
*****************************************************************************/
kal_int32 jpush_alarm_del_file(alarmentry_struct *del_alarm)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
alarmentry_struct *alarmp;
int pushfd;
kal_char tmp_buf[8] = {0};
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, JPUSH_ALARM_DEL_FILE);
#if defined(J2ME_SLIM_MEMORY_SUPPORT)
if (FS_GetDevStatus(SRV_FMGR_CARD_DRV, FS_MOUNT_STATE_ENUM) != FS_NO_ERROR)
{
return;
}
#endif
jpush_timer_mutex_lock();
if ((pushfd = jvm_file_open(_alarm_path, O_CREAT | O_TRUNC | FS_COMMITTED)) != -1)
{
/* Write a new list of push registrations to the persistent file */
for (alarmp = g_jpush_alarmlist_ptr; alarmp; alarmp = alarmp->next)
{
/* for fix the issue the two or more push timeout in a short time */
/* original : if (del_alarm != alarmp)*/
if (alarmp->event_id)
{
/* for fix the issue : the performace is low due to committed FS_write()*/
if(alarmp->executed)
{
jvm_file_write(pushfd, "1", 1);
}
else
{
jvm_file_write(pushfd, "0", 1);
}
jvm_file_write(pushfd, ",", 1);
jvm_file_write(pushfd, alarmp->midlet, strlen(alarmp->midlet));
jvm_file_write(pushfd, ",", 1);
tmp_buf[0] = (alarmp->wakeup & 0xff00000000000000) >> 56;
tmp_buf[1] = (alarmp->wakeup & 0x00ff000000000000) >> 48;
tmp_buf[2] = (alarmp->wakeup & 0x0000ff0000000000) >> 40;
tmp_buf[3] = (alarmp->wakeup & 0x000000ff00000000) >> 32;
tmp_buf[4] = (alarmp->wakeup & 0x00000000ff000000) >> 24;
tmp_buf[5] = (alarmp->wakeup & 0x0000000000ff0000) >> 16;
tmp_buf[6] = (alarmp->wakeup & 0x000000000000ff00) >> 8;
tmp_buf[7] = alarmp->wakeup & 0x00000000000000ff;
jvm_file_write(pushfd, tmp_buf, 8);
jvm_file_write(pushfd, ",", 1);
jvm_file_write(pushfd, alarmp->storagename, strlen(alarmp->storagename));
jvm_file_write(pushfd, ",", 1);
tmp_buf[0] = (alarmp->midletid& 0xff000000) >> 24;
tmp_buf[1] = (alarmp->midletid & 0x00ff0000) >> 16;
tmp_buf[2] = (alarmp->midletid & 0x0000ff00) >> 8;
tmp_buf[3] = alarmp->midletid & 0x000000ff;
jvm_file_write(pushfd, tmp_buf, 4);
jvm_file_write(pushfd, ",", 1);
tmp_buf[0] = alarmp->alarm_game_type & 0xff;
jvm_file_write(pushfd, tmp_buf, 1);
jvm_file_write(pushfd, "\n", 1);
}
}
jvm_file_close(pushfd);
jpush_timer_mutex_unlock();
return (0);
}
jpush_timer_mutex_unlock();
return (-1);
}
/*****************************************************************************
* FUNCTION
* jpush_alarm_open
* DESCRIPTION
* Open the Alram Registry file, if it exists and populate
* an in memory cache of the file contents.
* PARAMETERS
* alarm_path [?]
* RETURNS
* void
*****************************************************************************/
kal_int32 jpush_alarm_open(char *alarm_path)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_int32 pushfd;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
kal_trace(TRACE_FUNC, JPUSH_ALARM_OPEN);
#if defined(J2ME_SLIM_MEMORY_SUPPORT)
if (FS_GetDevStatus(SRV_FMGR_CARD_DRV, FS_MOUNT_STATE_ENUM) != FS_NO_ERROR)
{
return;
}
#endif
memcpy(_alarm_path, alarm_path, strlen(alarm_path) + 1);
#if !PERSISTENT_ALARMPUSH
/* Force to clean all timealarm after re-boot */
if ((pushfd = jvm_file_open((const char*)alarm_path, O_CREAT | O_TRUNC)) == -1)
{
return (-1);
}
else
{
jvm_file_close(pushfd);
return (0);
}
#else /* !PERSISTENT_ALARMPUSH */
/* Now read the registered connections. */
kal_trace(TRACE_FUNC, JPUSH_ALARM_OPEN_PERSISTENT);
if ((pushfd = jvm_file_open((const char*)alarm_path, O_RDONLY)) != -1)
{
kal_int32 ret;
/* Read through the file one line at a time */
if ((ret = jpush_alarm_parse(pushfd)) == -2)
{
return (-1);
}
/* Close the storage handle */
jvm_file_close(pushfd);
if (ret == -1)
{
return (-1);
}
return (-1);
}
else if ((pushfd = jvm_file_open((const char*)alarm_path, O_CREAT | O_RDWR)) == -1)
{
jvm_file_close(pushfd);
return (-1);
}
jvm_file_close(pushfd);
return (0);
#endif /* !PERSISTENT_ALARMPUSH */ /* !PERSISTENT_PUSH */
}
/*****************************************************************************
* FUNCTION
* jpush_alarm_add
* DESCRIPTION
* Add one entry to the alarm registry.
* If the entry already exists return previous alarm time.
* On succesful registration, write a new copy of the file to disk.
* PARAMETERS
* str [?]
* alarm [IN]
* lastalarm [?]
* RETURNS
*
*****************************************************************************/
int jpush_alarm_add(char *str, kal_int64 alarm, kal_int64 *lastalarm)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
alarmentry_struct *alarmp;
alarmentry_struct *lastp = g_jpush_alarmlist_ptr;
alarmentry_struct *pe = NULL;
kal_char *storage_name;
kal_char *midlet_name;
kal_int32 alarm_num = 0;
kal_uint32 alarm_period;
kal_int32 i;
kal_int32 storage_len, midlet_len;
kal_int32 midletid;
kal_char tmp_buf[16];
kal_char *tmp_str;
kal_int32 tmp_len = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
#ifdef __SUPPORT_JAVA_PUSH__
kal_trace(TRACE_FUNC, JPUSH_ALARM_ADD);
#if defined(J2ME_SLIM_MEMORY_SUPPORT)
if (FS_GetDevStatus(SRV_FMGR_CARD_DRV, FS_MOUNT_STATE_ENUM) != FS_NO_ERROR)
{
return;
}
#endif
jpush_timer_mutex_lock();
*lastalarm = 0;
storage_name = jpush_push_getstoragename(str, 2, &storage_len);
midlet_name = jpush_push_getstoragename(str, 0, &midlet_len);
tmp_str = jpush_push_getstoragename(str, 3, &tmp_len);
memcpy(tmp_buf, tmp_str, tmp_len);
tmp_buf[tmp_len] = 0;
sscanf(tmp_buf, "%d", &midletid);
/* Check if the entry already exists? */
for (alarmp = g_jpush_alarmlist_ptr; alarmp; alarmp = alarmp->next)
{
alarm_num++;
if (strncmp(midlet_name, alarmp->midlet, midlet_len) == 0 &&
strncmp(storage_name, alarmp->storagename, storage_len) == 0 &&
midletid == alarmp->midletid &&
alarmp->midlet[midlet_len] == 0 && alarmp->storagename[storage_len] == 0)
{
kal_int64 temp = alarmp->wakeup;
*lastalarm = alarmp->wakeup; // 20110321: Fix MIDP OTA TCK: PushRegistry WakeUp
kal_trace(TRACE_FUNC, JPUSH_ALARM_ADD_REGISTERED);
/* Cancel timer, Fix to check if valid event */
if (alarmp->event_id)
{
jpush_alarm_cancel(&alarmp->event_id);
}
for (i = 0; i < MAX_PUSH_REGISTRY; i++)
{
/* remove the push indication memorized by MMI */
if (g_mmi_java_push_cntx.push_entry_used[i])
{
if (strcmp(alarmp->storagename, g_mmi_java_push_cntx.push_entry[i].mids_storage_name) == 0 &&
alarmp->midletid == g_mmi_java_push_cntx.push_entry[i].mid_id &&
strcmp(alarmp->midlet, g_mmi_java_push_cntx.push_entry[i].mid_class_name) == 0)
{
jpush_search_and_delete_persistent_push(
0,
g_mmi_java_push_cntx.push_entry[i].pushalarm_type,
g_mmi_java_push_cntx.push_entry[i].mid_class_name,
g_mmi_java_push_cntx.push_entry[i].mid_id,
g_mmi_java_push_cntx.push_entry[i].mids_storage_name,
NULL,
NULL,
NULL,
NULL,
KAL_TRUE);
g_mmi_java_push_cntx.push_entry_used[i] = KAL_FALSE;
g_mmi_java_push_cntx.push_entry[i].mids_storage_name = NULL;
}
}
}
alarmp->event_id = NULL;
if (alarm == 0)
{
/* Remove an entry. */
if (alarmp == g_jpush_alarmlist_ptr)
{
g_jpush_alarmlist_ptr = alarmp->next;
}
else
{
lastp->next = alarmp->next;
}
alarmp->next = NULL;
free_ctrl_buffer(alarmp->midlet);
alarmp->midlet = NULL;
free_ctrl_buffer(alarmp->storagename);
alarmp->storagename = NULL;
free_ctrl_buffer(alarmp);
jpush_alarm_save();
}
else
{
/* Replace an entry. */
alarmp->wakeup = alarm;
alarmp->executed = 0;
if (alarm >= CurrentTime_md())
{
alarm_period = j2me_ms_2_tick(alarm - CurrentTime_md());
alarmp->event_id = jpush_alarm_set(alarmp, alarm_period);
jpush_alarm_save();
}
else
{
j2me_alarm_timeout_handler(alarmp);
}
}
///*lastalarm = temp; // 20110321: Reomved for MIDP OTA TCK: PushRegistry WakeUp
jpush_timer_mutex_unlock();
return 0;
}
lastp = alarmp;
}
g_timealarm_count = alarm_num;
kal_trace(TRACE_FUNC, JPUSH_ALARM_ADD_NEW,(g_timealarm_count));
/* Add a new entry. */
if (alarm &&
alarm_num + g_push_length < MAX_PUSH_REGISTRY &&
((pe = (alarmentry_struct*) get_ctrl_buffer(sizeof(alarmentry_struct))) != NULL))
{
pe->next = g_jpush_alarmlist_ptr;
pe->wakeup = alarm;
pe->executed = 0;
pe->midlet = jvm_str_dup(midlet_name, midlet_len);
pe->storagename = jvm_str_dup(storage_name, storage_len);
pe->midletid = midletid;
pe->alarm_game_type = 0;
if ((pe->midlet == NULL) || (pe->midletid <= 0) || (pe->storagename == NULL))
{
free_ctrl_buffer(pe->midlet);
pe->midlet = NULL;
free_ctrl_buffer(pe->storagename);
pe->storagename = NULL;
free_ctrl_buffer(pe);
pe = NULL;
}
else
{
g_jpush_alarmlist_ptr = pe;
/* Set timer */
if(alarm > CurrentTime_md())
{
alarm_period = j2me_ms_2_tick(alarm - CurrentTime_md());
pe->event_id = jpush_alarm_set(pe, alarm_period);
}
else
{
j2me_alarm_timeout_handler(pe);
}
}
}
if (pe == NULL)
{
jpush_timer_mutex_unlock();
return (-2);
}
jpush_timer_mutex_unlock();
jpush_alarm_save();
#endif
return (0);
}