/**
* Force Bluetooth stack to listen for incoming client connections.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>L2CAPNotifierImpl</code> object.
*
* @throws IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_btl2cap_L2CAPNotifierImpl_listen0(void) {
javacall_handle handle = BT_INVALID_HANDLE;
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::listen");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
if (KNI_GetIntField(thisHandle, pushHandleID) == BT_INVALID_PUSH_HANDLE) {
handle = (javacall_handle)KNI_GetIntField(thisHandle, notifHandleID);
/* force listening */
if (javacall_bt_l2cap_listen(handle) == JAVACALL_FAIL) {
javacall_bt_l2cap_close(handle);
REPORT_ERROR(LC_PROTOCOL,
"L2CAP notifier listen failed in btl2cap_notif::listen");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("L2CAP notifier listen failed"));
} else {
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::listen done!");
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Force Bluetooth stack to listen for incoming client connections.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>BTSPPNotifierImpl</code> object.
*
* @throws IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_btspp_BTSPPNotifierImpl_listen0(void) {
bt_handle_t handle = BT_INVALID_HANDLE;
REPORT_INFO(LC_PROTOCOL, "btspp_notif::listen");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
if (KNI_GetIntField(thisHandle, pushHandleID) == BT_INVALID_PUSH_HANDLE) {
handle = (bt_handle_t)KNI_GetIntField(thisHandle, notifHandleID);
/* force listening */
if (bt_rfcomm_listen(handle) == BT_RESULT_FAILURE) {
bt_rfcomm_close(handle);
REPORT_ERROR(LC_PROTOCOL,
"RFCOMM notifier listen failed in btspp_notif::listen");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("RFCOMM notifier listen failed"));
} else {
REPORT_INFO(LC_PROTOCOL, "btspp_notif::listen done!");
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Closes this server connection.
* Releases all native resources (such as sockets) owned by this notifier.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>L2CAPNotifierImpl</code> object.
*
* @throws IOException IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_btl2cap_L2CAPNotifierImpl_close0(void) {
javacall_handle handle, peer;
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::close");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, notifHandleID);
if (handle != BT_INVALID_HANDLE) {
if (javacall_bt_l2cap_close(handle) == JAVACALL_FAIL) {
REPORT_ERROR(LC_PROTOCOL,
"Notifier handle closing failed in btl2cap_notif::close");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("L2CAP notifier closing failed"));
} else {
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_SER, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
}
KNI_SetIntField(thisHandle, notifHandleID, (jint)BT_INVALID_HANDLE);
}
peer = (javacall_handle)KNI_GetIntField(thisHandle, peerHandleID);
if (peer != BT_INVALID_HANDLE) {
if (javacall_bt_l2cap_close(peer) == JAVACALL_FAIL) {
REPORT_ERROR(LC_PROTOCOL,
"Peer handle closing failed in btl2cap_notif::close");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("L2CAP notifier closing failed"));
} else {
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
}
KNI_SetIntField(thisHandle, peerHandleID, (jint)BT_INVALID_HANDLE);
}
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::close done!");
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Sends a native event a given Isolate.
*
* @param event A event to queued
* @param isolateId ID of the target Isolate
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_events_EventQueue_sendNativeEventToIsolate(void) {
MidpEvent event;
jint isolateId;
int noExceptions = 0;
MIDP_EVENT_INITIALIZE(event);
KNI_StartHandles(3);
KNI_DeclareHandle(eventObj);
KNI_DeclareHandle(stringObj);
KNI_DeclareHandle(classObj);
KNI_GetParameterAsObject(1, eventObj);
isolateId = KNI_GetParameterAsInt(2);
cacheEventFieldIDs(eventObj, classObj);
event.type = KNI_GetIntField(eventObj, typeFieldID);
event.intParam1 = KNI_GetIntField(eventObj, intParam1FieldID);
event.intParam2 = KNI_GetIntField(eventObj, intParam2FieldID);
event.intParam3 = KNI_GetIntField(eventObj, intParam3FieldID);
event.intParam4 = KNI_GetIntField(eventObj, intParam4FieldID);
do {
GET_STRING_EVENT_FIELD(eventObj, stringParam1FieldID, stringObj,
event.stringParam1);
GET_STRING_EVENT_FIELD(eventObj, stringParam2FieldID, stringObj,
event.stringParam2);
GET_STRING_EVENT_FIELD(eventObj, stringParam3FieldID, stringObj,
event.stringParam3);
GET_STRING_EVENT_FIELD(eventObj, stringParam4FieldID, stringObj,
event.stringParam4);
GET_STRING_EVENT_FIELD(eventObj, stringParam5FieldID, stringObj,
event.stringParam5);
GET_STRING_EVENT_FIELD(eventObj, stringParam6FieldID, stringObj,
event.stringParam6);
noExceptions = 1;
} while (0);
KNI_EndHandles();
if (noExceptions) {
StoreMIDPEventInVmThread(event, isolateId);
} else {
freeMIDPEventFields(event);
}
KNI_ReturnVoid();
}
/**
* Closes this server connection.
* Releases all native resources (such as sockets) owned by this notifier.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>BTSPPNotifierImpl</code> object.
*
* @throws IOException IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_btspp_BTSPPNotifierImpl_close0(void) {
bt_handle_t handle, peer;
REPORT_INFO(LC_PROTOCOL, "btspp_notif::close0");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
handle = (bt_handle_t)KNI_GetIntField(thisHandle, notifHandleID);
if (handle != BT_INVALID_HANDLE) {
if (bt_rfcomm_close(handle) == BT_RESULT_FAILURE) {
REPORT_ERROR(LC_PROTOCOL,
"Notifier handle closing failed in btspp_notif::close");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("RFCOMM notifier closing failed"));
} else {
// IMPL_NOTE: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_SER, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
}
KNI_SetIntField(thisHandle, notifHandleID, (jint)BT_INVALID_HANDLE);
}
peer = (bt_handle_t)KNI_GetIntField(thisHandle, peerHandleID);
if (peer != BT_INVALID_HANDLE) {
if (bt_rfcomm_close(peer) == BT_RESULT_FAILURE) {
REPORT_ERROR(LC_PROTOCOL,
"Peer handle closing failed in btspp_notif::close");
KNI_ThrowNew(midpIOException,
EXCEPTION_MSG("RFCOMM notifier closing failed"));
} else {
// IMPL_NOTE: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
}
KNI_SetIntField(thisHandle, peerHandleID, (jint)BT_INVALID_HANDLE);
}
REPORT_INFO(LC_PROTOCOL, "btspp_notif::close0 done!");
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Native method void finalize of
* com.sun.midp.midletsuite.MIDletSuiteImpl.
* <p>
*
* native finalizer
*
*/
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_midp_midletsuite_MIDletSuiteImpl_finalize) {
SuiteIdType suiteId;
jboolean locked;
KNI_StartHandles(2);
KNI_DeclareHandle(object);
KNI_DeclareHandle(clazz);
KNI_GetThisPointer(object);
KNI_GetObjectClass(object, clazz);
locked = KNI_GetBooleanField(object,
midp_get_field_id(KNIPASSARGS clazz, "locked", "Z"));
if (locked) {
suiteId = KNI_GetIntField(object,
midp_get_field_id(KNIPASSARGS clazz, "id", "I"));
unlock_storage(suiteId);
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Updates the parameters of the invocation in the native store.
* The ID, URL, Type, arguments, and data are stored again in native.
* The key into the native store is the TID;
*
* @param invoc the InvocationImpl to update the native params
* @see StoredInvoc
* @see #invocQueue
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_content_InvocationStore_setParams0(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;
if (KNI_TRUE != setParamsFromObj(invoc, invocObj, obj1, obj2)) {
KNI_ThrowNew(midpOutOfMemoryError,
"invocStore.c: setParam0() allocation failed");
}
} else {
#if REPORT_LEVEL <= LOG_CRITICAL
REPORT_CRIT(LC_NONE,
"invocStore.c: setParam0() no entry for tid");
#endif
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/*
* Closes client connection.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>RFCOMMConnectionImpl</code> object.
*
* @throws IOException if any I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_jsr082_bluetooth_btspp_BTSPPConnectionImpl_close0) {
javacall_handle handle;
REPORT_INFO(LC_PROTOCOL, "btspp::close");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, connHandleID);
if (handle != JAVACALL_BT_INVALID_HANDLE) {
if (javacall_bt_rfcomm_close(handle) == JAVACALL_FAIL) {
REPORT_ERROR(LC_PROTOCOL,
"RFCOMM connection closing failed in btspp::close");
KNI_ThrowNew(jsropIOException,
EXCEPTION_MSG("RFCOMM connection closing failed"));
} else {
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
}
KNI_SetIntField(thisHandle, connHandleID, (jint)JAVACALL_BT_INVALID_HANDLE);
}
REPORT_INFO(LC_PROTOCOL, "btspp::close done!");
KNI_EndHandles();
KNI_ReturnVoid();
}
/*
* Returns the number of bytes available to be read from the connection
* without blocking.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>BTSPPConnectionImpl</code> object.
*
* @return the number of available bytes
* @throws IOException if any I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_jsr082_bluetooth_btspp_BTSPPConnectionImpl_available0) {
javacall_handle handle;
int count = -1;
char* pError;
REPORT_INFO(LC_PROTOCOL, "btspp::available");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, connHandleID);
switch (javacall_bt_rfcomm_get_available(handle, &count)) {
case JAVACALL_OK:
REPORT_INFO(LC_PROTOCOL, "btspp::available done!");
break;
case JAVACALL_FAIL:
javacall_bt_rfcomm_get_error(handle, &pError);
JAVAME_SNPRINTF(gBtBuffer, BT_BUFFER_SIZE,
"IO error during btspp::::available (%s)", pError);
REPORT_ERROR(LC_PROTOCOL, gBtBuffer);
KNI_ThrowNew(jsropIOException, EXCEPTION_MSG(gBtBuffer));
break;
default: /* illegal argument */
REPORT_ERROR(LC_PROTOCOL, "Internal error in btspp::available");
}
KNI_EndHandles();
KNI_ReturnInt(count);
}
static void sendControlIntField(kjobject objectHandle, jfieldID fieldID) {
int n = KNI_GetIntField(objectHandle, fieldID);
write(controlPipe[1], &n, sizeof(int));
#ifdef CVM_DEBUG
printf("%d ", n);
#endif
}
static void
getRange(jobject linkMessageObj, int *offset, int *length)
{
jfieldID offsetField;
jfieldID lengthField;
KNI_StartHandles(1);
KNI_DeclareHandle(linkMessageClass);
KNI_GetObjectClass(linkMessageObj, linkMessageClass);
offsetField = KNI_GetFieldID(linkMessageClass, "offset", "I");
lengthField = KNI_GetFieldID(linkMessageClass, "length", "I");
*offset = KNI_GetIntField(linkMessageObj, offsetField);
*length = KNI_GetIntField(linkMessageObj, lengthField);
KNI_EndHandles();
}
/*
* Native finalizer.
* Releases all native resources used by this connection.
*/
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_jsr082_bluetooth_btspp_BTSPPConnectionImpl_finalize) {
javacall_handle handle;
int status = JAVACALL_FAIL;
REPORT_INFO(LC_PROTOCOL, "btspp::finalize");
KNI_StartHandles(2);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(classHandle);
KNI_GetThisPointer(thisHandle);
KNI_GetClassPointer(classHandle);
GET_FIELDID(classHandle, "handle", "I", connHandleID)
handle = (javacall_handle)KNI_GetIntField(thisHandle, connHandleID);
if (handle != JAVACALL_BT_INVALID_HANDLE) {
status = javacall_bt_rfcomm_close(handle);
KNI_SetIntField(thisHandle, connHandleID, (jint)JAVACALL_BT_INVALID_HANDLE);
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
if (status == JAVACALL_FAIL) {
char* pError;
javacall_bt_rfcomm_get_error(handle, &pError);
JAVAME_SNPRINTF(gBtBuffer, BT_BUFFER_SIZE,
"IO error in btspp::finalize (%s)\n", pError);
REPORT_ERROR(LC_PROTOCOL, gBtBuffer);
} else if (status == JAVACALL_WOULD_BLOCK) {
/* blocking during finalize is not supported */
REPORT_ERROR1(LC_PROTOCOL,
"btspp::finalize blocked, handle= %d\n", handle);
}
}
// Need revisit: add bluetooth activity indicator
/* FINISH_BT_INDICATOR; */
REPORT_INFO(LC_PROTOCOL, "btspp::finalize done!");
KNI_EndHandles();
KNI_ReturnVoid();
}
static rendezvous *
getNativePointer(jobject linkObj)
{
rendezvous *rp;
jfieldID nativePointerField;
KNI_StartHandles(1);
KNI_DeclareHandle(linkClass);
KNI_GetObjectClass(linkObj, linkClass);
nativePointerField = KNI_GetFieldID(linkClass, "nativePointer", "I");
rp = (rendezvous *)KNI_GetIntField(linkObj, nativePointerField);
KNI_EndHandles();
return rp;
}
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(KNITest_testGetSetIntField) {
jint x = KNI_GetParameterAsInt(1);
jint y;
jfieldID typeFieldID;
KNI_StartHandles(2);
KNI_DeclareHandle(this);
KNI_DeclareHandle(clazz);
KNI_GetThisPointer(this);
KNI_GetObjectClass(this, clazz);
typeFieldID = KNI_GetFieldID(clazz, "i", "I");
y = KNI_GetIntField(this, typeFieldID);
KNI_SetIntField(this, typeFieldID, x*y);
KNI_EndHandles();
KNI_ReturnVoid();
}
/*
* Retrieves native connection handle from temporary storage
* inside <code>RFCOMMNotifierImpl</code> instance
* and sets it to this <code>RFCOMMConnectionImpl</code> instance.
*
* Note: the method sets native connection handle directly to
* <code>handle<code> field of <code>RFCOMMConnectionImpl</code> object.
*
* @param notif reference to corresponding <code>RFCOMMNotifierImpl</code>
* instance storing native peer handle
*/
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_jsr082_bluetooth_btspp_BTSPPConnectionImpl_setThisConnHandle0) {
REPORT_INFO(LC_PROTOCOL, "btspp::setThisConnHandle");
KNI_StartHandles(2);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(notifHandle);
KNI_GetThisPointer(thisHandle);
KNI_GetParameterAsObject(1, notifHandle);
if (KNI_IsNullHandle(notifHandle)) {
REPORT_ERROR(LC_PROTOCOL,
"Notifier handle is null in btspp::setThisConnHandle");
} else {
jfieldID peerHandleID = GetRFCOMMPeerHandleID();
if (peerHandleID == NULL) {
REPORT_ERROR(LC_PROTOCOL,
"Peer handle ID is not initialized"
"in btspp::setThisConnHandle");
} else {
javacall_handle handle =
(javacall_handle)KNI_GetIntField(notifHandle, peerHandleID);
if (handle != JAVACALL_BT_INVALID_HANDLE) {
/* store native connection handle to Java */
KNI_SetIntField(thisHandle, connHandleID, (jint)handle);
/* reset temporary storing field */
KNI_SetIntField(notifHandle,
peerHandleID, (jint)JAVACALL_BT_INVALID_HANDLE);
REPORT_INFO(LC_PROTOCOL, "btspp::setThisConnHandle done!");
} else {
REPORT_ERROR(LC_PROTOCOL,
"Peer handle is invalid in btspp::setThisConnHandle");
}
}
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_VOID
KNIDECL(com_sun_j2me_location_LocationPersistentStorage_updateLandmarkImpl) {
jint landmarkID;
javacall_result res;
javacall_landmarkstore_landmark *landmark;
jint numAddressFields;
KNI_StartHandles(3);
KNI_DeclareHandle(landmarkObj);
KNI_DeclareHandle(stringObj);
GET_PARAMETER_AS_UTF16_STRING(1, storeName)
landmarkID = KNI_GetParameterAsInt(2);
KNI_GetParameterAsObject(3, landmarkObj);
numAddressFields = KNI_GetIntField(landmarkObj,
landmarkImplFieldID.numAddressInfoFields);
landmark = JAVAME_MALLOC(SIZE_OF_LANDMARK_INFO(numAddressFields));
if (landmark != NULL) {
if (fill_landmark(landmarkObj, landmark, stringObj) == KNI_TRUE) {
res = javacall_landmarkstore_landmark_update(storeName,
(javacall_handle)landmarkID, landmark);
switch (res) {
case JAVACALL_OK:
/* Landmark updated successfully */
break;
case JAVACALL_INVALID_ARGUMENT:
/* wrong landmark ID */
KNI_ThrowNew(jsropIllegalArgumentException,
"Landmark does not belong to this store");
break;
default:
/* operation Failed */
KNI_ThrowNew(jsropIOException, "I/O error");
break;
}
}
JAVAME_FREE(landmark);
}
RELEASE_UTF16_STRING_PARAMETER
KNI_EndHandles();
KNI_ReturnVoid();
}
/**
* Native finalizer.
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_comm_Protocol_finalize()
{
int hPort;
KNI_StartHandles(2);
KNI_DeclareHandle(instance);
KNI_DeclareHandle(clazz);
KNI_GetThisPointer(instance);
KNI_GetObjectClass(instance, clazz);
hPort = KNI_GetIntField(instance, KNI_GetFieldID(clazz, "handle", "I"));
if (hPort != -1) {
REPORT_INFO1(LC_PROTOCOL, "closePort(1st) >> hPort=%d\n",hPort);
closePort(hPort);
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_j2me_location_PlatformLocationProvider_finalize() {
jint provider;
KNI_StartHandles(2);
KNI_DeclareHandle(this_obj);
KNI_DeclareHandle(class_obj);
KNI_GetThisPointer(this_obj);
KNI_GetObjectClass(this_obj, class_obj);
provider = KNI_GetIntField(this_obj,
KNI_GetFieldID(class_obj, "provider", "I"));
if (unregister_provider(provider) == KNI_TRUE) {
jsr179_provider_close((jsr179_handle)provider);
}
KNI_EndHandles();
KNI_ReturnVoid();
}
/* JAVADOC COMMENT ELIDED */
KNIEXPORT KNI_RETURNTYPE_INT
KNIDECL(com_sun_j2me_location_LocationPersistentStorage_addLandmarkToStoreImpl) {
javacall_handle landmarkID = 0;
javacall_result res;
javacall_utf16_string categoryName = NULL;
javacall_landmarkstore_landmark *landmark;
jint numAddressFields;
KNI_StartHandles(3);
KNI_DeclareHandle(landmarkObj);
KNI_DeclareHandle(stringObj);
GET_PARAMETER_AS_UTF16_STRING(1, storeName)
KNI_GetParameterAsObject(2, landmarkObj);
/* CategoryName can be NULL -> check it and extract */
KNI_GetParameterAsObject(3, stringObj);
if (!KNI_IsNullHandle(stringObj)) {
if (JAVACALL_OK !=
jsrop_jstring_to_utf16_string(stringObj, &categoryName)) {
categoryName = NULL;
}
}
numAddressFields = KNI_GetIntField(landmarkObj,
landmarkImplFieldID.numAddressInfoFields);
landmark = JAVAME_MALLOC(SIZE_OF_LANDMARK_INFO(numAddressFields));
if (landmark != NULL) {
if ( fill_landmark(landmarkObj, landmark, stringObj) == KNI_TRUE ) {
res = javacall_landmarkstore_landmark_add_to_landmarkstore(storeName,
landmark, categoryName, &landmarkID);
switch (res) {
case JAVACALL_OK:
/* Category added successfully */
break;
case JAVACALL_INVALID_ARGUMENT:
/* wrong category name */
KNI_ThrowNew(jsropIllegalArgumentException,
"category name is invalid");
break;
default:
/* operation Failed */
KNI_ThrowNew(jsropIOException, "I/O error");
break;
}
} else {
KNI_ThrowNew(jsropIllegalArgumentException,
"landmark name is too long");
}
JAVAME_FREE(landmark);
}
if (categoryName != NULL) {
JAVAME_FREE(categoryName);
}
RELEASE_UTF16_STRING_PARAMETER
KNI_EndHandles();
KNI_ReturnInt((jint)landmarkID);
}
/**
* Fills <code>JSR211_content_handler</code> structure with data from
* <code>ContentHandlerImpl</code> object.
* <BR>Fields <code>ID, storageId</code> and <code>classname</code>
* are mandatory. They must have not 0 length.
*
* @param o <code>ContentHandlerImpl</code> object
* @param handler pointer on <code>JSR211_content_handler</code> structure
* to be filled up
* @return KNI_OK - if successfully get all fields,
* KNI_ERR or KNI_ENOMEM - otherwise
*/
static int fillHandlerData(jobject o, JSR211_content_handler* handler) {
int ret; // returned result code
KNI_StartHandles(1);
KNI_DeclareHandle(fldObj); // field object
do {
// ID
KNI_GetObjectField(o, chImplId, fldObj);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(fldObj, &(handler->id))) {
ret = KNI_ENOMEM;
break;
}
// check mandatory field
if (pcsl_string_length(&(handler->id)) <= 0) {
ret = KNI_ERR;
break;
}
// suiteId
handler->suite_id = KNI_GetIntField(o, chImplSuiteId);
// classname
KNI_GetObjectField(o, chImplClassname, fldObj);
if (PCSL_STRING_OK != midp_jstring_to_pcsl_string(fldObj, &(handler->class_name))) {
ret = KNI_ENOMEM;
break;
}
// flag
handler->flag = KNI_GetIntField(o, chImplregMethod);
// types
KNI_GetObjectField(o, chImplTypes, fldObj);
handler->type_num = getStringArray(fldObj, &(handler->types));
if (handler->type_num < 0) {
ret = KNI_ENOMEM;
break;
}
// suffixes
KNI_GetObjectField(o, chImplSuffixes, fldObj);
handler->suff_num = getStringArray(fldObj, &(handler->suffixes));
if (handler->suff_num < 0) {
ret = KNI_ENOMEM;
break;
}
// actions
KNI_GetObjectField(o, chImplActions, fldObj);
handler->act_num = getStringArray(fldObj, &(handler->actions));
if (handler->act_num < 0) {
ret = KNI_ENOMEM;
break;
}
// action names
if (handler->act_num > 0) {
KNI_GetObjectField(o, chImplActionnames, fldObj);
ret = fillActionMap(fldObj, handler);
if (KNI_OK != ret) {
break;
}
}
// accesses
KNI_GetObjectField(o, chImplAccesses, fldObj);
handler->access_num = getStringArray(fldObj, &(handler->accesses));
if (handler->access_num < 0) {
ret = KNI_ENOMEM;
break;
}
ret = KNI_OK;
} while (0);
KNI_EndHandles();
return ret;
}
/**
* KNI function that creates native resource for the current StringItem.
*
* Class: javax.microedition.lcdui.StringItemLFImpl
*
* Java prototype:
* private native int createNativeResource0(int ownerId,
* String label, int layout, String text, int maxSize,
* int constraints, String initialInputMode)
*
* INTERFACE (operand stack manipulation):
* parameters: ownerId id of the owner's native resource
* label StringItem's label
* layout StringItem's layout
* text StringItem's text
* appearanceMode the appearanceMode of StringItem
* font font to paint text
* returns: id of the created platform widget
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_javax_microedition_lcdui_StringItemLFImpl_createNativeResource0() {
MidpError err = KNI_OK;
MidpDisplayable *ownerPtr;
MidpItem *itemPtr = NULL;
pcsl_string label, text;
pcsl_string_status rc1 = PCSL_STRING_OK, rc2 = PCSL_STRING_OK;
PlatformFontPtr fontPtr = NULL;
int appearanceMode, layout;
KNI_StartHandles(4);
KNI_DeclareHandle(labelJString);
KNI_DeclareHandle(textJString);
KNI_DeclareHandle(fontJFont);
KNI_DeclareHandle(fontHandle);
ownerPtr = (MidpDisplayable *)KNI_GetParameterAsInt(1);
KNI_GetParameterAsObject(2, labelJString);
layout = KNI_GetParameterAsInt(3);
KNI_GetParameterAsObject(4, textJString);
appearanceMode = KNI_GetParameterAsInt(5);
KNI_GetParameterAsObject(6, fontJFont);
if (KNI_IsNullHandle(fontJFont) != KNI_TRUE) {
int face, style, size;
KNI_FindClass("javax/microedition/lcdui/Font", fontHandle);
face = KNI_GetIntField(fontJFont, _CACHE_FIELDID(fontHandle, "face",
"I", _f_face_cache));
style = KNI_GetIntField(fontJFont, _CACHE_FIELDID(fontHandle, "style",
"I", _f_style_cache));
size = KNI_GetIntField(fontJFont, _CACHE_FIELDID(fontHandle, "size",
"I", _f_size_cache));
err = lfpport_get_font(&fontPtr, face, style, size);
}
if (err == KNI_OK) {
rc1 = midp_kjstring_to_pcsl_string(labelJString, &label);
rc2 = midp_kjstring_to_pcsl_string(textJString, &text);
}
KNI_EndHandles();
if (err != KNI_OK || PCSL_STRING_OK != rc1 || PCSL_STRING_OK != rc2) {
err = KNI_ENOMEM;
goto cleanup;
}
itemPtr = MidpNewItem(ownerPtr, MIDP_PLAIN_STRING_ITEM_TYPE+appearanceMode);
if (itemPtr == NULL) {
err = KNI_ENOMEM;
goto cleanup;
}
err = lfpport_stringitem_create(itemPtr, ownerPtr, &label, layout,
&text, fontPtr, appearanceMode);
cleanup:
pcsl_string_free(&text);
pcsl_string_free(&label);
if (err != KNI_OK) {
MidpDeleteItem(itemPtr);
KNI_ThrowNew(midpOutOfMemoryError, NULL);
}
KNI_ReturnInt(itemPtr);
}
/*
* Reads data from a packet received via Bluetooth stack.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>L2CAPConnectionImpl</code> object.
*
* @param buf the buffer to read to
* @param offset he start offset in array <code>buf</code>
* at which the data to be written
* @param size the maximum number of bytes to read,
* the rest of the packet is discarded.
* @return total number of bytes read into the buffer or
* <code>0</code> if a zero length packet is received
* @throws IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_jsr082_bluetooth_btl2cap_L2CAPConnectionImpl_receive0(void) {
int length, offset;
javacall_handle handle;
int bytesRead = -1;
int status = JAVACALL_FAIL;
void* context = NULL;
MidpReentryData* info;
jfieldID connHandleID = NULL;
offset = (int)KNI_GetParameterAsInt(2);
length = (int)KNI_GetParameterAsInt(3);
KNI_StartHandles(3);
KNI_DeclareHandle(arrayHandle);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(classHandle);
KNI_GetThisPointer(thisHandle);
KNI_GetClassPointer(classHandle);
GET_FIELDID(classHandle, "handle", "I", connHandleID)
handle = (javacall_handle)KNI_GetIntField(thisHandle, connHandleID);
KNI_GetParameterAsObject(1, arrayHandle);
REPORT_INFO3(LC_PROTOCOL,
"btl2cap::receive off=%d len=%d handle=%d\n", offset, length, handle);
info = (MidpReentryData*)SNI_GetReentryData(NULL);
// Need revisit: add bluetooth activity indicator
// START_BT_INDICATOR;
if (info == NULL) { /* First invocation */
if (JAVACALL_BT_INVALID_HANDLE == handle) {
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(
"Invalid handle during btl2cap::receive"));
} else {
// Need revisit: add bluetooth activity indicator
// INC_BT_INDICATOR;
SNI_BEGIN_RAW_POINTERS;
status = javacall_bt_l2cap_receive(handle,
(unsigned char*)&(JavaByteArray(arrayHandle)[offset]),
length, &bytesRead);
SNI_END_RAW_POINTERS;
}
} else { /* Reinvocation after unblocking the thread */
if (JAVACALL_BT_INVALID_HANDLE == handle) {
/* closed by another thread */
KNI_ThrowNew(midpInterruptedIOException, EXCEPTION_MSG(
"Interrupted IO error during btl2cap::receive"));
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
} else {
if ((javacall_handle)info->descriptor != handle) {
REPORT_CRIT2(LC_PROTOCOL,
"btl2cap::receive handles mismatched %d != %d\n",
handle, (javacall_handle)info->descriptor);
}
context = info->pResult;
SNI_BEGIN_RAW_POINTERS;
status = javacall_bt_l2cap_receive(handle,
(unsigned char*)&(JavaByteArray(arrayHandle)[offset]),
length, &bytesRead);
SNI_END_RAW_POINTERS;
}
}
REPORT_INFO1(LC_PROTOCOL, "btl2cap::receive bytes=%d\n", bytesRead);
if (JAVACALL_BT_INVALID_HANDLE != handle) {
if (status == JAVACALL_OK) {
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
} else {
char* pError;
javacall_bt_l2cap_get_error(handle, &pError);
REPORT_INFO1(LC_PROTOCOL, "btl2cap::receive (%s)\n", pError);
if (status == JAVACALL_WOULD_BLOCK) {
midp_thread_wait(NETWORK_READ_SIGNAL, (int)handle, context);
} else if (status == JAVACALL_INTERRUPTED) {
char* pError;
javacall_bt_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Interrupted IO error during btl2cap::receive (%s)",
pError);
KNI_ThrowNew(midpInterruptedIOException,
EXCEPTION_MSG(gKNIBuffer));
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
} else {
char* pError;
javacall_bt_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Unknown error during btl2cap::receive (%s)", pError);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(gKNIBuffer));
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
}
}
}
// Need revisit: add bluetooth activity indicator
// STOP_BT_INDICATOR;
KNI_EndHandles();
KNI_ReturnInt((jint)bytesRead);
}
/**
* 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();
}
/**
*
* 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);
}
/*
* Performs client connection establishment.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>L2CAPConnectionImpl</code> object.
*
* @param addr bluetooth address of device to connect to
* @param psm Protocol Service Multiplexor (PSM) value
* @return Negotiated ReceiveMTU and TransmitMTU.
* 16 high bits is ReceiveMTU, 16 low bits is TransmitMTU.
*
* @throws IOException if any I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_jsr082_bluetooth_btl2cap_L2CAPConnectionImpl_connect0(void) {
unsigned char *address = NULL;
int psm = (int)KNI_GetParameterAsInt(2);
javacall_handle handle = JAVACALL_BT_INVALID_HANDLE;
int status, i, imtu, omtu, mtus;
void* context = NULL;
MidpReentryData* info;
javacall_bt_address addr;
jfieldID connHandleID = NULL;
KNI_StartHandles(3);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(arrayHandle);
KNI_DeclareHandle(classHandle);
KNI_GetThisPointer(thisHandle);
KNI_GetClassPointer(classHandle);
GET_FIELDID(classHandle, "handle", "I", connHandleID)
KNI_GetParameterAsObject(1, arrayHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, connHandleID);
REPORT_INFO1(LC_PROTOCOL, "btl2cap::connect handle=%d", handle);
/* copy address from Java input array */
SNI_BEGIN_RAW_POINTERS;
address = JavaByteArray(arrayHandle);
for (i = 0; i < JAVACALL_BT_ADDRESS_SIZE; i++) {
addr[i] = address[i];
}
SNI_END_RAW_POINTERS;
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) { /* First invocation */
// Need revisit: add resource counting
/*
* Verify that the resource is available well within limit as per
* the policy in ResourceLimiter
*/
/*
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_l2cap_connect(handle, address, psm,
&imtu, &omtu);
if (status == JAVACALL_OK) {
// Need revisit: add resource counting
/*
if (midpIncResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
} else if (status == JAVACALL_FAIL) {
char* pError;
javacall_bt_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IO error in btl2cap::connect (%s)\n", pError);
REPORT_INFO(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(gKNIBuffer));
} else if (status == JAVACALL_WOULD_BLOCK) {
// Need revisit: add bluetooth activity indicator
// INC_BT_INDICATOR;
// Need revisit: add resource counting
/*
if (midpIncResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
REPORT_INFO1(LC_PROTOCOL,
"btl2cap::connect is waiting for complete notify"
", handle = %d\n", handle);
midp_thread_wait(NETWORK_WRITE_SIGNAL, (int)handle, context);
} else {
char* pMsg = "Unknown error during btl2cap::connect";
REPORT_INFO(LC_PROTOCOL, pMsg);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg));
}
// }
} else { /* Reinvocation after unblocking the thread */
context = info->pResult;
if ((javacall_handle)info->descriptor != handle) {
REPORT_CRIT2(LC_PROTOCOL,
"btl2cap::connect handles mismatched %d != %d\n",
handle, (javacall_handle)info->descriptor);
}
status = javacall_bt_l2cap_connect(handle, address, psm,
&imtu, &omtu);
if (status == JAVACALL_OK) {
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
} else if (status == JAVACALL_WOULD_BLOCK) {
midp_thread_wait(NETWORK_WRITE_SIGNAL, (int)handle, context);
} else {
char* pError;
KNI_SetIntField(thisHandle, connHandleID, (jint)JAVACALL_BT_INVALID_HANDLE);
// Need revisit: add bluetooth activity indicator
// DEC_BT_INDICATOR;
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
javacall_bt_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"Error in btl2cap::connect (%s)", pError);
REPORT_INFO(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpConnectionNotFoundException,
EXCEPTION_MSG(gKNIBuffer));
}
}
mtus = (imtu << 16) & 0xFFFF0000;
mtus |= omtu & 0xFFFF;
KNI_EndHandles();
KNI_ReturnInt(mtus);
}
/*
* 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();
}
/**
* Accepts incoming client connection request.
*
* Note: the method gets native connection handle directly from
* <code>handle<code> field of <code>L2CAPNotifierImpl</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>L2CAPConnectionImpl</code> object.
*
* @return Negotiated ReceiveMTU and TransmitMTU.
* 16 high bits is ReceiveMTU, 16 low bits is TransmitMTU.
* @throws IOException if an I/O error occurs
*/
KNIEXPORT KNI_RETURNTYPE_INT
Java_com_sun_midp_io_j2me_btl2cap_L2CAPNotifierImpl_accept0(void) {
javacall_handle handle = BT_INVALID_HANDLE;
javacall_handle peer_handle = BT_INVALID_HANDLE;
MidpReentryData* info;
int status = JAVACALL_FAIL;
int processStatus = KNI_FALSE;
int imtu, omtu, mtus;
void *context = NULL;
javacall_bt_address peer_addr;
unsigned char *address = NULL;
KNI_StartHandles(2);
KNI_DeclareHandle(thisHandle);
KNI_DeclareHandle(arrayHandle);
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, notifHandleID);
KNI_GetObjectField(thisHandle, peerAddrID, arrayHandle);
if (handle == BT_INVALID_HANDLE) {
REPORT_ERROR(LC_PROTOCOL,
"L2CAP server socket was closed before btl2cap_notif::accept");
KNI_ThrowNew(midpInterruptedIOException, EXCEPTION_MSG(
"L2CAP notifier was closed"));
} else {
bt_pushid_t pushid = KNI_GetIntField(thisHandle, pushHandleID);
if (pushid != BT_INVALID_PUSH_HANDLE) {
if (bt_push_checkout_client(pushid, &peer_handle, peer_addr,
&imtu, &omtu) == JAVACALL_OK) {
pushcheckoutaccept((int)handle);
processStatus = KNI_TRUE;
status = JAVACALL_OK;
}
}
if (peer_handle == BT_INVALID_HANDLE) {
info = (MidpReentryData*)SNI_GetReentryData(NULL);
if (info == NULL) { /* First invocation */
REPORT_INFO1(LC_PROTOCOL,
"btl2cap_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_l2cap_accept(
handle, &peer_handle, &peer_addr, &imtu, &omtu);
processStatus = KNI_TRUE;
// }
} else { /* Reinvocation after unblocking the thread */
if ((javacall_handle)info->descriptor != handle) {
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"btl2cap_notif::accept handles mismatched %d != %d\n",
handle, info->descriptor);
REPORT_CRIT(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpIllegalStateException, EXCEPTION_MSG(
"Internal error in btl2cap_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 {
*/
status = javacall_bt_l2cap_accept(
handle, &peer_handle, &peer_addr, &imtu, &omtu);
processStatus = KNI_TRUE;
// }
}
}
}
if (processStatus) {
REPORT_INFO1(LC_PROTOCOL,
"btl2cap_notif::accept server handle=%d\n", handle);
if (status == JAVACALL_OK) {
int i;
// Need revisit: add resource counting
/*
if (midpIncResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL,
"btl2cap_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
SNI_BEGIN_RAW_POINTERS;
address = JavaByteArray(arrayHandle);
for (i = 0; i < BT_ADDRESS_SIZE; i++) {
address[i] = peer_addr[i];
}
SNI_END_RAW_POINTERS;
REPORT_INFO(LC_PROTOCOL,
"btl2cap_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_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IO error in btl2cap_notif::accept (%s)\n", pError);
REPORT_INFO(LC_PROTOCOL, gKNIBuffer);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(gKNIBuffer));
} else {
char* pMsg = "Unknown error during btl2cap_notif::accept";
REPORT_INFO(LC_PROTOCOL, pMsg);
KNI_ThrowNew(midpIOException, EXCEPTION_MSG(pMsg));
}
}
}
mtus = (imtu << 16) & 0xFFFF0000;
mtus |= omtu & 0xFFFF;
KNI_EndHandles();
KNI_ReturnInt(mtus);
}
/**
* (Internal) Fill landmark structure from the Landmark Object.
*/
static jboolean fill_landmark(jobject landmarkObj, javacall_landmarkstore_landmark *landmark,
jobject stringObj) {
/* Fill javacall_landmarkstore_landmark structure */
/* landmark.name */
KNI_GetObjectField(landmarkObj, landmarkImplFieldID.name, stringObj);
if (!KNI_IsNullHandle(stringObj) &&
KNI_GetStringLength(stringObj)<=JAVACALL_LANDMARKSTORE_MAX_LANDMARK_NAME) {
if (JAVACALL_OK !=
jsrop_jstring_to_utf16(stringObj, landmark->name, JAVACALL_LANDMARKSTORE_MAX_LANDMARK_NAME)) {
return KNI_FALSE;
}
} else {
return KNI_FALSE;
}
/* landmark.description */
KNI_GetObjectField(landmarkObj, landmarkImplFieldID.description, stringObj);
jsr179_jstring_to_utf16(stringObj, landmark->description, JAVACALL_LANDMARKSTORE_MAX_LANDMARK_DESCRIPTION);
landmark->isValidCoordinate = KNI_GetBooleanField(landmarkObj,
landmarkImplFieldID.isCoordinates);
if (landmark->isValidCoordinate) {
/* landmark.latitude */
landmark->latitude = KNI_GetDoubleField(landmarkObj,
landmarkImplFieldID.latitude);
/* landmark.longitude */
landmark->longitude = KNI_GetDoubleField(landmarkObj,
landmarkImplFieldID.longitude);
/* landmark.altitude */
landmark->altitude = KNI_GetFloatField(landmarkObj,
landmarkImplFieldID.altitude);
/* landmark.horizontalAccuracy */
landmark->horizontalAccuracy = KNI_GetFloatField(landmarkObj,
landmarkImplFieldID.horizontalAccuracy);
/* landmark.altitude */
landmark->verticalAccuracy = KNI_GetFloatField(landmarkObj,
landmarkImplFieldID.verticalAccuracy);
}
/* AddressInfo */
landmark->addressInfoFieldNumber = KNI_GetIntField(landmarkObj,
landmarkImplFieldID.numAddressInfoFields);
if (landmark->addressInfoFieldNumber > 0) {
jint counter = 0;
/* AddressInfo_EXTENSION */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_EXTENSION,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_EXTENSION) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_STREET */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_STREET,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_STREET) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_POSTAL_CODE */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_POSTAL_CODE,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_POSTAL_CODE) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_CITY */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_CITY,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_CITY) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_COUNTY */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_COUNTY,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_COUNTY) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_STATE */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_STATE,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_STATE) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_COUNTRY */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_COUNTRY,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_COUNTRY) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_COUNTRY_CODE */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_COUNTRY_CODE,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_COUNTRY_CODE) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_DISTRICT */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_DISTRICT,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_DISTRICT) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_BUILDING_NAME */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_BUILDING_NAME,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_BUILDING_NAME) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_BUILDING_FLOOR */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_BUILDING_FLOOR,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_BUILDING_FLOOR) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_BUILDING_ROOM */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_BUILDING_ROOM,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_BUILDING_ROOM) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_BUILDING_ZONE */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_BUILDING_ZONE,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_BUILDING_ZONE) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_CROSSING1 */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_CROSSING1,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_CROSSING1) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_CROSSING2 */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_CROSSING2,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_CROSSING2) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_URL */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_URL,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_URL) == KNI_TRUE)) {
counter++;
}
/* AddressInfo_PHONE_NUMBER */
if ((counter < landmark->addressInfoFieldNumber) &&
(fill_adressInfoField(landmarkObj,
landmarkImplFieldID.AddressInfo_PHONE_NUMBER,
stringObj,
&landmark->fields[counter],
JAVACALL_LOCATION_ADDRESSINFO_PHONE_NUMBER) == KNI_TRUE)) {
counter++;
}
}
return KNI_TRUE;
}
/**
* Native finalizer.
* Releases all native resources used by this connection.
*/
KNIEXPORT KNI_RETURNTYPE_VOID
Java_com_sun_midp_io_j2me_btl2cap_L2CAPNotifierImpl_finalize(void) {
javacall_handle handle, peer;
int status = JAVACALL_FAIL;
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::finalize");
KNI_StartHandles(1);
KNI_DeclareHandle(thisHandle);
KNI_GetThisPointer(thisHandle);
handle = (javacall_handle)KNI_GetIntField(thisHandle, notifHandleID);
if (handle != BT_INVALID_HANDLE) {
status = javacall_bt_l2cap_close(handle);
KNI_SetIntField(thisHandle, notifHandleID, (jint)BT_INVALID_HANDLE);
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_SER, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
if (status == JAVACALL_FAIL) {
char* pError;
javacall_bt_l2cap_get_error(handle, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IO error in bt_l2cap_notif::finalize (%s)\n", pError);
REPORT_ERROR(LC_PROTOCOL, gKNIBuffer);
} else if (status == JAVACALL_WOULD_BLOCK) {
/* blocking during finalize is not supported */
REPORT_CRIT1(LC_PROTOCOL,
"btl2cap_notif::finalize notifier blocked, handle = %d\n",
handle);
}
}
peer = (javacall_handle)KNI_GetIntField(thisHandle, peerHandleID);
if (peer != BT_INVALID_HANDLE) {
status = javacall_bt_l2cap_close(peer);
KNI_SetIntField(thisHandle, peerHandleID, (jint)BT_INVALID_HANDLE);
// Need revisit: add resource counting
/*
if (midpDecResourceCount(RSC_TYPE_BT_CLI, 1) == 0) {
REPORT_INFO(LC_PROTOCOL, "Resource limit update error");
}
*/
if (status == JAVACALL_FAIL) {
char* pError;
javacall_bt_l2cap_get_error(peer, &pError);
midp_snprintf(gKNIBuffer, KNI_BUFFER_SIZE,
"IO error in bt_l2cap_notif::finalize (%s)\n", pError);
REPORT_ERROR(LC_PROTOCOL, gKNIBuffer);
} else if (status == JAVACALL_WOULD_BLOCK) {
/* blocking during finalize is not supported */
REPORT_CRIT1(LC_PROTOCOL,
"btl2cap_notif::finalize blocked, handle = %d\n", peer);
}
}
REPORT_INFO(LC_PROTOCOL, "btl2cap_notif::finalize done!");
KNI_EndHandles();
KNI_ReturnVoid();
}