/**
* The function unblocks threads waiting for Transaction Store
*/
void unlock() {
int i, n;
JVMSPI_BlockedThreadInfo *blocked_threads;
MidpReentryData* pThreadReentryData;
KNI_StartHandles(1);
KNI_DeclareHandle(thisObject);
KNI_GetThisPointer(thisObject);
if ((locked == KNI_TRUE) &&
(getStorageOpenFlag(thisObject)->isOpen == KNI_TRUE)) {
blocked_threads = SNI_GetBlockedThreads(&n);
getStorageOpenFlag(thisObject)->isOpen = KNI_FALSE;
locked = KNI_FALSE;
for (i = 0; i < n; i++) {
pThreadReentryData =
(MidpReentryData*)(blocked_threads[i].reentry_data);
if (pThreadReentryData == NULL) {
continue;
}
if (pThreadReentryData->waitingFor !=
PAYMENT_TRANSACTION_STORE_SIGNAL) {
continue;
}
pThreadReentryData->status = KNI_TRUE;
midp_thread_unblock(blocked_threads[i].thread_id);
}
}
KNI_EndHandles();
}
/**
* Checks out (takes ownership of) an active server connection maintained
* by push subsystem.
*
* @param url URL used during registration of the push entry
* @param suiteId suite id
* @return true if the operation succeeds, false otherwise
*/
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
Java_com_sun_midp_io_j2me_btspp_BTSPPNotifierImpl_pushCheckout(void) {
jboolean retval = KNI_FALSE;
SuiteIdType suiteId;
MidpString wsUrl;
char *szUrl;
bt_port_t port;
KNI_StartHandles(2);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(urlHandle);
KNI_GetThisPointer(thisHandle);
KNI_GetParameterAsObject(1, urlHandle);
suiteId = KNI_GetParameterAsInt(2);
wsUrl = midpNewString(urlHandle);
szUrl = midpJcharsToChars(wsUrl);
if (bt_push_parse_url(szUrl, &port, NULL) == BT_RESULT_SUCCESS) {
if (pushcheckout(szUrl, 0, (char*)midp_suiteid2chars(suiteId)) == -2) {
KNI_ThrowNew(midpIOException, "Port already in use.");
} else {
bt_handle_t handle;
bt_pushid_t pushid = bt_push_checkout_server(&port, &handle, NULL);
if (pushid != BT_INVALID_PUSH_HANDLE) {
KNI_SetIntField(thisHandle, pushHandleID, (jint)pushid);
KNI_SetIntField(thisHandle, notifHandleID, (jint)handle);
retval = KNI_TRUE;
}
}
}
midpFree(szUrl);
MIDP_FREE_STRING(wsUrl);
KNI_EndHandles();
KNI_ReturnBoolean(retval);
}
/**
* Releases any native resources used by the datagram connection.
* <p>
* Java declaration:
* <pre>
* finalize(V)V
* </pre>
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_datagram_Protocol_finalize(void) {
void *handle;
int status;
void *context = NULL;
KNI_StartHandles(1);
KNI_DeclareHandle(thisObject);
KNI_GetThisPointer(thisObject);
handle = (void *)getMidpDatagramProtocolPtr(thisObject)->nativeHandle;
if (handle != INVALID_HANDLE) {
if (pushcheckin((int)handle) == -1) {
status = pcsl_datagram_close_start(handle, &context);
if (status == PCSL_NET_SUCCESS) {
if (midpDecResourceCount(RSC_TYPE_UDP, 1) == 0) {
REPORT_INFO(LC_PROTOCOL,
"Datagrams: resource limit update error");
}
} else if (status == PCSL_NET_IOERROR) {
REPORT_INFO2(LC_PROTOCOL,
"datagram::finalize handle 0x%x I/O error code %d",
(int)handle, pcsl_network_error(handle));
} else if (status == PCSL_NET_WOULDBLOCK) {
REPORT_ERROR1(LC_PROTOCOL,
"datagram::finalize handle 0x%x WOULDBLOCK not supported",
(int)handle);
}
getMidpDatagramProtocolPtr(thisObject)->nativeHandle =
(jint)INVALID_HANDLE;
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Creates a copy of the specified <tt>ImageData</tt> and stores the
* copied image in this object.
* <p>
* Java declaration:
* <pre>
* createImmutableImageDataCopy(Ljavax/microedition/lcdui/ImageData;
* Ljavax/microedition/lcdui/ImageData;)V
* </pre>
*
* @param dest The <tt>ImageData </tt>where to make a copy
* @param source The mutable <tt>ImageData</tt> to copy
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_javax_microedition_lcdui_ImageDataFactory_createImmutableImageDataCopy() {
img_native_error_codes creationError = IMG_NATIVE_IMAGE_NO_ERROR;
/* mutable image */
gxpport_image_native_handle srcImage;
/* pointer to native image structure */
gxpport_image_native_handle newImage;
KNI_StartHandles(2);
KNI_DeclareHandle(dest);
KNI_DeclareHandle(source);
KNI_GetParameterAsObject(2, source);
KNI_GetParameterAsObject(1, dest);
srcImage = gxp_get_imagedata(source);
gxpport_createimmutable_from_mutable(srcImage, &newImage, &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(dest)->nativeImageData = (jint)newImage;
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Gets the number of bytes that can be read without blocking.
* <p>
* Java declaration:
* <pre>
* available0(V)I
* </pre>
*
* @return number of bytes that can be read without blocking
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_socket_Protocol_available0(void) {
void *pcslHandle;
int bytesAvailable = 0;
KNI_StartHandles(1);
KNI_DeclareHandle(thisObject);
KNI_GetThisPointer(thisObject);
pcslHandle = (void *)(getMidpSocketProtocolPtr(thisObject)->handle);
KNI_EndHandles();
REPORT_INFO1(LC_PROTOCOL, "socket::available0 fd=%d\n", (int)pcslHandle);
if (INVALID_HANDLE == pcslHandle) {
KNI_ThrowNew(midpIOException, "invalid handle during socket::available");
} else {
int status;
status = pcsl_socket_available(pcslHandle, &bytesAvailable);
/* status is only PCSL_NET_SUCCESS or PCSL_NET_IOERROR */
if (status == PCSL_NET_IOERROR) {
bytesAvailable = 0;
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IOError %d during socket::available0",
pcsl_network_error(pcslHandle));
KNI_ThrowNew(midpIOException, gKNIBuffer);
}
}
REPORT_INFO1(LC_PROTOCOL, "socket::available0 bytesAvailable=%d\n",
bytesAvailable);
KNI_ReturnInt((jint)bytesAvailable);
}
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_cldc_io_j2me_socket_Protocol_readBuf() {
int result = -1;
SocketBufferParameter *p;
if (!ANI_Start()) {
ANI_Wait();
KNI_ReturnInt(-1);
}
KNI_StartHandles(1);
KNI_DeclareHandle(buffer_object);
KNI_GetParameterAsObject(2, buffer_object);
p = (SocketBufferParameter *) ANI_GetParameterBlock(NULL);
if (p == NULL) {
int buffer_size = KNI_GetParameterAsInt(4);
p = new_buffer_parameter(/*fd*/ KNI_GetParameterAsInt(1), buffer_size);
if (!ANI_UseFunction(asynchronous_socket_read,
/*try_non_blocking*/ KNI_FALSE)) {
ANI_BlockThread();
goto EXIT;
}
}
if ((result = p->buffer_size) > 0) {
jint offset = KNI_GetParameterAsInt(3);
KNI_SetRawArrayRegion(buffer_object, offset, p->buffer_size,
(jbyte *) p->buffer);
}
EXIT:
KNI_EndHandles();
ANI_End();
KNI_ReturnInt(result);
}
/*
* 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();
}
/**
* Get the maximum length of a datagram.
* <p>
* Java declaration:
* <pre>
* getMaximumLength0(V)I
* </pre>
*
* @return maximum length of a datagram
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_datagram_Protocol_getMaximumLength0(void) {
void *socketHandle;
int len = -1;
KNI_StartHandles(1);
KNI_DeclareHandle(thisObject);
KNI_GetThisPointer(thisObject);
socketHandle =
(void *)getMidpDatagramProtocolPtr(thisObject)->nativeHandle;
if (socketHandle != INVALID_HANDLE) {
int status;
/*
* IMPL NOTE:
* Option=3 represents SO_RCVBUF
* The SO_RCVBUF option is used by the the network implementation
* as a hint to size the underlying network I/O buffers.
*/
status = pcsl_network_getsockopt(socketHandle, 3, &len);
if (status != PCSL_NET_SUCCESS) {
KNI_ThrowNew(midpIOException, NULL);
}
} else {
KNI_ThrowNew(midpIOException, "socket closed");
}
REPORT_INFO2(LC_PROTOCOL,
"datagram::getMaximumLength0 handle=%d len=%d %d\n",
(int)socketHandle, len);
KNI_EndHandles();
KNI_ReturnInt((jint)len);
}
/**
* 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) {
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);
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);
SNI_END_RAW_POINTERS;
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Gets an ARGB integer array from this <tt>ImmutableImage</tt>. The
* array consists of values in the form of 0xAARRGGBB.
* <p>
* Java declaration:
* <pre>
* getRGB([IIIIIII)V
* </pre>
*
* @param rgbData The target integer array for the ARGB data
* @param offset Zero-based index of first ARGB pixel to be saved
* @param scanlen Number of intervening pixels between pixels in
* the same column but in adjacent rows
* @param x The x coordinate of the upper left corner of the
* selected region
* @param y The y coordinate of the upper left corner of the
* selected region
* @param width The width of the selected region
* @param height The height of the selected region
*/
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(javax_microedition_lcdui_Image_getRGB) {
int height = KNI_GetParameterAsInt(7);
int width = KNI_GetParameterAsInt(6);
int y = KNI_GetParameterAsInt(5);
int x = KNI_GetParameterAsInt(4);
int scanlength = KNI_GetParameterAsInt(3);
int offset = KNI_GetParameterAsInt(2);
int buflen;
int *rgbBuffer;
int img_width;
int img_height;
jboolean iae = KNI_FALSE;
java_imagedata * srcImageDataPtr = NULL;
KNI_StartHandles(2);
KNI_DeclareHandle(rgbData);
KNI_DeclareHandle(thisObject);
KNI_GetParameterAsObject(1, rgbData);
KNI_GetThisPointer(thisObject);
srcImageDataPtr = GET_IMAGE_PTR(thisObject)->imageData;
img_width = srcImageDataPtr->width;
img_height = srcImageDataPtr->height;
/* see if absolute value of scanlength is greater than or equal to width */
if (scanlength >= 0 && scanlength < width) {
iae = KNI_TRUE;
} else if (scanlength < 0 && (0 - scanlength) < width) {
iae = KNI_TRUE;
}
if (KNI_IsNullHandle(rgbData)) {
KNI_ThrowNew(midpNullPointerException, NULL);
} else if((y < 0) || (x < 0) || (x + width > img_width) ||
(y + height > img_height) || iae == KNI_TRUE) {
KNI_ThrowNew(midpIllegalArgumentException, NULL);
} else if (height < 0 || width < 0 ) {
/* spec says noop in this case */
} else {
buflen = KNI_GetArrayLength(rgbData);
if (offset < 0
|| offset + ((height - 1) * scanlength) + width > buflen
|| offset + ((height - 1) * scanlength) < 0) {
KNI_ThrowNew(midpArrayIndexOutOfBoundsException, NULL);
} else {
gxutl_native_image_error_codes error = GXUTL_NATIVE_IMAGE_NO_ERROR;
SNI_BEGIN_RAW_POINTERS;
rgbBuffer = JavaIntArray(rgbData);
gx_get_argb(srcImageDataPtr, rgbBuffer,
offset, scanlength,
x, y, width, height, &error);
SNI_END_RAW_POINTERS;
if (error != GXUTL_NATIVE_IMAGE_NO_ERROR) {
KNI_ThrowNew(midpOutOfMemoryError, NULL);
}
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Renders the given region of this <tt>ImmutableImage</tt> onto the
* given <tt>Graphics</tt> object.
* <p>
* Java declaration:
* <pre>
* renderRegion(Ljavax/microedition/lcdui/ImageImpl;IIIIIIII)V
* </pre>
*
* @param g The <tt>Graphics</tt> object to be drawn
* @param x_src The x coordinate of the upper-left corner of the
* source region
* @param y_src The y coordinate of the upper-left corner of the
* source region
* @param width The width of the source region
* @param height The height of the source region
* @param transform The transform to apply to the selected region.
* @param x_dest The x coordinate of the destination anchor point
* @param y_dest The y coordinate of the destination anchor point
* @param anchor The anchor point for positioning the destination
* <tt>Image</tt>
*/
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
KNIDECL(javax_microedition_lcdui_Image_renderRegion) {
int anchor = KNI_GetParameterAsInt(9);
int y_dest = KNI_GetParameterAsInt(8);
int x_dest = KNI_GetParameterAsInt(7);
int transform = KNI_GetParameterAsInt(6);
int height = KNI_GetParameterAsInt(5);
int width = KNI_GetParameterAsInt(4);
int y_src = KNI_GetParameterAsInt(3);
int x_src = KNI_GetParameterAsInt(2);
jboolean success = KNI_TRUE;
KNI_StartHandles(3);
KNI_DeclareHandle(img);
KNI_DeclareHandle(g);
KNI_DeclareHandle(gImg);
KNI_GetParameterAsObject(1, g);
KNI_GetThisPointer(img);
if (GRAPHICS_OP_IS_ALLOWED(g)) {
if (KNI_IsNullHandle(img)) {
/* null checking is performed in the Java code, but check just in case */
success = KNI_FALSE; //KNI_ThrowNew(midpNullPointerException, NULL);
} else if ((transform < 0) || (transform > 7)) {
success = KNI_FALSE; //KNI_ThrowNew(midpIllegalArgumentException, NULL);
} else if (!gxutl_normalize_anchor(&x_dest, &y_dest,
width, height, anchor)) {
success = KNI_FALSE; //KNI_ThrowNew(midpIllegalArgumentException, NULL);
} else {
const java_imagedata * srcImageDataPtr = GET_IMAGE_PTR(img)->imageData;
jint img_width = srcImageDataPtr->width;
jint img_height = srcImageDataPtr->height;
GET_IMAGE_PTR(gImg) = (struct Java_javax_microedition_lcdui_Image *)
(GXAPI_GET_GRAPHICS_PTR(g)->img);
if (KNI_IsSameObject(gImg, img) ||
(height < 0) || (width < 0) || (x_src < 0) || (y_src < 0) ||
((x_src + width) > img_width) ||
((y_src + height) > img_height)) {
success = KNI_FALSE; //KNI_ThrowNew(midpIllegalArgumentException, NULL);
} else {
jshort clip[4]; /* Defined in Graphics.java as 4 shorts */
const java_imagedata * dstMutableImageDataPtr =
GXAPI_GET_IMAGEDATA_PTR_FROM_GRAPHICS(g);
GXAPI_TRANSLATE(g, x_dest, y_dest);
GXAPI_GET_CLIP(g, clip);
gx_render_imageregion(srcImageDataPtr, dstMutableImageDataPtr,
clip,
x_src, y_src,
width, height,
x_dest, y_dest,
transform);
}
}
}
KNI_EndHandles();
KNI_ReturnBoolean(success);
}
/**
* Open a serial port by system dependent device name.
*
* @param name device name of the port
* @param baud baud rate to set the port at
* @param flags options for the serial port
*
* @return handle to a native serial port
*
* @exception IOException if an I/O error occurs.
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_comm_Protocol_native_1openByName() {
int flags = (int)KNI_GetParameterAsInt(3);
int baud = (int)KNI_GetParameterAsInt(2);
int nameLen;
char szName[MAX_NAME_LEN];
jchar* temp;
int hPort = (int)INVALID_HANDLE;
int i;
int status = PCSL_NET_IOERROR;
void* context = NULL;
MidpReentryData* info;
KNI_StartHandles(1);
KNI_DeclareHandle(nameObject);
KNI_GetParameterAsObject(1, nameObject);
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) {
nameLen = KNI_GetStringLength(nameObject);
if (nameLen > MAX_NAME_LEN) {
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Serial device name has wrong length: %d\n", nameLen);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpIllegalArgumentException, gKNIBuffer);
} else {
temp = (jchar*)szName;
KNI_GetStringRegion(nameObject, 0, nameLen, temp);
/* device names are in ASCII */
for (i = 0; i < nameLen; i++) {
szName[i] = (char)temp[i];
}
szName[nameLen] = 0;
status = openPortByNameStart(szName, baud, flags, &hPort, &context);
}
} else {
/* reinvocation */
hPort = info->descriptor;
context = info->pResult;
status = openPortByNameFinish(szName, baud, flags, &hPort, context);
}
switch (status) {
case PCSL_NET_SUCCESS:
/* do nothing and return normally */
break;
case PCSL_NET_INTERRUPTED:
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Opening port %s has been interrupted\n", szName);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpInterruptedIOException, gKNIBuffer);
break;
case PCSL_NET_WOULDBLOCK:
midp_thread_wait(COMM_OPEN_SIGNAL, hPort, context);
break;
default:
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Opening port %s was failed\n", szName);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpIOException, gKNIBuffer);
}
KNI_EndHandles();
KNI_ReturnInt((jint)hPort);
}
/**
* Write to a serial port without blocking.
*
* @param hPort handle to a native serial port
* @param b I/O buffer
* @param off starting offset for data
* @param len length of data
*
* @return number of bytes that were written
*
* @exception IOException if an I/O error occurs.
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_comm_Protocol_native_1writeBytes() {
int length = (int)KNI_GetParameterAsInt(4);
int offset = (int)KNI_GetParameterAsInt(3);
int hPort = (int)KNI_GetParameterAsInt(1);
int bytesWritten = 0;
int status = PCSL_NET_IOERROR;
void* context = NULL;
MidpReentryData* info;
KNI_StartHandles(1);
KNI_DeclareHandle(bufferObject);
KNI_GetParameterAsObject(2, bufferObject);
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) {
if (hPort < 0) {
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Write to port: handle %d is invalid\n", hPort);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpIllegalArgumentException, gKNIBuffer);
} else {
SNI_BEGIN_RAW_POINTERS;
status = writeToPortStart(hPort,
(char*)&(JavaByteArray(bufferObject)[offset]),
length, &bytesWritten, &context);
SNI_END_RAW_POINTERS;
}
} else {
/* reinvocation */
hPort = info->descriptor;
context = info->pResult;
SNI_BEGIN_RAW_POINTERS;
status = writeToPortFinish(hPort,
(char*)&(JavaByteArray(bufferObject)[offset]),
length, &bytesWritten, context);
SNI_END_RAW_POINTERS;
}
switch (status) {
case PCSL_NET_SUCCESS:
/*do nothing and return normally */
break;
case PCSL_NET_INTERRUPTED:
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Writing to port %d has been interrupted\n", hPort);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpInterruptedIOException, gKNIBuffer);
break;
case PCSL_NET_WOULDBLOCK:
midp_thread_wait(COMM_WRITE_SIGNAL, hPort, context);
break;
default:
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Writing to port %d was failed\n", hPort);
REPORT_INFO1(LC_PROTOCOL, "%s\n", gKNIBuffer);
KNI_ThrowNew(midpIOException, gKNIBuffer);
}
KNI_EndHandles();
KNI_ReturnInt((jint)bytesWritten);
}
/**
* Implementation of native method to set the status of an Invocation.
* If the status is set to a response status then the "finish"
* behavior is performed. If a response is required, the Invocation
* is requeued to the invoking application. Otherwise, the Invocation
* is discarded.
*
* @param invoc the InvocationImpl to update the native status
* @see StoredInvoc
* @see #invocQueue
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_content_InvocationStore_setStatus0(void) {
StoredLink* link;
StoredInvoc* invoc;
int tid;
KNI_StartHandles(3);
KNI_DeclareHandle(invocObj);
KNI_DeclareHandle(obj1);
KNI_DeclareHandle(obj2);
KNI_GetParameterAsObject(1, invocObj);
init(invocObj, obj1);
/* Find the matching entry in the queue */
tid = KNI_GetIntField(invocObj, tidFid);
link = invocFindTid(tid);
if (link != NULL) {
invoc = link->invoc;
/* Update the status */
invoc->status = KNI_GetIntField(invocObj, statusFid);
switch (invoc->status) {
case STATUS_OK:
case STATUS_CANCELLED:
case STATUS_ERROR:
case STATUS_INITIATED:
/*
* If a response is required, switch the target
* application; if not then discard the Invocation.
*/
if (invoc->responseRequired) {
/* Swap the source and target suite and classname */
SuiteIdType tmpSuiteId = invoc->invokingSuiteId;
SuiteIdType tmpSuiteId2;
pcsl_string tmpClassname = invoc->invokingClassname;
invoc->invokingSuiteId = invoc->suiteId;
invoc->invokingClassname = invoc->classname;
invoc->suiteId = tmpSuiteId;
invoc->classname = tmpClassname;
/* Unmark the response it is "new" to the target */
invoc->cleanup = KNI_FALSE;
invoc->notified = KNI_FALSE;
/* Swap the references in the Invocation object. */
tmpSuiteId = KNI_GetIntField(invocObj, suiteIdFid);
tmpSuiteId2 = KNI_GetIntField(invocObj, invokingSuiteIdFid);
KNI_SetIntField(invocObj, invokingSuiteIdFid, tmpSuiteId);
KNI_SetIntField(invocObj, suiteIdFid, tmpSuiteId2);
KNI_GetObjectField(invocObj, invokingClassnameFid, obj1);
KNI_GetObjectField(invocObj, classnameFid, obj2);
KNI_SetObjectField(invocObj, classnameFid, obj1);
KNI_SetObjectField(invocObj, invokingClassnameFid, obj2);
/* Unblock any waiting threads so they can retrieve this. */
unblockWaitingThreads(STATUS_OK);
break;
}
/* If no response; Fall into DISPOSE */
case STATUS_DISPOSE:
/*
* Free the Invocation, clean the Tid in the Invocation
*/
invoc->tid = 0;
KNI_SetIntField(invocObj, tidFid, 0);
removeEntry(link);
invocFree(invoc);
break;
case STATUS_ACTIVE:
case STATUS_HOLD:
case STATUS_WAITING:
/* No Action. */
break;
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Implementation of native method to queue a new Invocation.
* The state of the InvocationImpl is copied to the heap
* and inserted in the head of the invocation queue.
* An StoredInvoc struct is allocated on the native heap and
* the non-null strings for each field of the InvocationImpl class
* are copied to the heap.
* A new transaction ID is assigned to this Invocation
* and returned in the tid field of the InvocationImpl.
* @param invoc the InvocationImpl to store
* @throws OutOfMemoryError if the memory allocation fails
* @see StoredInvoc
* @see #invocQueue
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_content_InvocationStore_put0(void) {
StoredInvoc* invoc = NULL;
KNI_StartHandles(4);
KNI_DeclareHandle(invocObj);
KNI_DeclareHandle(classObj);
KNI_DeclareHandle(argsObj);
KNI_DeclareHandle(str);
KNI_GetParameterAsObject(1, invocObj);
init(invocObj, classObj);
do {
/* On any error break out of this block */
/* Allocate a new zero'ed struct to save the values in */
invoc = (StoredInvoc*) pcsl_mem_calloc(1, sizeof (StoredInvoc));
if (invoc == NULL) {
KNI_ThrowNew(midpOutOfMemoryError,
"InvocationStore_put0 no memory for [invoc]");
break;
}
/* Assign a new transaction id and set it */
invoc->tid = invocNextTid();
KNI_SetIntField(invocObj, tidFid, invoc->tid);
/*
* Copy all the parameters to native
* Includes ID, type,url, action, args, data
*/
if (KNI_TRUE != setParamsFromObj(invoc, invocObj, str, argsObj))
break;
invoc->previousTid = KNI_GetIntField(invocObj, previousTidFid);
invoc->status = KNI_GetIntField(invocObj, statusFid);
invoc->responseRequired =
KNI_GetBooleanField(invocObj, responseRequiredFid);
invoc->suiteId = KNI_GetIntField(invocObj, suiteIdFid);
KNI_GetObjectField(invocObj, classnameFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str, &invoc->classname))
break;
KNI_GetObjectField(invocObj, invokingAuthorityFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str,
&invoc->invokingAuthority))
break;
KNI_GetObjectField(invocObj, invokingAppNameFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str,
&invoc->invokingAppName))
break;
invoc->invokingSuiteId = KNI_GetIntField(invocObj, invokingSuiteIdFid);
KNI_GetObjectField(invocObj, invokingClassnameFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str,
&invoc->invokingClassname))
break;
KNI_GetObjectField(invocObj, invokingIDFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str, &invoc->invokingID))
break;
KNI_GetObjectField(invocObj, usernameFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str, &invoc->username))
break;
KNI_GetObjectField(invocObj, passwordFid, str);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(str, &invoc->password))
break;
/* Insert the new Invocation at the end of the queue */
if (!invocPut(invoc))
break;
unblockWaitingThreads(STATUS_OK);
/* Clear to skip cleanup and throwing exception */
invoc = NULL;
} while (0);
if (invoc != NULL) {
/* An allocation error occurred; free any remaining */
invocFree(invoc);
KNI_ThrowNew(midpOutOfMemoryError, "invocStore.c allocation failed");
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* Copy engine buffer back to MIDP */
void
JSR239_putWindowContents(jobject graphicsHandle,
jint delta_height,
JSR239_Pixmap *src, jint flipY) {
void* s;
void* d;
KNI_StartHandles(1);
KNI_DeclareHandle(GraphicsClassHandle);
#ifdef DEBUG
printf("JSR239_putWindowContents >>\n");
#endif
KNI_FindClass("javax/microedition/lcdui/Graphics", GraphicsClassHandle);
if (!KNI_IsInstanceOf(graphicsHandle, GraphicsClassHandle)) {
#ifdef DEBUG
printf("JSR239_putWindowContents only implemented for graphicsHandle "
"instanceof Graphics!\n");
#endif
} else {
gxj_screen_buffer sbuf;
gxj_screen_buffer* gimg;
// Obtain the dimensions of the destination.
jint dest_width = lcdlf_get_screen_width();
jint dest_height = lcdlf_get_screen_height();
jint min_height = 0;
gimg = GXJ_GET_GRAPHICS_SCREEN_BUFFER(graphicsHandle, &sbuf);
if (gimg != NULL) {
dest_width = gimg->width;
dest_height= gimg->height;
}
#ifdef DEBUG
printf("JSR239_putWindowContents:\n");
printf(" src Bpp = %d\n", src->pixelBytes);
printf(" src width = %d\n", src->width);
printf(" src height = %d\n", src->height);
printf(" min height = %d\n", min_height);
#endif
/* IMPL_NOTE: get clip sizes into account. */
copyToScreenBuffer(src, delta_height, flipY);
/* src->screen_buffer is an output of copyToScreenBuffer function. */
s = (void*)src->screen_buffer;
d = (void*)getGraphicsBuffer(graphicsHandle);
min_height = (dest_height > src->height) ? src->height : dest_height;
if ((src->width != dest_width) ||
(sizeof(gxj_pixel_type) != 2)) {
#ifdef DEBUG
printf("JSR239: offscreen buffer data is incorrect.\n");
#endif
} else {
/* Source data must be in 16bit 565 format. */
JSR239_memcpy(d, s,
dest_width * min_height * sizeof(gxj_pixel_type));
}
}
#ifdef DEBUG
printf("JSR239_putWindowContents <<\n");
#endif
KNI_EndHandles();
}
/**
*
* 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);
}
KNIEXPORT KNI_RETURNTYPE_OBJECT
KNIDECL(com_sun_midp_chameleon_skins_resources_LoadedSkinData_readStringArray) {
int arrayLength;
int i;
KNI_StartHandles(2);
KNI_DeclareHandle(returnArray);
KNI_DeclareHandle(stringHandle);
do {
/*
* First, read array length
*/
ENSURE_SKIN_DATA_AVAILABILITY(sizeof(jint));
memcpy((void*)&arrayLength, (void*)gsSkinFileDataPos, sizeof(jint));
gsSkinFileDataPos += sizeof(jint);
/*
* Then create array
*/
SNI_NewArray(SNI_STRING_ARRAY, arrayLength, returnArray);
if (KNI_IsNullHandle(returnArray)) {
KNI_ThrowNew(midpOutOfMemoryError, NULL);
break;
}
/*
* And finally populate it with strings
*/
for (i = 0; i < arrayLength; ++i) {
unsigned char dataLength;
unsigned char encoding;
/* read data length */
ENSURE_SKIN_DATA_AVAILABILITY(sizeof(char));
dataLength = *((unsigned char*)gsSkinFileDataPos);
gsSkinFileDataPos += 1;
/* read encoding */
ENSURE_SKIN_DATA_AVAILABILITY(sizeof(char));
encoding = *((unsigned char*)gsSkinFileDataPos);
gsSkinFileDataPos += 1;
ENSURE_SKIN_DATA_AVAILABILITY(dataLength * sizeof(char));
if (encoding == STRING_ENCODING_USASCII) {
int j;
/*
* In case of USASCII encoding, each byte of
* string data corresponds to one string char
*/
int stringLength = dataLength;
/* use gKNIBuffer for storing string chars */
jchar* stringChars = (jchar*)gKNIBuffer;
/*
* Safety measure to prevent gKNIBuffer overflow
* (which should never happens unless something is broken)
*/
if (stringLength > (int)(KNI_BUFFER_SIZE/sizeof(jchar))) {
stringLength = (int)(KNI_BUFFER_SIZE/sizeof(jchar));
REPORT_WARN(LC_HIGHUI,
"gKNIBuffer is too small for skin string");
}
/* fill string chars array */
for (j = 0; j < stringLength; ++j) {
stringChars[j] = gsSkinFileDataPos[j];
}
/* and create string from it */
KNI_NewString(stringChars, stringLength, stringHandle);
} else if (encoding == STRING_ENCODING_UTF8) {
KNI_NewStringUTF((char*)gsSkinFileDataPos, stringHandle);
} else {
KNI_ThrowNew(midpIllegalStateException,
"Illegal skin string encoding");
break;
}
KNI_SetObjectArrayElement(returnArray, i, stringHandle);
gsSkinFileDataPos += dataLength;
}
} while (0);
KNI_EndHandlesAndReturnObject(returnArray);
}
/* private native int _eglCreatePbufferSurface ( int display , int config , int [ ] attrib_list ) ; */
KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_khronos_egl_EGL10Impl__1eglCreatePbufferSurface() {
jint display = KNI_GetParameterAsInt(1);
jint config = KNI_GetParameterAsInt(2);
EGLint *attrib_list = (EGLint *)0;
jint returnValue = (jint)EGL_NO_SURFACE;
KNI_StartHandles(2);
KNI_DeclareHandle(attrib_listHandle);
KNI_DeclareHandle(thisHandle);
KNI_GetParameterAsObject(3, attrib_listHandle);
KNI_GetThisPointer(thisHandle);
/* Construct attrib_list as a copy of attrib_listHandle if non-null */
if (!KNI_IsNullHandle(attrib_listHandle)) {
jint attrib_list_length, attrib_list_size;
attrib_list_length = KNI_GetArrayLength(attrib_listHandle);
attrib_list_size = attrib_list_length*sizeof(jint);
attrib_list = (EGLint *)JSR239_malloc(attrib_list_size);
if (!attrib_list) {
KNI_ThrowNew("java.lang.OutOfMemoryException",
"eglCreatePbufferSurface");
goto exit;
}
KNI_GetRawArrayRegion(attrib_listHandle, 0, attrib_list_size,
(jbyte *) attrib_list);
}
#ifdef DEBUG
{
int idx = 0;
int attr;
#ifdef DEBUG
printf("In eglCreatePbufferSurface:\n");
#endif
if (!attrib_list) {
#ifdef DEBUG
printf("attrib_list is null!\n");
#endif
} else {
while (1) {
attr = attrib_list[idx++];
#ifdef DEBUG
printf("attr[%d] = 0x%x\n", idx, attr);
#endif
if (attr == EGL_NONE) {
break;
}
}
}
}
#endif
returnValue = (jint)eglCreatePbufferSurface((EGLDisplay)display,
(EGLConfig)config,
(EGLint const *) attrib_list);
#ifdef DEBUG
if (returnValue > 0) {
++surfaces;
}
printf("eglCreatePbufferSurface(0x%x, 0x%x, attrib_list) = %d, surfaces = %d\n",
display, config, returnValue, surfaces);
{
EGLint error; /* debugging */
error = eglGetError();
if (error != EGL_SUCCESS) {
printf("egl error = 0x%x\n", error);
}
}
#endif
exit:
if (attrib_list) {
JSR239_free(attrib_list);
}
KNI_EndHandles();
KNI_ReturnInt(returnValue);
}
/* private native int _eglGetConfigs ( int display , int [ ] configs , int config_size , int [ ] num_config ) ; */
KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_khronos_egl_EGL10Impl__1eglGetConfigs() {
jint display = KNI_GetParameterAsInt(1);
jint config_size = KNI_GetParameterAsInt(3);
EGLConfig *configs = (EGLConfig *)0;
EGLint num_config = 0;
jint returnValue = EGL_FALSE;
KNI_StartHandles(2);
KNI_DeclareHandle(configsHandle);
KNI_DeclareHandle(num_configHandle);
KNI_GetParameterAsObject(2, configsHandle);
KNI_GetParameterAsObject(4, num_configHandle);
if (!KNI_IsNullHandle(configsHandle)) {
configs = (EGLConfig *)JSR239_malloc(config_size*sizeof(EGLint));
if (!configs) {
KNI_ThrowNew("java.lang.OutOfMemoryException", "eglGetConfigs");
goto exit;
}
}
returnValue = (jint)eglGetConfigs((EGLDisplay)display,
configs,
(EGLint)config_size,
&num_config);
#ifdef DEBUG
printf("num_config = %d\n", num_config);
#endif
#ifdef ALL_WINDOWS_ARE_PIXMAPS
{
EGLBoolean ok;
EGLint surfaceType;
int i, j;
// Remove all configs that are for windows only
if (returnValue && configs) {
for (i = 0; i < num_config; i++) {
ok = eglGetConfigAttrib((EGLDisplay)display, configs[i],
EGL_SURFACE_TYPE, &surfaceType);
if ((surfaceType & (EGL_PIXMAP_BIT | EGL_PBUFFER_BIT)) == 0) {
for (j = i; j < num_config - 1; j++) {
configs[j] = configs[j + 1];
}
configs[--num_config] = 0;
#ifdef DEBUG
printf("Deleting a config, num_config = %d\n", num_config);
#endif
}
}
}
}
#endif
#ifdef DEBUG
printf("eglGetConfigs(0x%x, configs, %d, num_config<-%d) = %d\n",
display, config_size, num_config, returnValue);
#endif
if ((returnValue == EGL_TRUE) && !KNI_IsNullHandle(configsHandle)) {
KNI_SetRawArrayRegion(configsHandle, 0, config_size*sizeof(EGLint),
(const jbyte *)configs);
}
if ((returnValue == EGL_TRUE) && !KNI_IsNullHandle(num_configHandle)) {
KNI_SetIntArrayElement(num_configHandle, 0, num_config);
}
exit:
if (configs) {
JSR239_free(configs);
}
KNI_EndHandles();
KNI_ReturnInt(returnValue);
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
Java_com_sun_j2me_location_PlatformLocationProvider_getCriteria() {
jsr179_provider_info provider_info;
jsr179_result res;
jboolean ret = KNI_FALSE;
KNI_StartHandles(3);
/* get NULL terminated provider name */
KNI_DeclareHandle(criteria);
KNI_DeclareHandle(class_obj);
GET_PARAMETER_AS_PCSL_STRING(1, name)
/* call provider_open to get provider handler */
res = jsr179_provider_getinfo(name, &provider_info);
if (res == JSR179_STATUSCODE_OK) {
KNI_GetParameterAsObject(2, criteria);
KNI_GetObjectClass(criteria, class_obj);
KNI_SetBooleanField(criteria,
locationProviderInfoFieldID.incurCost,
provider_info.incurCost);
KNI_SetBooleanField(criteria,
locationProviderInfoFieldID.canReportAltitude,
provider_info.canReportAltitude);
KNI_SetBooleanField(criteria,
locationProviderInfoFieldID.canReportAddressInfo,
provider_info.canReportAddressInfo);
KNI_SetBooleanField(criteria,
locationProviderInfoFieldID.canReportSpeedCource,
provider_info.canReportSpeedCource);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.powerConsumption,
provider_info.powerConsumption);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.horizontalAccuracy,
provider_info.horizontalAccuracy);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.verticalAccuracy,
provider_info.verticalAccuracy);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.defaultTimeout,
provider_info.defaultTimeout);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.defaultMaxAge,
provider_info.defaultMaxAge);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.defaultInterval,
provider_info.defaultInterval);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.averageResponseTime,
provider_info.averageResponseTime);
KNI_SetIntField(criteria,
locationProviderInfoFieldID.defaultStateInterval,
provider_info.defaultStateInterval);
ret = KNI_TRUE;
} else if (res == JSR179_STATUSCODE_INVALID_ARGUMENT) {
/* wrong provider name */
KNI_ThrowNew(midpIllegalArgumentException, "wrong provider name");
}
RELEASE_PCSL_STRING_PARAMETER
KNI_EndHandles();
KNI_ReturnBoolean(ret);
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_j2me_location_PlatformLocationProvider_open() {
MidpReentryData *info = NULL;
ProviderInfo *pInfo = NULL;
jsr179_result res;
jsr179_handle pProvider = NULL;
jint provider = 0;
KNI_StartHandles(1);
GET_PARAMETER_AS_PCSL_STRING(1, name)
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) {
res = jsr179_provider_open(name, &pProvider);
switch (res) {
case JSR179_STATUSCODE_OK:
/* handler returned immediatelly */
provider = (jint)pProvider;
register_provider(provider);
break;
case JSR179_STATUSCODE_INVALID_ARGUMENT:
/* wrong provider name */
KNI_ThrowNew(midpIllegalArgumentException,
"wrong provider name");
break;
case JSR179_STATUSCODE_FAIL:
/* fail */
KNI_ThrowNew(midpIOException, "open failed");
break;
case JSR179_STATUSCODE_WOULD_BLOCK:
/* wait for javanotify */
provider = (jint)pProvider;
pInfo = register_provider(provider);
if (pInfo != NULL) {
pInfo->locked = KNI_TRUE;
}
lock_thread(JSR179_EVENT_OPEN_COMPLETED, provider);
break;
default:
break;
}
} else {
/* Second call for this thread - finish open */
if (info->status == JSR179_STATUSCODE_OK) {
/* Provider opened successfully */
provider = info->descriptor;
pInfo = getProviderInfo(provider);
if (pInfo != NULL) {
pInfo->locked = KNI_FALSE;
}
} else {
/* Provider open failed*/
unregister_provider(provider);
provider = 0;
}
}
RELEASE_PCSL_STRING_PARAMETER
KNI_EndHandles();
KNI_ReturnInt(provider);
}
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_cldc_io_j2me_socket_Protocol_open0() {
init_sockets();
SocketOpenParameter *p = (SocketOpenParameter*) SNI_GetReentryData(NULL);
if (p == NULL) {
p = (SocketOpenParameter*) SNI_AllocateReentryData(sizeof(*p));
p->fd = -1;
struct hostent *phostent;
KNI_StartHandles(1);
KNI_DeclareHandle(hostname_object);
KNI_GetParameterAsObject(1, hostname_object);
// hostname is always NUL terminated. See socket/Protocol.java for detail.
char *hostname = (char*) SNI_GetRawArrayPointer(hostname_object);
phostent = (struct hostent*)jvm_gethostbyname(hostname);
KNI_EndHandles();
if (phostent == NULL) {
KNI_ReturnInt(-1);
}
struct sockaddr_in destination_sin;
destination_sin.sin_family = AF_INET;
int port = KNI_GetParameterAsInt(2);
destination_sin.sin_port = jvm_htons(port);
jvm_memcpy((char *) &destination_sin.sin_addr, phostent->h_addr,
phostent->h_length);
p->fd = jvm_socket(AF_INET, SOCK_STREAM, 0);
if (p->fd < 0) {
KNI_ReturnInt(-1);
}
if (!set_blocking_flags(&p->fd, /*is_blocking*/ KNI_FALSE)) {
KNI_ReturnInt(-1);
}
if (jvm_connect(p->fd, (struct sockaddr *) &destination_sin,
sizeof(destination_sin)) < 0) {
int err_code = GET_LAST_ERROR();
if (err_code == EINPROGRESS) {
// When the socket is ready for connect, it becomes *writable*
// (according to BSD socket spec of select())
p->check_flags = CHECK_WRITE | CHECK_EXCEPTION;
SNI_BlockThread();
} else {
jvm_shutdown(p->fd, 2);
closesocket(p->fd);
p->fd = -1;
}
}
KNI_ReturnInt(p->fd);
} else {
// When we come to here, a CheckEvent() call has reported one of the
// following:
// [1] connect() has succeeded. In this case we return the socket fd.
// [2] connect() has failed. In this case CheckEvent has already closed
// the socket and set p->fd to -1. So we'd be returning -1.
KNI_ReturnInt(p->fd);
}
}
/**
*
* Resets the request or response flags for listener notification.
* Each request or response is marked as not having been notified.
*
* @param suiteId to match a pending invocation
* @param classname to match a pending invocation
* @param mode one of {@link #MODE_LREQUEST}, {@link #MODE_LRESPONSE}
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_content_InvocationStore_setListenNotify0(void) {
StoredLink* link;
StoredInvoc* invoc;
SuiteIdType desiredSuiteId;
pcsl_string desiredClassname = PCSL_STRING_NULL_INITIALIZER;
KNI_StartHandles(2);
KNI_DeclareHandle(classname); /* Arg2: non-null classname */
int mode; /* Arg3: requested invocation mode */
/* Argument indices must match Java native method declaration */
#define listenSuiteIdArg 1
#define listenClassnameArg 2
#define listenModeArg 3
do {/* Block to break out of on exceptions */
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_setListenNotify0 no memory for [desiredClassname]");
break;
}
/* Get the desired request mode. */
mode = KNI_GetParameterAsInt(listenModeArg);
/* Inspect the queue of Invocations and pick one that
* matches the suiteId and classname
*/
for (link = invocQueue; link != NULL; link = link->flink) {
invoc = link->invoc;
/*
* If the status matches the request
* and the suite matches and the classname matches.
*/
if (mode == MODE_LREQUEST &&
invoc->status == STATUS_INIT) {
/* This invocation is a match; check classname and suite below */
} else if (mode == MODE_LRESPONSE &&
(invoc->status >= STATUS_OK &&
invoc->status <= STATUS_INITIATED)) {
/* A pending response; check classname and suite below */
} else {
/* Not this invocation; on to the next */
continue;
}
/* Check if this is the right class and suite */
if (desiredSuiteId == invoc->suiteId &&
pcsl_string_equals(&desiredClassname, &invoc->classname)) {
/* Reset the flag so this Invocation will notify. */
invoc->notified = KNI_FALSE;
}
}
}
} while (KNI_FALSE);
/* TBD: MidpMalloc failure not reported; not found is returned */
/* Always free strings allocated */
pcsl_string_free(&desiredClassname);
KNI_EndHandles();
KNI_ReturnVoid();
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
Java_com_sun_j2me_location_PlatformLocationProvider_waitForNewLocation() {
jboolean ret = KNI_FALSE;
MidpReentryData *info = NULL;
ProviderInfo *pInfo = NULL;
jsr179_result res;
jint provider;
jlong timeout;
KNI_StartHandles(1);
provider = KNI_GetParameterAsInt(1);
timeout = KNI_GetParameterAsLong(2);
pInfo = getProviderInfo(provider);
if(pInfo != NULL) {
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) {
/* First call -request */
if(pInfo->locked == KNI_TRUE) {
lock_thread(JSR179_EVENT_UPDATE_ONCE, provider);
} else {
/* request new location */
res = jsr179_update_set((jsr179_handle)provider, timeout);
switch (res) {
case JSR179_STATUSCODE_WOULD_BLOCK:
/* wait for javanotify */
pInfo->locked = KNI_TRUE;
lock_thread(JSR179_EVENT_UPDATE_ONCE, provider);
break;
case JSR179_STATUSCODE_OK:
/* location updated successfully */
pInfo->locked = KNI_FALSE;
pInfo->newLocationAvailable = KNI_TRUE;
ret = KNI_TRUE;
break;
case JSR179_STATUSCODE_FAIL:
/* fail */
pInfo->locked = KNI_FALSE;
/* wrong provider name */
KNI_ThrowNew(midpIllegalArgumentException,
"wrong provider");
break;
default:
/* fail */
pInfo->locked = KNI_FALSE;
break;
}
}
} else {
/* Response */
if (info->status == JSR179_STATUSCODE_OK) {
/* location updated successfully */
pInfo->newLocationAvailable = KNI_TRUE;
ret = KNI_TRUE;
} else {
/* location updated failed */
ret = KNI_FALSE;
}
pInfo->locked = KNI_FALSE;
}
}
KNI_EndHandles();
KNI_ReturnBoolean(ret);
}
/*
* Accepts incoming client connection request.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>BTSPPNotifierImpl</code> object.
*
* Note: new native connection handle to work with accepted incoming
* client connection is setted directly to <code>handle</code> field of
* appropriate <code>RFCOMMConnectionImpl</code> object.
*
* @throws IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_jsr082_bluetooth_btspp_BTSPPNotifierImpl_accept0(void) {
javacall_handle handle = JAVACALL_BT_INVALID_HANDLE;
javacall_handle peer_handle = JAVACALL_BT_INVALID_HANDLE;
MidpReentryData* info;
int status = JAVACALL_FAIL;
int processStatus = KNI_FALSE;
void *context = NULL;
javacall_bt_address peer_addr;
jfieldID notifHandleID = NULL;
jfieldID peerHandleID = NULL;
jfieldID peerAddrID = NULL;
jfieldID pushHandleID = NULL;
KNI_StartHandles(3);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(arrayHandle);
KNI_DeclareHandle(classHandle);
KNI_GetClassPointer(classHandle);
GET_FIELDID(classHandle, "handle", "I", notifHandleID)
GET_FIELDID(classHandle, "peerHandle", "I", peerHandleID)
GET_FIELDID(classHandle, "peerAddress", "[B", peerAddrID)
GET_FIELDID(classHandle, "pushHandle", "I", pushHandleID)
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, notifHandleID);
KNI_GetObjectField(thisHandle, peerAddrID, arrayHandle);
if (handle == JAVACALL_BT_INVALID_HANDLE) {
REPORT_ERROR(LC_PROTOCOL,
"RFCOMM notifier was closed before btspp_notif::accept");
KNI_ThrowNew(midpInterruptedIOException, EXCEPTION_MSG(
"RFCOMM notifier was closed"));
} else {
#ifndef NO_PUSH
bt_pushid_t pushid = KNI_GetIntField(thisHandle, pushHandleID);
if (pushid != BT_INVALID_PUSH_HANDLE) {
if (bt_push_checkout_client(pushid, &peer_handle, peer_addr,
NULL, NULL) == JAVACALL_OK) {
pushcheckoutaccept((int)handle);
processStatus = KNI_TRUE;
status = JAVACALL_OK;
}
}
#endif
if (peer_handle == JAVACALL_BT_INVALID_HANDLE) {
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) { /* First invocation */
REPORT_INFO1(LC_PROTOCOL,
"btspp_notif::accept handle=%d\n", handle);
// Need revisit: add resource counting
/*
* An incoming socket connection counts against the client socket
* resource limit.
*/
/*
if (midpCheckResourceLimit(RSC_TYPE_BT_CLI, 1) == 0) {
const char* pMsg =
"Resource limit exceeded for BT client sockets";
REPORT_INFO(LC_PROTOCOL, pMsg);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg));
*/
// } else {
status = javacall_bt_rfcomm_accept(
handle, &peer_handle, &peer_addr);
processStatus = KNI_TRUE;
// }
} else { /* Reinvocation after unblocking the thread */
if ((javacall_handle)info->descriptor != handle) {
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"btspp_notif::accept handles mismatched %d != %d\n",
handle, info->descriptor);
REPORT_CRIT(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpIllegalStateException, EXCEPTION_MSG(
"Internal error in btspp_notif::accept"));
} else {
// Need revisit: add resource counting
/*
if (midpCheckResourceLimit(RSC_TYPE_BT_CLI, 1) == 0) {
const char* pMsg =
"Resource limit exceeded for BT client sockets"
REPORT_INFO(LC_PROTOCOL, pMsg);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg));
} else {
*/
context = info->pResult;
status = javacall_bt_rfcomm_accept(
handle, &peer_handle, &peer_addr);
processStatus = KNI_TRUE;
// }
}
}
}
if (processStatus) {
REPORT_INFO1(LC_PROTOCOL,
"btspp_notif::accept server handle=%d\n", handle);
if (status == JAVACALL_OK) {
// Need revisit: add resource counting
/*
if (midpIncResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL,
"btspp_notif: Resource limit update error");
}
*/
// store client native connection handle for temporary storing
KNI_SetIntField(thisHandle, peerHandleID, (jint)peer_handle);
// copy address to Java object field
KNI_SetRawArrayRegion(arrayHandle, 0, JAVACALL_BT_ADDRESS_SIZE, (jbyte*) peer_addr);
REPORT_INFO(LC_PROTOCOL,
"btspp_notif::accept incoming connection accepted!");
} else if (status == JAVACALL_WOULD_BLOCK) {
midp_thread_wait(NETWORK_READ_SIGNAL, (int)handle, context);
} else if (status == JAVACALL_FAIL) {
char* pError;
javacall_bt_rfcomm_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IO error in btspp_notif::accept (%s)\n", pError);
REPORT_INFO(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(gKNIBuffer));
} else {
char* pMsg = "Unknown error during btspp_notif::accept";
REPORT_INFO(LC_PROTOCOL, pMsg);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg));
}
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* private native int _eglChooseConfig ( int display , int [ ] attrib_list , int [ ] configs , int config_size , int [ ] num_config ) ; */
KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_khronos_egl_EGL10Impl__1eglChooseConfig() {
jint display = KNI_GetParameterAsInt(1);
jint config_size = KNI_GetParameterAsInt(4);
EGLint *attrib_list = (EGLint *)0;
EGLConfig *configs = (EGLConfig *)0;
EGLint num_config;
jint returnValue = EGL_FALSE;
KNI_StartHandles(3);
KNI_DeclareHandle(attrib_listHandle);
KNI_DeclareHandle(configsHandle);
KNI_DeclareHandle(num_configHandle);
KNI_GetParameterAsObject(2, attrib_listHandle);
KNI_GetParameterAsObject(3, configsHandle);
KNI_GetParameterAsObject(5, num_configHandle);
if (!KNI_IsNullHandle(attrib_listHandle)) {
jint attrib_list_length, attrib_list_size;
/* Construct attrib_list as a copy of attrib_listHandle */
attrib_list_length = KNI_GetArrayLength(attrib_listHandle);
attrib_list_size = (attrib_list_length + 2)*sizeof(jint);
attrib_list = (EGLint *)JSR239_malloc(attrib_list_size);
if (!attrib_list) {
KNI_ThrowNew("java.lang.OutOfMemoryException", "eglChooseConfig");
goto exit;
}
KNI_GetRawArrayRegion(attrib_listHandle, 0, attrib_list_size,
(jbyte *)attrib_list);
}
#ifdef ALL_WINDOWS_ARE_PIXMAPS
// Force queries with SURFACE_TYPE == WINDOW to actually query pixmap
if (attrib_list) {
jint attr, val, idx;
idx = 0;
while (1) {
attr = attrib_list[idx];
#ifdef DEBUG
printf("attr[%d] = %d\n", idx, attr);
#endif
if (attr == EGL_NONE) {
#ifdef DEBUG
printf("attr = EGL_NONE, done\n");
#endif
break;
}
if (attr == EGL_SURFACE_TYPE) {
#ifdef DEBUG
printf("attr = EGL_SURFACE_TYPE\n");
#endif
val = attrib_list[idx + 1];
if ((val & EGL_WINDOW_BIT) != 0) {
#ifdef DEBUG
printf("Switching WINDOW_BIT to PIXMAP_BIT\n");
#endif
val |= EGL_PIXMAP_BIT;
val &= ~EGL_WINDOW_BIT;
}
}
idx += 2;
}
}
#endif
/* Allocate config_size elements if configsHandle is non-null */
if (!KNI_IsNullHandle(configsHandle)) {
configs = (EGLConfig *)JSR239_malloc(config_size*sizeof(EGLint));
if (!configs) {
KNI_ThrowNew("java.lang.OutOfMemoryException", "eglChooseConfig");
goto exit;
}
}
returnValue = (jint)eglChooseConfig((EGLDisplay)display, attrib_list,
configs, config_size, &num_config);
#ifdef DEBUG
printf("eglChooseConfig(0x%x, attrib_list, configs, %d, num_config<-%d) = %d\n",
display, config_size, num_config, returnValue);
#endif
/* Copy configs back to Java */
if (returnValue == EGL_TRUE && !KNI_IsNullHandle(configsHandle)) {
KNI_SetRawArrayRegion(configsHandle, 0, config_size*sizeof(EGLint),
(const jbyte *)configs);
}
/* Set output parameter via num_configHandle */
if ((returnValue == EGL_TRUE) && !KNI_IsNullHandle(num_configHandle)) {
KNI_SetIntArrayElement(num_configHandle, 0, num_config);
}
exit:
if (attrib_list) {
JSR239_free(attrib_list);
}
if (configs) {
JSR239_free(configs);
}
KNI_EndHandles();
KNI_ReturnInt(returnValue);
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_j2me_location_LocationInfo_initNativeClass() {
KNI_StartHandles(1);
KNI_DeclareHandle(class_obj);
KNI_GetClassPointer(class_obj);
if(!KNI_IsNullHandle(class_obj)) {
locationInfoFieldID.isValid =
KNI_GetFieldID(class_obj, "isValid", "Z");
locationInfoFieldID.timestamp =
KNI_GetFieldID(class_obj, "timestamp", "J");
locationInfoFieldID.latitude =
KNI_GetFieldID(class_obj, "latitude", "D");
locationInfoFieldID.longitude =
KNI_GetFieldID(class_obj, "longitude", "D");
locationInfoFieldID.altitude =
KNI_GetFieldID(class_obj, "altitude", "F");
locationInfoFieldID.horizontalAccuracy =
KNI_GetFieldID(class_obj, "horizontalAccuracy", "F");
locationInfoFieldID.verticalAccuracy =
KNI_GetFieldID(class_obj, "verticalAccuracy", "F");
locationInfoFieldID.speed =
KNI_GetFieldID(class_obj, "speed", "F");
locationInfoFieldID.course =
KNI_GetFieldID(class_obj, "course", "F");
locationInfoFieldID.method =
KNI_GetFieldID(class_obj, "method", "I");
locationInfoFieldID.isAddressInfo =
KNI_GetFieldID(class_obj, "isAddressInfo", "Z");
locationInfoFieldID.AddressInfo_EXTENSION =
KNI_GetFieldID(class_obj,
"AddressInfo_EXTENSION", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_STREET =
KNI_GetFieldID(class_obj,
"AddressInfo_STREET", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_POSTAL_CODE =
KNI_GetFieldID(class_obj,
"AddressInfo_POSTAL_CODE", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_CITY =
KNI_GetFieldID(class_obj,
"AddressInfo_CITY", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_COUNTY =
KNI_GetFieldID(class_obj,
"AddressInfo_COUNTY", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_STATE =
KNI_GetFieldID(class_obj,
"AddressInfo_STATE", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_COUNTRY =
KNI_GetFieldID(class_obj,
"AddressInfo_COUNTRY", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_COUNTRY_CODE =
KNI_GetFieldID(class_obj,
"AddressInfo_COUNTRY_CODE", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_DISTRICT =
KNI_GetFieldID(class_obj,
"AddressInfo_DISTRICT", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_BUILDING_NAME =
KNI_GetFieldID(class_obj,
"AddressInfo_BUILDING_NAME", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_BUILDING_FLOOR =
KNI_GetFieldID(class_obj,
"AddressInfo_BUILDING_FLOOR", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_BUILDING_ROOM =
KNI_GetFieldID(class_obj,
"AddressInfo_BUILDING_ROOM", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_BUILDING_ZONE =
KNI_GetFieldID(class_obj,
"AddressInfo_BUILDING_ZONE", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_CROSSING1 =
KNI_GetFieldID(class_obj,
"AddressInfo_CROSSING1", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_CROSSING2 =
KNI_GetFieldID(class_obj,
"AddressInfo_CROSSING2", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_URL =
KNI_GetFieldID(class_obj,
"AddressInfo_URL", "Ljava/lang/String;");
locationInfoFieldID.AddressInfo_PHONE_NUMBER =
KNI_GetFieldID(class_obj,
"AddressInfo_PHONE_NUMBER", "Ljava/lang/String;");
locationInfoFieldID.extraInfoNMEA =
KNI_GetFieldID(class_obj, "extraInfoNMEA", "Ljava/lang/String;");
locationInfoFieldID.extraInfoLIF =
KNI_GetFieldID(class_obj, "extraInfoLIF", "Ljava/lang/String;");
locationInfoFieldID.extraInfoPlain =
KNI_GetFieldID(class_obj, "extraInfoPlain", "Ljava/lang/String;");
locationInfoFieldID.extraInfoOther =
KNI_GetFieldID(class_obj, "extraInfoOther", "Ljava/lang/String;");
locationInfoFieldID.extraInfoOtherMIMEType =
KNI_GetFieldID(class_obj, "extraInfoOtherMIMEType", "Ljava/lang/String;");
} else {
KNI_ThrowNew(midpNullPointerException, NULL);
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* private native int _eglCopyBuffers ( int display , int surface , Graphics target ) ; */
KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_khronos_egl_EGL10Impl__1eglCopyBuffers() {
EGLDisplay display = (EGLDisplay) KNI_GetParameterAsInt(1);
EGLSurface surface = (EGLSurface) KNI_GetParameterAsInt(2);
jint width = KNI_GetParameterAsInt(4);
jint height = KNI_GetParameterAsInt(5);
jint delta_height = KNI_GetParameterAsInt(6);
jint clipX = KNI_GetParameterAsInt(7);
jint clipY = KNI_GetParameterAsInt(8);
jint clipWidth = KNI_GetParameterAsInt(9);
jint clipHeight = KNI_GetParameterAsInt(10);
JSR239_Pixmap* pixmap;
// eglCopyBuffers copies the EGL surface color buffer to a native pixmap.
// As the native pixmaps the Graphics opbject are used. Thus eglCopyBuffers
// can not be used as the destination buffer can be of a different size as
// the source surface. In these case call to eglCopyBuffers may lead to
// the memory corruption.
// Of course it is more efficient ot use eglCopyBuffers instead of workaround
// with glReadPixels, but we should do additional checks to do it safely.
// Let glReadPixels return the data in the following format:
const jint bytesPerPixel = 4;
// for data type for glReadPixels we use GL_UNSIGNED_BYTE, one
// byte for each component
const jint alphaSize = 8;
const jint redSize = 8;
const jint greenSize = 8;
const jint blueSize = 8;
KNI_StartHandles(1);
KNI_DeclareHandle(graphicsHandle);
KNI_GetParameterAsObject(3, graphicsHandle);
pixmap = JSR239_getImagePixmap(graphicsHandle, width, height,
bytesPerPixel,
alphaSize, redSize, greenSize, blueSize);
if (!pixmap) {
KNI_ThrowNew("java.lang.OutOfMemoryException", "eglCopyBuffers");
goto exit;
}
// Enforce RGBA order of glReadPixels
pixmap->aOffset = redSize + greenSize + blueSize;
pixmap->bOffset = greenSize + blueSize;
pixmap->gOffset = blueSize;
pixmap->rOffset = 0;
eglCopyBuffersWorkaround((EGLDisplay)display, (EGLSurface)surface, pixmap);
// glReadPixels returns pixel data from the color buffer, starting with the
// pixel whose lower left corner is at location (x, y), into client memory
// starting at location pixels. Thus we should flip the data returned by
// glReadPixels
JSR239_putWindowContents(graphicsHandle, delta_height,
pixmap,
clipX, clipY, clipWidth, clipHeight,
1 /*should do flip*/);
JSR239_destroyPixmap(pixmap);
exit:
KNI_EndHandles();
KNI_ReturnInt(EGL_TRUE);
}
/**
*
* 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);
}
