/** * Creates a server connection object. * * Note: the method sets native connection handle directly to * <code>handle<code> field of <code>L2CAPNotifierImpl</code> object. * * @param imtu receive MTU or <code>-1</code> if not specified * @param omtu transmit MTU or <code>-1</code> if not specified * @param auth <code>true</code> if authication is required * @param authz <code>true</code> if authorization is required * @param enc <code>true</code> indicates * what connection must be encrypted * @param master <code>true</code> if client requires to be * a connection's master * @return reserved PSM to listen for incoming connections on * @throws IOException if any I/O error occurs */ KNIEXPORT KNI_RETURNTYPE_INT Java_com_sun_midp_io_j2me_btl2cap_L2CAPNotifierImpl_create0(void) { int imtu = (int)KNI_GetParameterAsInt(1); int omtu = (int)KNI_GetParameterAsInt(2); javacall_bool auth = (KNI_GetParameterAsBoolean(3) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_bool authz = (KNI_GetParameterAsBoolean(4) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_bool enc = (KNI_GetParameterAsBoolean(5) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_bool master = (KNI_GetParameterAsBoolean(6) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_handle handle = BT_INVALID_HANDLE; int psm = BT_L2CAP_INVALID_PSM; REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::create"); // Need revisit: add resource counting /* if (midpCheckResourceLimit(RSC_TYPE_BT_SER, 1) == 0) { const char* pMsg = "Resource limit exceeded for BT server sockets"; REPORT_INFO(LC_PROTOCOL, pMsg); KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg)); } else { */ /* create L2CAP server connection */ if (javacall_bt_l2cap_create_server(imtu, omtu, auth, authz, enc, master, &handle, &psm) == JAVACALL_FAIL) { REPORT_ERROR(LC_PROTOCOL, "L2CAP notifier creation failed in btl2cap_notif::create"); KNI_ThrowNew(midpIOException, EXCEPTION_MSG("Can not create L2CAP notifier ")); KNI_ReturnInt(BT_L2CAP_INVALID_PSM); } KNI_StartHandles(1); KNI_DeclareHandle(thisHandle); KNI_GetThisPointer(thisHandle); /* store native connection handle to Java object */ KNI_SetIntField(thisHandle, notifHandleID, (jint)handle); // Need revisit: add resource counting /* if (midpIncResourceCount(RSC_TYPE_BT_SER, 1) == 0) { REPORT_INFO(LC_PROTOCOL, "BT Server: Resource limit update error"); } */ // } REPORT_INFO2(LC_PROTOCOL, "btl2cap_notif::create notifier created" ", port = %d, handle = %d\n", psm, handle); KNI_EndHandles(); KNI_ReturnInt(psm); }
/** * Creates a server connection object. * * Note: the method sets native connection handle directly to * <code>handle<code> field of <code>BTSPPNotifierImpl</code> object. * * @param auth <code>true</code> if authication is required * @param authz <code>true</code> if authorization is required * @param enc <code>true</code> indicates * what connection must be encrypted * @param master <code>true</code> if client requires to be * a connection's master * @return selected channel number to listen for incoming connections on * @throws IOException if any I/O error occurs */ KNIEXPORT KNI_RETURNTYPE_INT Java_com_sun_midp_io_j2me_btspp_BTSPPNotifierImpl_create0(void) { bt_bool_t auth = (KNI_GetParameterAsBoolean(1) == KNI_TRUE) ? BT_BOOL_TRUE : BT_BOOL_FALSE; bt_bool_t authz = (KNI_GetParameterAsBoolean(2) == KNI_TRUE) ? BT_BOOL_TRUE : BT_BOOL_FALSE; bt_bool_t enc = (KNI_GetParameterAsBoolean(3) == KNI_TRUE) ? BT_BOOL_TRUE : BT_BOOL_FALSE; bt_bool_t master = (KNI_GetParameterAsBoolean(4) == KNI_TRUE) ? BT_BOOL_TRUE : BT_BOOL_FALSE; bt_handle_t handle = BT_INVALID_HANDLE; int cn = BT_RFCOMM_INVALID_CN; REPORT_INFO(LC_PROTOCOL, "btspp_notif::create0"); // IMPL_NOTE: add resource counting /* if (midpCheckResourceLimit(RSC_TYPE_BT_SER, 1) == 0) { const char* pMsg = "Resource limit exceeded for BT server sockets"; REPORT_INFO(LC_PROTOCOL, pMsg); KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg)); } else { */ /* create RFCOMM server connection */ if (bt_rfcomm_create_server(auth, authz, enc, master, &handle, &cn) == BT_RESULT_FAILURE) { REPORT_ERROR(LC_PROTOCOL, "RFCOMM notifier creation failed in btspp_notif::create"); KNI_ThrowNew(midpIOException, EXCEPTION_MSG("Can not create RFCOMM notifier")); KNI_ReturnInt(BT_RFCOMM_INVALID_CN); } KNI_StartHandles(1); KNI_DeclareHandle(thisHandle); KNI_GetThisPointer(thisHandle); /* store native connection handle to Java object */ KNI_SetIntField(thisHandle, notifHandleID, (jint)handle); // IMPL_NOTE: add resource counting /* if (midpIncResourceCount(RSC_TYPE_BT_SER, 1) == 0) { REPORT_INFO(LC_PROTOCOL, "BT Server: Resource limit update error"); } */ // } REPORT_INFO2(LC_PROTOCOL, "btspp_notif::create notifier created" ", port = %d, handle = %d\n", cn, handle); KNI_EndHandles(); KNI_ReturnInt(cn); }
/* protected native int nSetMute ( int mediaType , boolean mute ) ; */ KNIEXPORT KNI_RETURNTYPE_BOOLEAN KNIDECL(com_sun_mmedia_DirectVolume_nSetMute) { jint handle = KNI_GetParameterAsInt(1); jboolean mute = KNI_GetParameterAsBoolean(2); jboolean returnValue = KNI_FALSE; javacall_result ret = JAVACALL_FAIL; javacall_bool setMuted; KNIPlayerInfo* pKniInfo = (KNIPlayerInfo*)handle; MMP_DEBUG_STR1("[kni_volume] +nSetMute %d\n", mute); if (pKniInfo && pKniInfo->pNativeHandle) { setMuted = (mute == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; ret = javacall_media_set_mute(pKniInfo->pNativeHandle, setMuted); } else { MMP_DEBUG_STR("[nSetMute] Invalid native handle"); } if (ret == JAVACALL_OK) { returnValue = (setMuted == JAVACALL_TRUE) ? KNI_TRUE : KNI_FALSE; } KNI_ReturnBoolean(returnValue); }
/** * Initializes the native peer of this <tt>Font</tt>. * <p> * Java declaration: * <pre> * init(III)V * </pre> * * @param face The face of the font to initialize * @param style The style of the font to initialize * @param size The point size of the font to initialize */ KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(javax_microedition_lcdui_Font_init) { jboolean free_size = KNI_GetParameterAsBoolean(4); int size = (int)KNI_GetParameterAsInt(3); int style = (int)KNI_GetParameterAsInt(2); int face = (int)KNI_GetParameterAsInt(1); int ascent, descent, leading; KNI_StartHandles(1); KNI_DeclareHandle(thisObject); if (free_size == KNI_FALSE) { /* size is one of the SIZE_XXX constants */ size = OEM_FONT_SIZE(size); } KNI_GetParameterAsObject(0, thisObject); gx_get_fontinfo(face, style, size, &ascent, &descent, &leading); SNI_BEGIN_RAW_POINTERS; GET_FONT_PTR(thisObject)->baseline = (jint)ascent; GET_FONT_PTR(thisObject)->height = (jint)(ascent + descent + leading); GET_FONT_PTR(thisObject)->size = (jint)size; GET_FONT_PTR(thisObject)->sizeRounded = (jint) LCDUI_FONT_SIZE(size); SNI_END_RAW_POINTERS; KNI_EndHandles(); KNI_ReturnVoid(); }
KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(javax_microedition_lcdui_TextFieldLFImpl_enableNativeEditor) { int x = KNI_GetParameterAsInt(1); int y = KNI_GetParameterAsInt(2); int w = KNI_GetParameterAsInt(3); int h = KNI_GetParameterAsInt(4); jboolean multiline = KNI_GetParameterAsBoolean(5); if (multiline) { hwndTextActive = hwndTextBox; } else { hwndTextActive = hwndTextField; } editCHX = x; editCHY = y; editCHW = w; editCHH = h; if (!JWC_WINCE_SMARTPHONE) { int diff = (rcVisibleDesktop.right - rcVisibleDesktop.left) - CHAM_WIDTH; if (diff > 0) { x += diff / 2; } } editBoxShown = 1; SetWindowPos(hwndTextActive, HWND_TOP, x, y, w, h, SWP_SHOWWINDOW); SetFocus(hwndTextActive); KNI_ReturnVoid(); }
KNIEXPORT KNI_RETURNTYPE_VOID Java_com_sun_midp_jsr82emul_DeviceEmul_inquiryCompleted() { jboolean success = (int)KNI_GetParameterAsBoolean(1); LOG("DeviceEmul_inquiryCompleteted()"); javanotify_bt_inquiry_complete(success ? JAVACALL_TRUE : JAVACALL_FALSE); KNI_ReturnVoid(); }
KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(com_sun_midp_main_IndicatorManager_toggleHomeIcon0) { jboolean isHomeOn = KNI_GetParameterAsBoolean(1); anc_toggle_home_icon(isHomeOn); KNI_ReturnVoid(); }
/** * Creates a copy of a region of the specified <tt>ImageData</tt> and * stores the copied image in passed in immutable <tt>ImageData</tt> object. * <p> * Java declaration: * <pre> * createImmutableImageDataRegion(Ljavax/microedition/lcdui/ImageData;Ljavax/microedition/lcdui/ImageData;IIIII)V * </pre> * * @param dest The <tt>ImageData</tt> to copy to * @param source The <tt>ImageData</tt> to copy * @param x The x coordinate of the upper left corner of the * region to copy * @param y The y coordinate of the upper left corner of the * region to copy * @param width The width of the region to copy * @param height The height of the region to copy * @param transform The transform to apply to the selected region. * @param isMutable <tt>true</tt> if <tt>img</tt> is mutable, otherwise * <tt>false</tt> */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_lcdui_ImageDataFactory_createImmutableImageDataRegion() { jboolean ismutable = KNI_GetParameterAsBoolean(8); int transform = KNI_GetParameterAsInt(7); int height = KNI_GetParameterAsInt(6); int width = KNI_GetParameterAsInt(5); int y = KNI_GetParameterAsInt(4); int x = KNI_GetParameterAsInt(3); img_native_error_codes creationError = IMG_NATIVE_IMAGE_NO_ERROR; /* pointer to native image structure */ gxpport_image_native_handle srcImagePtr; gxpport_image_native_handle newImagePtr; KNI_StartHandles(2); KNI_DeclareHandle(srcImg); KNI_DeclareHandle(destImg); KNI_GetParameterAsObject(2, srcImg); KNI_GetParameterAsObject(1, destImg); /* get src image's midpNative data */ srcImagePtr = gxp_get_imagedata(srcImg); if (KNI_FALSE == ismutable) { /* immutable image */ gxpport_createimmutable_from_immutableregion(srcImagePtr, x, y, width, height, transform, &newImagePtr, &creationError); } else { /* mutable image */ gxpport_createimmutable_from_mutableregion(srcImagePtr, x, y, width, height, transform, &newImagePtr, &creationError); } if (IMG_NATIVE_IMAGE_OUT_OF_MEMORY_ERROR == creationError) { KNI_ThrowNew(midpOutOfMemoryError, NULL); } else if (IMG_NATIVE_IMAGE_RESOURCE_LIMIT == creationError) { KNI_ThrowNew(midpOutOfMemoryError, "Resource limit exceeded for immutable image"); } else if (IMG_NATIVE_IMAGE_NO_ERROR != creationError) { KNI_ThrowNew(midpIllegalArgumentException, NULL); } else { IMGAPI_GET_IMAGEDATA_PTR(destImg)->nativeImageData = (jint)newImagePtr; } KNI_EndHandles(); KNI_ReturnVoid(); }
/** * IMPL_NOTE:(Deoxy - Consider using internal) * * FUNCTION: drawTrustedIcon(II)V * CLASS: javax.microedition.lcdui.Display * TYPE: virtual native function * OVERVIEW: set the drawing of the trusted MIDlet icon * INTERFACE (operand stack manipulation): * parameters: displayId The display ID associated with the caller Display * drawTrusted * returns: <nothing> */ KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(javax_microedition_lcdui_Display_drawTrustedIcon0) { jboolean drawTrusted = KNI_GetParameterAsBoolean(2); jint displayId = KNI_GetParameterAsInt(1); if (midpHasForeground(displayId)) { /* Call platform dependent implementation */ anc_show_trusted_indicator(drawTrusted); } KNI_ReturnVoid(); }
/** * Garbage collect any zombie Images to free up their resources. * <p> * Java declaration: * <pre> * garbageCollectImages(Z)V * </pre> * * @param doFullGC boolean indicating whether to do a full GC or not */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_lcdui_ImageDataFactory_garbageCollectImages() { jboolean doFullGC = KNI_GetParameterAsBoolean(1); if (doFullGC == KNI_TRUE) { JVM_GarbageCollect(0, 0); } else { JVM_GarbageCollect(JVM_COLLECT_YOUNG_SPACE_ONLY, 0); } KNI_ReturnVoid(); }
/** * Garbage collect any zombie Objects to free up their resources. * <p> * Java declaration: * <pre> * garbageCollect(Z)V * </pre> * * @param fullGC boolean indicating whether to do a full GC or not */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_khronos_egl_EGL10Impl__1garbageCollect() { jboolean doFullGC = KNI_GetParameterAsBoolean(1); if (doFullGC == KNI_TRUE) { JVM_GarbageCollect(0, 0); } else { JVM_GarbageCollect(JVM_COLLECT_YOUNG_SPACE_ONLY, 0); } KNI_ReturnVoid(); }
/** * FUNCTION: setSuppressKeyEvents(Ljavax/microedition/lcdui/Canvas;Z)V * CLASS: javax.microedition.lcdui.game.GameCanvas * TYPE: virtual native function * OVERVIEW: Sets a private field in a public class defined in a * different package. * INTERFACE (operand stack manipulation): * parameters: c the object whose field we are to set * suppressKeyEvents value to set the private field to * returns: <nothing> */ KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(javax_microedition_lcdui_game_GameCanvas_setSuppressKeyEvents) { KNI_StartHandles(1); KNI_DeclareHandle(canvas); KNI_GetParameterAsObject(1, canvas); GET_GAMECANVAS_PTR(canvas)->suppressKeyEvents = KNI_GetParameterAsBoolean(2); KNI_EndHandles(); KNI_ReturnVoid(); }
/** * @internal * * Internal native implementation of Java function vibrate0() * * @verbatim * FUNCTION: vibrate0(II)Z * CLASS: com.sun.midp.lcdui.DisplayDeviceAccess * TYPE: native function to play vibration * OVERVIEW: turn on the vibrator mechanism if <code>onOff</code> * is true, or off if it is false. * return false if this <code>Display</code> does not have foreground. * INTERFACE (operand stack manipulation): * parameters: display the display ID associated with the Display object * onOff start/stop vibrator * returns: KNI_TRUE if the device supports vibrate and Display has * foreground, * KNI_FALSE otherwise * @endverbatim */ KNIEXPORT KNI_RETURNTYPE_BOOLEAN KNIDECL(com_sun_midp_lcdui_DisplayDeviceAccess_vibrate0) { jboolean onoff = KNI_GetParameterAsBoolean(2); int displayId = KNI_GetParameterAsInt(1); if(/*!midpHasForeground(displayId) || */anc_stop_vibrate() == KNI_FALSE){ KNI_ReturnBoolean(KNI_FALSE); } else if (KNI_FALSE == onoff) { KNI_ReturnBoolean(anc_stop_vibrate()); } else { KNI_ReturnBoolean(anc_start_vibrate()); } }
/* * Creates a client connection object. * * Note: the method sets native connection handle directly to * <code>handle<code> field of <code>RFCOMMConnectionImpl</code> object. * * @param auth <code>true</code> if authication is required * @param enc <code>true</code> indicates * what connection must be encrypted * @param master <code>true</code> if client requires to be * a connection's master * @throws IOException if any I/O error occurs */ KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(com_sun_jsr082_bluetooth_btspp_BTSPPConnectionImpl_create0) { javacall_bool auth = (KNI_GetParameterAsBoolean(1) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_bool enc = (KNI_GetParameterAsBoolean(2) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_bool master = (KNI_GetParameterAsBoolean(3) == KNI_TRUE) ? JAVACALL_TRUE : JAVACALL_FALSE; javacall_handle handle = JAVACALL_BT_INVALID_HANDLE; REPORT_INFO(LC_PROTOCOL, "btspp::create"); /* create RFCOMMC server connection */ if (javacall_bt_rfcomm_create_client(auth, enc, master, &handle) == JAVACALL_FAIL) { REPORT_ERROR(LC_PROTOCOL, "Connection creation failed during btspp::create"); KNI_ThrowNew(jsropIOException, EXCEPTION_MSG("Can not create RFCOMM connection")); KNI_ReturnVoid(); } KNI_StartHandles(1); KNI_DeclareHandle(thisHandle); KNI_GetThisPointer(thisHandle); /* store native connection handle to Java object */ KNI_SetIntField(thisHandle, connHandleID, (jint)handle); REPORT_INFO1(LC_PROTOCOL, "btspp::create0 handle=%d connection created", handle); KNI_EndHandles(); KNI_ReturnVoid(); }
/** * KNI function that sets selected state on an element with passed in index * in the native resource corresponding to the current ChoiceGroup. * * Java declaration: * <pre> * setSelectedIndex0(III)V * </pre> * @param nativeId - id of the native resource corresponding to the current * ChoiceGroup * @param elementNum - index of an element which content should be changed * @param selected - current selection state of the element */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_lcdui_ChoiceGroupLFImpl_setSelectedIndex0() { MidpError err = KNI_OK; MidpItem *cgPtr = (MidpItem *)KNI_GetParameterAsInt(1); int elementNum = KNI_GetParameterAsInt(2); jboolean selected = KNI_GetParameterAsBoolean(3); err = lfpport_choicegroup_set_selected_index(cgPtr, elementNum, selected); if (err == KNI_ENOMEM) { KNI_ThrowNew(midpOutOfMemoryError, NULL); } KNI_ReturnVoid(); }
KNIEXPORT KNI_RETURNTYPE_VOID KNIDECL(com_sun_midp_midletsuite_MIDletSuiteImpl_lockMIDletSuite) { jboolean isUpdate; SuiteIdType suiteId; int status; suiteId = KNI_GetParameterAsInt(1); isUpdate = KNI_GetParameterAsBoolean(2); /* Throw an exception here if we have an error */ status = lock_storage(suiteId, isUpdate); if (status < 0) { if (status == OUT_OF_MEM_LEN) { KNI_ThrowNew(midpOutOfMemoryError, NULL); } else if (status == SUITE_LOCKED) { KNI_ThrowNew(midletsuiteLocked, NULL); } } KNI_ReturnVoid(); }
/** * Gets all registered push connections associated with the given MIDlet * suite. * <p> * Java declaration: * <pre> * list0([BZ[BI)I * </pre> * * @param midlet The MIDlet suite to get push registry entries * @param available Which connections to return. If <tt>true</tt>, * only return the connections with available input. * Otherwise, return all connection. * @param connectionlist A comma separated string of connections stored * as a byte array. * @param listsz The maximum length of the byte array that will be * accepted for <tt>connectionlist</tt> * * @return <tt>0</tt> if successful, otherwise <tt>-1</tt> * * @throw IllegalArgumentException If the length <tt>midlet</tt> is * too long. */ KNIEXPORT KNI_RETURNTYPE_INT KNIDECL(com_sun_midp_io_j2me_push_ConnectionRegistry_list0) { char *midletName = NULL; int available; int connsize; int nameLength; char *conn; int ret = -1; available = KNI_GetParameterAsBoolean(2); connsize = KNI_GetParameterAsInt(4); KNI_StartHandles(2); KNI_DeclareHandle(name); KNI_DeclareHandle(connections); KNI_GetParameterAsObject(1, name); KNI_GetParameterAsObject(3, connections); nameLength = KNI_GetArrayLength(name); midletName = (char*)midpMalloc(nameLength); if (midletName == NULL) { KNI_ThrowNew(midpOutOfMemoryError, NULL); } else { KNI_GetRawArrayRegion(name, 0, nameLength, (jbyte*)midletName); conn = pushfindsuite(midletName, available); if (conn != NULL) { KNI_SetRawArrayRegion(connections, 0, strlen(conn), (jbyte*)conn); midpFree(conn); ret = 0; } midpFree(midletName); } KNI_EndHandles(); KNI_ReturnInt(ret); }
KNIEXPORT KNI_RETURNTYPE_VOID Java_com_sun_midp_jsr82emul_ConnectionEmul_notifyOpen() { int myHandle = KNI_GetParameterAsInt(1); jboolean success = KNI_GetParameterAsBoolean(2); connection_info_t *info = &emul_data.handled_info[myHandle].conn; LOG1("ConnectionEmul_notifyOpen(%d)", myHandle); if (success == KNI_FALSE) { info->connect_status = JAVACALL_FAIL; } else { info->imtu = KNI_GetParameterAsInt(3); info->omtu = KNI_GetParameterAsInt(4); info->connect_status = JAVACALL_OK; } javanotify_bt_protocol_event(JAVACALL_EVENT_BT_CONNECT_COMPLETE, (javacall_handle)myHandle, info->connect_status); KNI_ReturnVoid(); }
/** * KNI function that inserts new element with passed in string and image * into the native resource corresponding to the current ChoiceGroup. * * Java declaration: * <pre> * insert0(IISOB)V * </pre> * @param nativeId - id of the native resource corresponding to the current * ChoiceGroup * @param elementNum - location at which new element should be inserted * @param stringPart - string part of the element to be inserted * @param imagePart - image part of the element to be inserted * @param selected - current selection state of the inserted element */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_lcdui_ChoiceGroupLFImpl_insert0() { MidpError err = KNI_OK; MidpItem *cgPtr = (MidpItem *)KNI_GetParameterAsInt(1); MidpChoiceGroupElement cgElement; pcsl_string_status perr; int elementNum = KNI_GetParameterAsInt(2); KNI_StartHandles(2); KNI_DeclareHandle(stringPartJString); KNI_DeclareHandle(imgPartJImage); KNI_GetParameterAsObject(3, stringPartJString); KNI_GetParameterAsObject(4, imgPartJImage); if (KNI_IsNullHandle(imgPartJImage) == KNI_TRUE) { cgElement.image = NULL; } else { cgElement.image = gxp_get_imagedata(imgPartJImage); } perr = midp_jstring_to_pcsl_string(stringPartJString, &cgElement.string); cgElement.selected = KNI_GetParameterAsBoolean(5); cgElement.font = NULL; KNI_EndHandles(); if (PCSL_STRING_OK == perr) { err = lfpport_choicegroup_insert(cgPtr, elementNum, cgElement); } pcsl_string_free(&cgElement.string); if (err == KNI_ENOMEM) { KNI_ThrowNew(midpOutOfMemoryError, NULL); } KNI_ReturnVoid(); }
/** * KNI function that create native resource for current Gauge. * Class: javax.microedition.lcdui.GaugeLFImpl * Java prototype: * private native int createNativeResource0(int ownerId, * String label, int layout, * boolean interactive, * int maxValue, int initialValue) */ KNIEXPORT KNI_RETURNTYPE_INT Java_javax_microedition_lcdui_GaugeLFImpl_createNativeResource0() { MidpError err = KNI_OK; MidpItem *gaugePtr = NULL; MidpDisplayable *ownerPtr; int maxValue, initialValue, layout; jboolean interactive; KNI_StartHandles(1); ownerPtr = (MidpDisplayable *)KNI_GetParameterAsInt(1); GET_PARAMETER_AS_PCSL_STRING(2, label) layout = KNI_GetParameterAsInt(3); interactive = KNI_GetParameterAsBoolean(4); maxValue = KNI_GetParameterAsInt(5); initialValue = KNI_GetParameterAsInt(6); { gaugePtr = MidpNewItem(ownerPtr, interactive ? MIDP_INTERACTIVE_GAUGE_TYPE : MIDP_NON_INTERACTIVE_GAUGE_TYPE); if (gaugePtr == NULL) { err = KNI_ENOMEM; } else { err = lfpport_gauge_create(gaugePtr, ownerPtr, &label, layout, interactive, maxValue, initialValue); } /* cleanup: */ if (err != KNI_OK) { MidpDeleteItem(gaugePtr); KNI_ThrowNew(midpOutOfMemoryError, NULL); } } RELEASE_PCSL_STRING_PARAMETER KNI_EndHandles(); KNI_ReturnInt(gaugePtr); }
/* void stop(int exit_code, int exit_reason); */ void Java_com_sun_cldc_isolate_Isolate_stop(JVM_SINGLE_ARG_TRAPS) { UsingFastOops fast_oops; IsolateObj::Fast isolate_obj = GET_PARAMETER_AS_OOP(0); Task::Fast task = isolate_obj().task(); const int exit_code = KNI_GetParameterAsInt(1); const int exit_reason = KNI_GetParameterAsBoolean(2); switch (isolate_obj().status()) { case Task::TASK_NEW: isolate_obj().terminate(exit_code JVM_NO_CHECK_AT_BOTTOM); // Isolate was never started, so no threads to kill. break; case Task::TASK_STARTED: GUARANTEE(task.not_null(), "Task must exist for running Isolate"); task().stop(exit_code, exit_reason JVM_NO_CHECK_AT_BOTTOM); break; default: // OK to call stop() multiple times. Just ignore it. break; } }
/** * Gets the requested IP number. * <p> * Java declaration: * <pre> * getHost(Z)Ljava/lang/String; * </pre> * * @param local <tt>true</tt> to get the local host IP address, or * <tt>false</tt> to get the remote host IP address. * * @return the IP address as a dotted-quad <tt>String</tt> */ KNIEXPORT KNI_RETURNTYPE_OBJECT Java_com_sun_midp_io_j2me_socket_Protocol_getHost0(void) { int local; void *pcslHandle; char value[MAX_HOST_LENGTH]; int status = PCSL_NET_INVALID; local = (int)KNI_GetParameterAsBoolean(1); memset(value, '\0', MAX_HOST_LENGTH); KNI_StartHandles(2); KNI_DeclareHandle(result); KNI_DeclareHandle(thisObject); KNI_GetThisPointer(thisObject); pcslHandle = (void *)(getMidpSocketProtocolPtr(thisObject)->handle); if (INVALID_HANDLE == pcslHandle) { KNI_ThrowNew(midpIOException, "invalid handle during socket::getHost"); } else { if (local) { status = pcsl_socket_getlocaladdr(pcslHandle, value); } else { status = pcsl_socket_getremoteaddr(pcslHandle, value); } if (status == PCSL_NET_SUCCESS) { KNI_NewStringUTF(value, result); } else { KNI_ThrowNew(midpIOException, NULL); } } KNI_EndHandlesAndReturnObject(result); }
/** * * Listens for an InvocationImpl from the store using a MIDlet suiteId * and optional, and status. Each Invocation must be returned only * once. When an Invocation is returned; it is marked as being * notified. * * @param suiteId to match a pending invocation * @param classname to match a pending invocation * @param mode one of {@link #MODE_REQUEST}, {@link #MODE_RESPONSE}, * or {@link #MODE_CLEANUP} * @param blocking true to block until a matching invocation is available * @return true if an Invocation is found with * the same MIDlet suiteId and classname; false is returne dotherwise */ KNIEXPORT KNI_RETURNTYPE_BOOLEAN Java_com_sun_midp_content_InvocationStore_listen0(void) { StoredLink* match = NULL; SuiteIdType desiredSuiteId; pcsl_string desiredClassname = PCSL_STRING_NULL_INITIALIZER; KNI_StartHandles(1); KNI_DeclareHandle(classname); /* Arg2: non-null classname */ int mode; /* Arg3: requested invocation mode */ jboolean blocking = KNI_FALSE; /* Arg4: true if should block */ /* Argument indices must match Java native method declaration */ #define listenSuiteIdArg 1 #define listenClassnameArg 2 #define listenModeArg 3 #define listenBlockingArg 4 do {/* Block to break out of on exceptions */ /* Check if blocked invocation was cancelled. */ if (isThreadCancelled()) { /* blocking is always false to cleanup and exit immediately */ break; } /* Get the desired blocking mode. */ blocking = KNI_GetParameterAsBoolean(listenBlockingArg); if (!isEmpty()) { /* Queue is not empty * Need a string copy of the desired suiteID and classname * to use for comparisons */ desiredSuiteId = KNI_GetParameterAsInt(listenSuiteIdArg); KNI_GetParameterAsObject(listenClassnameArg, classname); if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(classname, &desiredClassname)) { KNI_ThrowNew(midpOutOfMemoryError, "InvocationStore_listen0 no memory for [desiredClassname]"); break; } /* Get the desired request mode. */ mode = KNI_GetParameterAsInt(listenModeArg); match = invocFind(desiredSuiteId, &desiredClassname, mode); } } while (KNI_FALSE); /* Always free strings allocated */ pcsl_string_free(&desiredClassname); if (match != NULL) { match->invoc->notified = KNI_TRUE; } else { if (blocking) { /* No found; block the thread in the VM */ blockThread(); /* Fall into the return to manage handles correctly */ } } KNI_EndHandles(); KNI_ReturnBoolean(match != NULL); }
/** * * Gets an InvocationImpl from the store using a MIDlet suiteId * and optional classname. * Getting an Invocation from the store removes it from the store. * If an OutOfMemory exception is thrown the matched Invocation * is NOT removed from the queue. If the heap memory can be * replenished then the operation can be retried. * * @param invoc an Invocation Object to fill in * @param suiteId to match a pending invocation * @param classname to match a pending invocation * @param mode one of {@link #MODE_REQUEST}, {@link #MODE_RESPONSE}, * or {@link #MODE_CLEANUP} * @param blocking true to block until a matching invocation is available * @return 1 if a matching invocation was found and returned * in its entirety; zero if there was no matching invocation; * -1 if the sizes of the arguments or parameter array were wrong * @see StoredInvoc */ KNIEXPORT KNI_RETURNTYPE_INT Java_com_sun_midp_content_InvocationStore_get0(void) { int ret = 0; /* return value = nothing matched */ KNI_StartHandles(4); KNI_DeclareHandle(obj); /* multipurpose handle */ KNI_DeclareHandle(argsObj); /* handle for argument array */ KNI_DeclareHandle(invocObj); /* Arg1: Invocation object; non-null */ KNI_DeclareHandle(classname); /* Arg3: non-null classname */ int mode = MODE_REQUEST; /* Arg4: mode for get */ jboolean blocking = KNI_FALSE; /* Arg5: true if should block */ /* Argument indices must match Java native method declaration */ #define getInvokeObjArg 1 #define getSuiteIdArg 2 #define getClassnameArg 3 #define getModeArg 4 #define getBlockingArg 5 StoredLink* match = NULL; SuiteIdType desiredSuiteId; pcsl_string desiredClassname = PCSL_STRING_NULL_INITIALIZER; do {/* Block to break out of on exceptions */ /* Check if blocked invocation was cancelled. */ if (isThreadCancelled()) { /* blocking is always false to cleanup and exit immediately */ break; } /* Get the desired blocking mode. */ blocking = KNI_GetParameterAsBoolean(getBlockingArg); if (!isEmpty()) { /* Queue is not empty, get InvocationImpl obj and init. */ KNI_GetParameterAsObject(getInvokeObjArg, invocObj); init(invocObj, obj); /* Get the desired type of invocation. */ mode = KNI_GetParameterAsInt(getModeArg); if (mode == MODE_TID || mode == MODE_TID_NEXT || mode == MODE_TID_PREV) { int tid = KNI_GetIntField(invocObj, tidFid); if (tid != 0) { match = invocFindTid(tid); } else { /* start with the root */ match = invocQueue; } if (match != NULL) { /* Link to the next or previous depending on the mode. */ if (mode == MODE_TID_NEXT) { match = match->flink; } else if (mode == MODE_TID_PREV) { match = match->blink; } } } else { desiredSuiteId = KNI_GetParameterAsInt(getSuiteIdArg); KNI_GetParameterAsObject(getClassnameArg, classname); if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(classname, &desiredClassname)) { KNI_ThrowNew(midpOutOfMemoryError, "InvocationStore_get0 no memory for [desiredClassname]"); break; } match = invocFind(desiredSuiteId, &desiredClassname, mode); } } } while (KNI_FALSE); /* Always free strings allocated */ pcsl_string_free(&desiredClassname); if (match != NULL) { StoredInvoc *invoc = match->invoc; int st = copyOut(invoc, mode, invocObj, argsObj, obj); switch (st) { case 1: /* If a match was found and successfully copied; * do final set of actions on the Invocation selected. */ switch (mode) { case MODE_REQUEST: if (invoc->status == STATUS_INIT) { /* * Returning new request, change status to ACTIVE * Keep this entry in the queue. */ invoc->status = STATUS_ACTIVE; KNI_SetIntField(invocObj, statusFid, invoc->status); } break; case MODE_RESPONSE: if (invoc->status >= STATUS_OK && invoc->status <= STATUS_INITIATED) { /* * Remove responses from the list and free. */ removeEntry(match); invocFree(invoc); } break; case MODE_LREQUEST: case MODE_LRESPONSE: case MODE_CLEANUP: case MODE_TID: case MODE_TID_NEXT: case MODE_TID_PREV: default: /* No additional action */ break; } /* Returning an Invocation */ ret = 1; break; case 0: /* Insufficient memory for strings. */ KNI_ThrowNew(midpOutOfMemoryError, "invocStore returning strings"); KNI_ReleaseHandle(invocObj); ret = 0; break; case -1: /* Either args array or data array is incorrect size. */ ret = -1; } } else { /* No match found. */ /* If blocking, setup to block. */ if (blocking) { blockThread(); /* Fall into the return to manage handles correctly */ } ret = 0; } KNI_EndHandles(); KNI_ReturnInt(ret); }
/** * Populates a passed in immutable <tt>ImageData</tt> * from the given ARGB integer * array. The array consists of values in the form of 0xAARRGGBB. * <p> * Java declaration: * <pre> * createImmutableImageDecodeRGBImage([Ljavax/microedition/lcdui/ImageData;III)V * </pre> * * @param imageData The <tt>ImadgeData</tt> to be populated * @param rgbData The array of argb image data * @param width The width of the new image * @param height The height of the new image * @param processAlpha If <tt>true</tt>, alpha channel bytes will * be used, otherwise, alpha channel bytes will * be ignored */ KNIEXPORT KNI_RETURNTYPE_VOID Java_javax_microedition_lcdui_ImageDataFactory_createImmutableImageDecodeRGBImage() { jboolean processAlpha = KNI_GetParameterAsBoolean(5); int height = KNI_GetParameterAsInt(4); int width = KNI_GetParameterAsInt(3); jint *imageBuffer = NULL; int buflen; img_native_error_codes creationError = IMG_NATIVE_IMAGE_NO_ERROR; /* pointer to native image structure */ gxpport_image_native_handle newImagePtr; KNI_StartHandles(2); KNI_DeclareHandle(rgbData); KNI_DeclareHandle(imageData); KNI_GetParameterAsObject(2, rgbData); KNI_GetParameterAsObject(1, imageData); do { if (KNI_IsNullHandle(rgbData)) { KNI_ThrowNew(midpNullPointerException, NULL); break; } if ((width <= 0) || (height <= 0)) { KNI_ThrowNew(midpIllegalArgumentException, NULL); break; } buflen = KNI_GetArrayLength(rgbData); if ((width * height) > buflen) { KNI_ThrowNew(midpArrayIndexOutOfBoundsException, NULL); break; } imageBuffer = JavaIntArray(rgbData); SNI_BEGIN_RAW_POINTERS; gxpport_decodeimmutable_from_argb(imageBuffer, width, height, processAlpha, &newImagePtr, &creationError); SNI_END_RAW_POINTERS; if (IMG_NATIVE_IMAGE_NO_ERROR == creationError) { java_imagedata * dstImageDataPtr = IMGAPI_GET_IMAGEDATA_PTR(imageData); dstImageDataPtr->height = (jint)height; dstImageDataPtr->width = (jint)width; dstImageDataPtr->nativeImageData = (jint)newImagePtr; break; } if (IMG_NATIVE_IMAGE_OUT_OF_MEMORY_ERROR == creationError) { KNI_ThrowNew(midpOutOfMemoryError, NULL); break; } if (IMG_NATIVE_IMAGE_RESOURCE_LIMIT == creationError) { KNI_ThrowNew(midpOutOfMemoryError, "Resource limit exceeded for immutable image"); break; } KNI_ThrowNew(midpIllegalArgumentException, NULL); } while (0); KNI_EndHandles(); KNI_ReturnVoid(); }