midp_slavemode_javacall.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 729 行 · 第 1/2 页

/*
 *
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

#include <jvmconfig.h>
#include <kni.h>
#include <jvm.h>
#include <jvmspi.h>
#include <sni.h>

#include <midpEventUtil.h>
#include <push_server_export.h>
#include <midp_thread.h>
#include <midp_run_vm.h>

#include <midp_logging.h>
#include <midp_slavemode_port.h>

#include <javacall_lifecycle.h>
#include <javautil_string.h>
#include <midp_jc_event_defs.h>

#include <midpServices.h>
#include <midpEvents.h>
#include <midpAMS.h>  /* for midpFinalize() */

#include <javacall_socket.h>
#include <pcsl_network.h>

#include <suspend_resume.h>

#include <javacall_lifecycle.h>
#include <jcapp_export.h>

#ifdef ENABLE_JSR_120
#include <wmaInterface.h>
#endif

#if ENABLE_JSR_135
#include <javanotify_multimedia.h>
#include <KNICommon.h>
#endif /* ENABLE_JSR_135 */

#ifdef ENABLE_JSR_234
#include <javanotify_multimedia_advanced.h>
#endif /*ENABLE_JSR_234*/

#ifdef ENABLE_JSR_75
#include <fcNotifyIsolates.h>
#endif

#ifdef ENABLE_JSR_177
#include <carddevice.h>
#endif

extern void measureStack(int clearStack);
extern jlong midp_slavemode_time_slice(void);

static jlong midpTimeSlice(void);

/**
 * Free the event result. Called when no waiting Java thread was found to
 * receive the result. This may be empty on some systems.
 *
 * @param waitingFor what signal the result is for
 * @param pResult the result set by checkForSystemSignal
 */
void midpFreeEventResult(int waitingFor, void* pResult) {
    (void)waitingFor;
    (void)pResult;
}

/**
 * Unblock a Java thread.
 *
 * @param blocked_threads blocked threads
 * @param blocked_threads_count number of blocked threads
 * @param waitingFor signal type
 * @param descriptor platform specific handle
 * @param status error code produced by the operation that unblocked the thread
 *
 * @return <tt>1</tt> if a thread was unblocked, otherwise <tt>0</tt>.
 */
static int
eventUnblockJavaThread(
        JVMSPI_BlockedThreadInfo *blocked_threads,
        int blocked_threads_count, unsigned int waitingFor,
        int descriptor, int status)
{
    /*
     * IMPL NOTE: this functionality is similar to midp_thread_signal_list.
     * It differs in that it reports to the caller whether a thread was
     * unblocked. This is a poor interface and should be removed. However,
     * the coupling with Push needs to be resolved first. In addition,
     * freeing of pResult here seems unsafe. Management of pResult needs
     * to be revisited.
     */
    int i;
    MidpReentryData* pThreadReentryData;

    for (i = 0; i < blocked_threads_count; i++) {
        pThreadReentryData =
            (MidpReentryData*)(blocked_threads[i].reentry_data);

        if (pThreadReentryData == NULL) {
            continue;
        }

        if (pThreadReentryData != NULL
                && pThreadReentryData->descriptor == descriptor
             && pThreadReentryData->waitingFor == (midpSignalType)waitingFor) {
            pThreadReentryData->status = status;
            midp_thread_unblock(blocked_threads[i].thread_id);
            return 1;
        }
        if (waitingFor == NO_SIGNAL
            && pThreadReentryData->descriptor == descriptor) {
            pThreadReentryData->status = status;
            /**
            * mark this thread as unblocked so that it will not be unblocked
            * again without being blocked first.
            */
            pThreadReentryData->waitingFor = -1;
            REPORT_INFO(LC_CORE, "eventUnblockJavaThread without signal!\n");
            midp_thread_unblock(blocked_threads[i].thread_id);
            return 1;
        }
    }

    return 0;
}

/*
 * This function is called by the VM periodically. Checks if
 * the native platform has sent a signal to MIDP.
 *
 * @param pNewSignal (out) Structure that will store the signal info
 * @param pNewMidpEvent (out) Structure that will store the midp event info
 * @param blocked_threads (in) Blocked threads
 * @param blocked_threads_count (in) Number of blocked threads
 * @param timeout Wait timeout
 *
 * @return <tt>JAVACALL_OK</tt> if an event successfully received,
 *         <tt>JAVACALL_FAIL</tt> or if failed or no messages are avaialable
 */
javacall_result checkForSystemSignal(MidpReentryData* pNewSignal,
                          MidpEvent* pNewMidpEvent,
                          JVMSPI_BlockedThreadInfo* blocked_threads,
                          int blocked_threads_count,
                          jlong timeout) {

    midp_jc_event_union *event;
    static unsigned char binaryBuffer[BINARY_BUFFER_MAX_LEN];
    javacall_bool res;
    int outEventLen;
    long timeTowaitInMillisec;
     /* convert jlong to long */
    if (timeout > 0x7FFFFFFF) {
        timeTowaitInMillisec = -1;
    } else if (timeout < 0) {
    	 timeTowaitInMillisec = -1;
    }	else {
        timeTowaitInMillisec = (long)(timeout&0x7FFFFFFF);
    }

    res = javacall_event_receive ((long)timeTowaitInMillisec, binaryBuffer, BINARY_BUFFER_MAX_LEN, &outEventLen);

    if (!JAVACALL_SUCCEEDED(res)) {
        return res;
    }

    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 = 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_NETWORK:
        pNewSignal->waitingFor = NETWORK_STATUS_SIGNAL;
        pNewSignal->descriptor = 0;
        pNewSignal->status = (int)event->data.networkEvent.netType;
        break;
    case MIDP_JC_EVENT_END:
        pNewSignal->waitingFor = AMS_SIGNAL;
        pNewMidpEvent->type    = SHUTDOWN_EVENT;
        break;
     case MIDP_JC_EVENT_PAUSE:
        /*
         * IMPL_NOTE: if VM is running, the following call will send
         * PAUSE_ALL_EVENT message to AMS; otherwise, the resources
         * will be suspended in the context of the caller.
         */
        midp_suspend();
        break;
    case MIDP_JC_EVENT_RESUME:
        midp_resume();
        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;
    case MIDP_JC_EVENT_DISPLAY_DEVICE_STATE_CHANGED:
        pNewSignal->waitingFor = DISPLAY_DEVICE_SIGNAL;
        pNewMidpEvent->type    = DISPLAY_DEVICE_STATE_CHANGED_EVENT;
        pNewMidpEvent->intParam1 = event->data.displayDeviceEvent.hardwareId;
        pNewMidpEvent->intParam2 = event->data.displayDeviceEvent.state;
        break;
	case MIDP_JC_EVENT_CLAMSHELL_STATE_CHANGED:
        pNewSignal->waitingFor = DISPLAY_DEVICE_SIGNAL;
        pNewMidpEvent->type    = DISPLAY_CLAMSHELL_STATE_CHANGED_EVENT;
        pNewMidpEvent->intParam1 = event->data.clamshellEvent.state;
        break;
    case MIDP_JC_EVENT_CHANGE_LOCALE:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = CHANGE_LOCALE_EVENT;
        break;
    case MIDP_JC_EVENT_VIRTUAL_KEYBOARD:
        pNewSignal->waitingFor = UI_SIGNAL;
        pNewMidpEvent->type    = VIRTUAL_KEYBOARD_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;
        pNewSignal->descriptor = (int)event->data.smsSendingResultEvent.handle;
        pNewSignal->status = event->data.smsSendingResultEvent.result;
        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;
        pNewSignal->descriptor = (int)event->data.mmsSendingResultEvent.handle;
        pNewSignal->status = event->data.mmsSendingResultEvent.result;
        break;
#endif

    case MIDP_JC_EVENT_MULTIMEDIA:
#if ENABLE_JSR_135
        pNewSignal->waitingFor = MEDIA_EVENT_SIGNAL;
        pNewSignal->status     = event->data.multimediaEvent.status;
        pNewSignal->pResult    = (void *)event->data.multimediaEvent.data.num32;
        
        /* Create Java driven event */
        if (event->data.multimediaEvent.mediaType > 0 &&
                event->data.multimediaEvent.mediaType <
                        JAVACALL_EVENT_MEDIA_JAVA_EVENTS_MARKER) {
            pNewMidpEvent->type         = MMAPI_EVENT;
            pNewMidpEvent->MM_PLAYER_ID = event->data.multimediaEvent.playerId;
            pNewMidpEvent->MM_DATA      = event->data.multimediaEvent.data.num32;
            pNewMidpEvent->MM_ISOLATE   = event->data.multimediaEvent.appId;
            pNewMidpEvent->MM_EVT_TYPE  = event->data.multimediaEvent.mediaType;
            pNewMidpEvent->MM_EVT_STATUS= event->data.multimediaEvent.status;
    
            /* VOLUME_CHANGED event must be sent to all players.             */
            /* MM_ISOLATE = -1 causes broadcast by StoreMIDPEventInVmThread() */
            if(JAVACALL_EVENT_MEDIA_VOLUME_CHANGED == 
                    event->data.multimediaEvent.mediaType) {
                pNewMidpEvent->MM_ISOLATE = -1;
            }
        }
        
        /* This event should simply unblock waiting thread. No Java event is needed */
        if (event->data.multimediaEvent.mediaType > 
                                    JAVACALL_EVENT_MEDIA_JAVA_EVENTS_MARKER) {
            pNewSignal->descriptor =
                MAKE_PLAYER_DESCRIPTOR(event->data.multimediaEvent.appId,
                                       event->data.multimediaEvent.playerId,
                                       event->data.multimediaEvent.mediaType);
                
        /* In case of error or end-of-media unblock all awaiting threads */
        } else if (event->data.multimediaEvent.mediaType == 
                            JAVACALL_EVENT_MEDIA_END_OF_MEDIA ||
                   event->data.multimediaEvent.mediaType == 
                            JAVACALL_EVENT_MEDIA_RECORD_ERROR ||
                   event->data.multimediaEvent.mediaType == 
                            JAVACALL_EVENT_MEDIA_ERROR) {
            pNewSignal->descriptor =
                (MAKE_PLAYER_DESCRIPTOR(event->data.multimediaEvent.appId,
                                       event->data.multimediaEvent.playerId,
                                       0) & PLAYER_DESCRIPTOR_EVENT_MASK);
        } else {
            pNewSignal->descriptor = 0;
        }
        REPORT_CALL_TRACE4(LC_NONE, "[media event] External event received "
                "%d %d %d %d\n",
                pNewMidpEvent->type,
                event->data.multimediaEvent.appId,
                event->data.multimediaEvent.playerId,
                event->data.multimediaEvent.data.num32);
#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_ISOLATE   = event->data.multimediaEvent.appId;
        pNewMidpEvent->MM_EVT_TYPE  = event->data.multimediaEvent.mediaType;

        switch( event->data.multimediaEvent.mediaType )
        {
        case JAVACALL_EVENT_AMMS_SNAP_SHOOTING_STOPPED:
        case JAVACALL_EVENT_AMMS_SNAP_STORAGE_ERROR: