/**
* Platform dependent implementation of startVibrate
*
* @note start vibrate is not implemented, as planned.
* @return KNI_FALSE: if this device does not support vibrate
*/
jboolean anc_start_vibrate()
{
REPORT_CALL_TRACE1(LC_CORE, "LF:STUB:anc_start_vibrate(%d)\n", dur);
/* Not yet implemented */
return KNI_FALSE;
}
/**
* Obtain the color that will be final shown
* on the screen after the system processed it.
*/
extern jint gxpport_get_displaycolor(jint color) {
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:gxpport_get_displaycolor(%d)\n",
color);
return color; /* No change */
}
/**
* Turn on or off the full screen mode
*
* @param mode true for full screen mode
* false for normal
*/
void lfjport_set_fullscreen_mode(jboolean mode) {
REPORT_CALL_TRACE1(LC_HIGHUI, "LF:STUB:lfjport_ui_setFullScreenMode(%1)\n",
mode);
(void)mode;
return;
}
jboolean anc_play_sound(AncSoundType soundType)
{
REPORT_CALL_TRACE1(LC_HIGHUI, "LF:STUB:anc_play_sound(%d)\n", soundType);
/* Suppress unused parameter warning */
(void)soundType;
// Not yet implemented
return KNI_FALSE;
}
/**
* Platform dependent implementation of startVibrate
*
* @note start vibrate is not implemented, as planned.
* @parameter dur duration of the vibrate period in
* microseconds
* @return KNI_FALSE: if this device does not support vibrate
*/
jboolean anc_start_vibrate(int dur)
{
REPORT_CALL_TRACE1(LC_CORE, "LF:STUB:anc_start_vibrate(%d)\n", dur);
/* Suppress unused parameter warning */
(void)dur;
/* Not yet implemented */
return KNI_FALSE;
}
/**
* Return the system key corresponding to the given key
* code.
*
* @param keyCode key code value
* IMPL_NOTE:move to share platform
*/
int
keymap_get_system_key(int keyCode)
{
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:keymap_get_system_key(%d)\n", keyCode);
switch (keyCode) {
case KEYMAP_KEY_POWER: return 1;
case KEYMAP_KEY_SEND: return 2;
case KEYMAP_KEY_END: return 3;
case KEYMAP_KEY_CLEAR:
case KEYMAP_KEY_BACKSPACE: return 4;
default: return 0;
}
}
/**
* Return the abstract game action corresponding to the
* given key code.
*
* @param keyCode key code value
* IMPL_NOTE:move to share platform
*/
int
keymap_get_game_action(int keyCode)
{
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:keymap_get_game_action(%d)\n", keyCode);
switch (keyCode) {
case KEYMAP_KEY_UP:
return 1; /* Canvas.UP */
case KEYMAP_KEY_DOWN:
return 6; /* Canvas.DOWN */
case KEYMAP_KEY_LEFT:
return 2; /* Canvas.LEFT */
case KEYMAP_KEY_RIGHT:
return 5; /* Canvas.RIGHT */
case KEYMAP_KEY_SELECT:
return 8; /* Canvas.FIRE */
case KEYMAP_KEY_GAMEA:
case KEYMAP_KEY_1:
return 9; /* Canvas.GAME_A */
case KEYMAP_KEY_GAMEB:
case KEYMAP_KEY_3:
return 10; /* Canvas.GAME_B */
case KEYMAP_KEY_GAMEC:
case KEYMAP_KEY_7:
return 11; /* Canvas.GAME_C */
case KEYMAP_KEY_GAMED:
case KEYMAP_KEY_9:
return 12; /* Canvas.GAME_D */
default:
if(keymap_is_invalid_key_code(keyCode)) {
/* Invalid key code */
return -1;
}
/* No game action available for this key */
return 0;
}
}
/**
* Return whether the keycode given is correct for
* this platform.
*
* @param keyCode key code value
*/
jboolean
keymap_is_invalid_key_code(int keyCode)
{
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:keymap_is_invalid_key_code(%d)\n", keyCode);
/*
* Valid within UNICODE and not 0x0 and 0xffff
* since they are defined to be invalid
*/
if ((keyCode <= 0x0) || (keyCode >= 0xFFFF) ) {
return KNI_TRUE;
}
return KNI_FALSE;
}
/**
* Return the key string to the given key code.
*
* @param keyCode key code value
*
* @return C pointer to char or NULL if the keyCode does not
* correspond to any name.
* IMPL_NOTE:move to share platform and change to loop through table Keys[]
*/
char *
keymap_get_key_name(int keyCode)
{
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:keymap_get_key_name(%d)\n", keyCode);
switch (keyCode) {
case KEYMAP_KEY_POWER: return Keys[0].name;
case KEYMAP_KEY_SEND: return Keys[8].name;
case KEYMAP_KEY_END: return Keys[9].name;
case KEYMAP_KEY_CLEAR: return Keys[10].name;
case KEYMAP_KEY_SOFT1: return Keys[1].name;
case KEYMAP_KEY_SOFT2: return Keys[2].name;
case KEYMAP_KEY_UP: return Keys[3].name;
case KEYMAP_KEY_DOWN: return Keys[4].name;
case KEYMAP_KEY_LEFT: return Keys[5].name;
case KEYMAP_KEY_RIGHT: return Keys[6].name;
case KEYMAP_KEY_SELECT: return Keys[7].name;
case KEYMAP_KEY_1: return Keys[11].name;
case KEYMAP_KEY_2: return Keys[12].name;
case KEYMAP_KEY_3: return Keys[13].name;
case KEYMAP_KEY_4: return Keys[14].name;
case KEYMAP_KEY_5: return Keys[15].name;
case KEYMAP_KEY_6: return Keys[16].name;
case KEYMAP_KEY_7: return Keys[17].name;
case KEYMAP_KEY_8: return Keys[18].name;
case KEYMAP_KEY_9: return Keys[19].name;
case KEYMAP_KEY_0: return Keys[21].name;
case KEYMAP_KEY_ASTERISK: return Keys[20].name;
case KEYMAP_KEY_POUND: return Keys[22].name;
case KEYMAP_KEY_GAMEA: return Keys[23].name;
case KEYMAP_KEY_GAMEB: return Keys[24].name;
case KEYMAP_KEY_GAMEC: return Keys[25].name;
case KEYMAP_KEY_GAMED: return Keys[26].name;
case KEYMAP_KEY_SPACE: return Keys[27].name;
}
return 0;
}
/**
* Return the key code corresponding to the given abstract
* game action.
*
* @param gameAction game action value
* IMPL_NOTE:move to share platform
*/
int
keymap_get_key_code(int gameAction)
{
REPORT_CALL_TRACE1(LC_LOWUI, "LF:STUB:keymap_get_key_code(%d)\n", gameAction);
switch (gameAction) {
case 1: /* Canvas.UP */
return KEYMAP_KEY_UP;
case 6: /* Canvas.DOWN */
return KEYMAP_KEY_DOWN;
case 2: /* Canvas.LEFT */
return KEYMAP_KEY_LEFT;
case 5: /* Canvas.RIGHT */
return KEYMAP_KEY_RIGHT;
case 8: /* Canvas.FIRE */
return KEYMAP_KEY_SELECT;
case 9: /* Canvas.GAME_A */
return KEYMAP_KEY_GAMEA;
case 10: /* Canvas.GAME_B */
return KEYMAP_KEY_GAMEB;
case 11: /* Canvas.GAME_C */
return KEYMAP_KEY_GAMEC;
case 12: /* Canvas.GAME_D */
return KEYMAP_KEY_GAMED;
default: return 0;
}
}
/*
* This function is called by the VM periodically. It has to check if
* system has sent a signal to MIDP and return the result in the
* structs given.
*
* Values for the <timeout> paramater:
* >0 = Block until a signal sent to MIDP, or until <timeout> milliseconds
* has elapsed.
* 0 = Check the system for a signal but do not block. Return to the
* caller immediately regardless of the if a signal was sent.
* -1 = Do not timeout. Block until a signal is sent to MIDP.
*/
void checkForSystemSignal(MidpReentryData* pNewSignal,
MidpEvent* pNewMidpEvent,
jlong timeout) {
midp_jc_event_union *event;
static unsigned char binaryBuffer[BINARY_BUFFER_MAX_LEN];
javacall_bool res;
int outEventLen;
res = (javacall_bool)javacall_event_receive ((long)timeout, binaryBuffer, BINARY_BUFFER_MAX_LEN, &outEventLen);
if (!JAVACALL_SUCCEEDED(res)) {
return;
}
event = (midp_jc_event_union *) binaryBuffer;
switch (event->eventType) {
case MIDP_JC_EVENT_KEY:
pNewSignal->waitingFor = UI_SIGNAL;
pNewMidpEvent->type = MIDP_KEY_EVENT;
pNewMidpEvent->CHR = event->data.keyEvent.key;
pNewMidpEvent->ACTION = event->data.keyEvent.keyEventType;
break;
case MIDP_JC_EVENT_PEN:
pNewSignal->waitingFor = UI_SIGNAL;
pNewMidpEvent->type = MIDP_PEN_EVENT;
pNewMidpEvent->ACTION = event->data.penEvent.type;
pNewMidpEvent->X_POS = event->data.penEvent.x;
pNewMidpEvent->Y_POS = event->data.penEvent.y;
break;
case MIDP_JC_EVENT_SOCKET:
pNewSignal->waitingFor = (midpSignalType)event->data.socketEvent.waitingFor;
pNewSignal->descriptor = (int)event->data.socketEvent.handle;
pNewSignal->status = event->data.socketEvent.status;
pNewSignal->pResult = (void *) event->data.socketEvent.extraData;
break;
case MIDP_JC_EVENT_END:
pNewSignal->waitingFor = AMS_SIGNAL;
pNewMidpEvent->type = SHUTDOWN_EVENT;
break;
case MIDP_JC_EVENT_PAUSE:
pNewSignal->waitingFor = AMS_SIGNAL;
pNewMidpEvent->type = PAUSE_ALL_EVENT;
break;
case MIDP_JC_EVENT_RESUME:
pNewSignal->waitingFor = AMS_SIGNAL;
pNewMidpEvent->type = ACTIVATE_ALL_EVENT;
break;
case MIDP_JC_EVENT_PUSH:
pNewSignal->waitingFor = PUSH_ALARM_SIGNAL;
pNewSignal->descriptor = event->data.pushEvent.alarmHandle;
break;
case MIDP_JC_EVENT_ROTATION:
pNewSignal->waitingFor = UI_SIGNAL;
pNewMidpEvent->type = ROTATION_EVENT;
break;
#ifdef ENABLE_JSR_75
case JSR75_FC_JC_EVENT_ROOTCHANGED:
notifyDisksChanged();
break;
#endif
#if ENABLE_JSR_120
case MIDP_JC_EVENT_SMS_INCOMING:
pNewSignal->waitingFor = WMA_SMS_READ_SIGNAL;
pNewSignal->descriptor = event->data.smsIncomingEvent.stub;
break;
case MIDP_JC_EVENT_CBS_INCOMING:
pNewSignal->waitingFor = WMA_CBS_READ_SIGNAL;
pNewSignal->descriptor = event->data.cbsIncomingEvent.stub;
break;
case MIDP_JC_EVENT_SMS_SENDING_RESULT:
pNewSignal->waitingFor = WMA_SMS_WRITE_SIGNAL;
break;
#endif
#if ENABLE_JSR_205
case MIDP_JC_EVENT_MMS_INCOMING:
pNewSignal->waitingFor = WMA_MMS_READ_SIGNAL;
pNewSignal->descriptor = event->data.mmsIncomingEvent.stub;
break;
case MIDP_JC_EVENT_MMS_SENDING_RESULT:
pNewSignal->waitingFor = WMA_MMS_WRITE_SIGNAL;
break;
#endif
case MIDP_JC_EVENT_MULTIMEDIA:
#if ENABLE_JSR_135
if( JAVACALL_EVENT_MEDIA_SNAPSHOT_FINISHED == event->data.multimediaEvent.mediaType ) {
pNewSignal->waitingFor = MEDIA_SNAPSHOT_SIGNAL;
pNewSignal->descriptor = (((event->data.multimediaEvent.isolateId & 0xFFFF) << 16)
| (event->data.multimediaEvent.playerId & 0xFFFF));
REPORT_CALL_TRACE1(LC_NONE, "[media event] JAVACALL_EVENT_MEDIA_SNAPSHOT_FINISHED %d\n",
pNewSignal->descriptor);
} else {
pNewSignal->waitingFor = MEDIA_EVENT_SIGNAL;
}
pNewSignal->status = JAVACALL_OK;
pNewMidpEvent->type = MMAPI_EVENT;
pNewMidpEvent->MM_PLAYER_ID = event->data.multimediaEvent.playerId;
pNewMidpEvent->MM_DATA = event->data.multimediaEvent.data;
pNewMidpEvent->MM_ISOLATE = event->data.multimediaEvent.isolateId;
pNewMidpEvent->MM_EVT_TYPE = event->data.multimediaEvent.mediaType;
/* VOLUME_CHANGED event must be sent to all players. */
/* MM_ISOLATE = -1 causes bradcast by StoreMIDPEventInVmThread() */
if( JAVACALL_EVENT_MEDIA_VOLUME_CHANGED == event->data.multimediaEvent.mediaType )
pNewMidpEvent->MM_ISOLATE = -1;
REPORT_CALL_TRACE4(LC_NONE, "[media event] External event recevied %d %d %d %d\n",
pNewMidpEvent->type,
event->data.multimediaEvent.isolateId,
pNewMidpEvent->MM_PLAYER_ID,
pNewMidpEvent->MM_DATA);
#endif
break;
#ifdef ENABLE_JSR_234
case MIDP_JC_EVENT_ADVANCED_MULTIMEDIA:
pNewSignal->waitingFor = MEDIA_EVENT_SIGNAL;
pNewSignal->status = JAVACALL_OK;
pNewMidpEvent->type = AMMS_EVENT;
pNewMidpEvent->MM_PLAYER_ID = event->data.multimediaEvent.playerId;
pNewMidpEvent->MM_DATA = event->data.multimediaEvent.data;
pNewMidpEvent->MM_ISOLATE = event->data.multimediaEvent.isolateId;
pNewMidpEvent->MM_EVT_TYPE = event->data.multimediaEvent.mediaType;
REPORT_CALL_TRACE4(LC_NONE, "[jsr234 event] External event recevied %d %d %d %d\n",
pNewMidpEvent->type,
event->data.multimediaEvent.isolateId,
pNewMidpEvent->MM_PLAYER_ID,
pNewMidpEvent->MM_DATA);
break;
#endif
#ifdef ENABLE_JSR_179
case JSR179_LOCATION_JC_EVENT:
pNewSignal->waitingFor = JSR179_LOCATION_SIGNAL;
pNewSignal->descriptor = event->data.jsr179LocationEvent.provider;
pNewSignal->status = event->data.jsr179LocationEvent.operation_result;
REPORT_CALL_TRACE1(LC_NONE, "[jsr179 event] JSR179_LOCATION_SIGNAL %d %d\n", pNewSignal->descriptor, pNewSignal->status);
break;
#endif
#ifdef ENABLE_JSR_177
case MIDP_JC_EVENT_CARDDEVICE:
switch (event->data.carddeviceEvent.eventType) {
case MIDP_CARDDEVICE_RESET:
pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
pNewSignal->descriptor = SIGNAL_RESET;
pNewSignal->status = SIGNAL_RESET;
pNewSignal->pResult = (void *)event->data.carddeviceEvent.handle;
break;
case MIDP_CARDDEVICE_XFER:
pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
pNewSignal->descriptor = SIGNAL_XFER;
pNewSignal->status = SIGNAL_XFER;
pNewSignal->pResult = (void *)event->data.carddeviceEvent.handle;
break;
case MIDP_CARDDEVICE_UNLOCK:
pNewSignal->waitingFor = CARD_READER_DATA_SIGNAL;
pNewSignal->descriptor = SIGNAL_LOCK;
pNewSignal->status = SIGNAL_LOCK;
pNewSignal->pResult = NULL;
break;
default: /* just ignore invalid event type */
REPORT_ERROR1(LC_CORE,"Invalid carddevice event type: %d\n",
event->data.carddeviceEvent.eventType);
break;
}
break;
#endif /* ENABLE_JSR_177 */
#if ENABLE_MULTIPLE_ISOLATES
case MIDP_JC_EVENT_SWITCH_FOREGROUND:
pNewSignal->waitingFor = AMS_SIGNAL;
pNewMidpEvent->type = SELECT_FOREGROUND_EVENT;
pNewMidpEvent->intParam1 = 1;
break;
case MIDP_JC_EVENT_SELECT_APP:
pNewSignal->waitingFor = AMS_SIGNAL;
pNewMidpEvent->type = SELECT_FOREGROUND_EVENT;
pNewMidpEvent->intParam1 = 0;
break;
#endif /* ENABLE_MULTIPLE_ISOLATES */
default:
//REPORT_ERROR(LC_CORE,"Unknown event.\n");
break;
};
//REPORT_CALL_TRACE(LC_HIGHUI, "LF:STUB:checkForSystemSignal()\n");
}
