core/jni/android_bluetooth_RfcommSocket.cpp - platform/frameworks/base - Git at Google

 /*
 ** Copyright 2006, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */

 #define LOG_TAG "bluetooth_RfcommSocket.cpp"

 #include "android_bluetooth_common.h"
 #include "android_runtime/AndroidRuntime.h"
 #include "JNIHelp.h"
 #include "jni.h"
 #include "utils/Log.h"
 #include "utils/misc.h"

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <sys/poll.h>

 #ifdef HAVE_BLUETOOTH
 #include <bluetooth/bluetooth.h>
 #include <bluetooth/rfcomm.h>
 #include <bluetooth/sco.h>
 #endif

 namespace android {

 #ifdef HAVE_BLUETOOTH
 static jfieldID field_mNativeData;
 static jfieldID field_mTimeoutRemainingMs;
 static jfieldID field_mAcceptTimeoutRemainingMs;
 static jfieldID field_mAddress;
 static jfieldID field_mPort;

 typedef struct {
     jstring address;
     const char *c_address;
     int rfcomm_channel;
     int last_read_err;
     int rfcomm_sock;
     // < 0 -- in progress,
     //   0 -- not connected
     // > 0 connected
     //     1 input is open
     //     2 output is open
     //     3 both input and output are open
     int rfcomm_connected;
     int rfcomm_sock_flags;
 } native_data_t;

 static inline native_data_t * get_native_data(JNIEnv *env, jobject object) {
     return (native_data_t *)(env->GetIntField(object, field_mNativeData));
 }

 static inline void init_socket_info(
     JNIEnv *env, jobject object,
     native_data_t *nat,
     jstring address,
     jint rfcomm_channel) {
     nat->address = (jstring)env->NewGlobalRef(address);
     nat->c_address = env->GetStringUTFChars(nat->address, NULL);
     nat->rfcomm_channel = (int)rfcomm_channel;
 }

 static inline void cleanup_socket_info(JNIEnv *env, native_data_t *nat) {
     if (nat->c_address != NULL) {
         env->ReleaseStringUTFChars(nat->address, nat->c_address);
         env->DeleteGlobalRef(nat->address);
         nat->c_address = NULL;
     }
 }
 #endif

 static void classInitNative(JNIEnv* env, jclass clazz) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     field_mNativeData = get_field(env, clazz, "mNativeData", "I");
     field_mTimeoutRemainingMs = get_field(env, clazz, "mTimeoutRemainingMs", "I");
     field_mAcceptTimeoutRemainingMs = get_field(env, clazz, "mAcceptTimeoutRemainingMs", "I");
     field_mAddress = get_field(env, clazz, "mAddress", "Ljava/lang/String;");
     field_mPort = get_field(env, clazz, "mPort", "I");
 #endif
 }

 static void initializeNativeDataNative(JNIEnv* env, jobject object) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH

     native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t));
     if (nat == NULL) {
         LOGE("%s: out of memory!", __FUNCTION__);
         return;
     }

     env->SetIntField(object, field_mNativeData, (jint)nat);
     nat->rfcomm_sock = -1;
     nat->rfcomm_connected = 0;
 #endif
 }

 static void cleanupNativeDataNative(JNIEnv* env, jobject object) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     native_data_t *nat = get_native_data(env, object);
     if (nat) {
         free(nat);
     }
 #endif
 }

 static jobject createNative(JNIEnv *env, jobject obj) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     int lm;
     native_data_t *nat = get_native_data(env, obj);
     nat->rfcomm_sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);

     if (nat->rfcomm_sock < 0) {
         LOGE("%s: Could not create RFCOMM socket: %s\n", __FUNCTION__,
              strerror(errno));
         return NULL;
     }

     lm = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT;

     if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm,
                 sizeof(lm)) < 0) {
         LOGE("%s: Can't set RFCOMM link mode", __FUNCTION__);
         close(nat->rfcomm_sock);
         return NULL;
     }

     return jniCreateFileDescriptor(env, nat->rfcomm_sock);
 #else
     return NULL;
 #endif
 }

 static void destroyNative(JNIEnv *env, jobject obj) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     native_data_t *nat = get_native_data(env, obj);
     cleanup_socket_info(env, nat);
     if (nat->rfcomm_sock >= 0) {
         close(nat->rfcomm_sock);
         nat->rfcomm_sock = -1;
     }
 #endif
 }


 static jboolean connectNative(JNIEnv *env, jobject obj,
                               jstring address, jint port) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     native_data_t *nat = get_native_data(env, obj);

     if (nat->rfcomm_sock >= 0) {
         if (nat->rfcomm_connected) {
             LOGI("RFCOMM socket: %s.",
                  (nat->rfcomm_connected > 0) ? "already connected" : "connection is in progress");
             return JNI_TRUE;
         }

         init_socket_info(env, obj, nat, address, port);

         struct sockaddr_rc addr;
         memset(&addr, 0, sizeof(struct sockaddr_rc));
         get_bdaddr(nat->c_address, &addr.rc_bdaddr);
         addr.rc_channel = nat->rfcomm_channel;
         addr.rc_family = AF_BLUETOOTH;
         nat->rfcomm_connected = 0;

         while (nat->rfcomm_connected == 0) {
             if (connect(nat->rfcomm_sock, (struct sockaddr *)&addr,
                     sizeof(addr)) < 0) {
                 if (errno == EINTR) continue;
                 LOGE("connect error: %s (%d)\n", strerror(errno), errno);
                 break;
             } else {
                 nat->rfcomm_connected = 3; // input and output
             }
         }
     } else {
         LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
     }

     if (nat->rfcomm_connected > 0) {
         env->SetIntField(obj, field_mPort, port);
         return JNI_TRUE;
     }
 #endif
     return JNI_FALSE;
 }

 static jboolean connectAsyncNative(JNIEnv *env, jobject obj,
                                    jstring address, jint port) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     native_data_t *nat = get_native_data(env, obj);

     if (nat->rfcomm_sock < 0) {
         LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
         return JNI_FALSE;
     }

     if (nat->rfcomm_connected) {
         LOGI("RFCOMM socket: %s.",
              (nat->rfcomm_connected > 0) ?
              "already connected" : "connection is in progress");
         return JNI_TRUE;
     }

     init_socket_info(env, obj, nat, address, port);

     struct sockaddr_rc addr;
     memset(&addr, 0, sizeof(struct sockaddr_rc));
     get_bdaddr(nat->c_address, &addr.rc_bdaddr);
     addr.rc_channel = nat->rfcomm_channel;
     addr.rc_family = AF_BLUETOOTH;

     nat->rfcomm_sock_flags = fcntl(nat->rfcomm_sock, F_GETFL, 0);
     if (fcntl(nat->rfcomm_sock,
               F_SETFL, nat->rfcomm_sock_flags | O_NONBLOCK) >= 0) {
         int rc;
         nat->rfcomm_connected = 0;
         errno = 0;
         rc = connect(nat->rfcomm_sock,
                      (struct sockaddr *)&addr,
                      sizeof(addr));

         if (rc >= 0) {
             nat->rfcomm_connected = 3;
             LOGI("RFCOMM async connect immediately successful");
             env->SetIntField(obj, field_mPort, port);
             return JNI_TRUE;
         }
         else if (rc < 0) {
             if (errno == EINPROGRESS || errno == EAGAIN)
                 {
                     LOGI("RFCOMM async connect is in progress (%s)",
                          strerror(errno));
                     nat->rfcomm_connected = -1;
                     env->SetIntField(obj, field_mPort, port);
                     return JNI_TRUE;
                 }
             else
                 {
                     LOGE("RFCOMM async connect error (%d): %s (%d)",
                          nat->rfcomm_sock, strerror(errno), errno);
                     return JNI_FALSE;
                 }
         }
     } // fcntl(nat->rfcomm_sock ...)
 #endif
     return JNI_FALSE;
 }

 static jboolean interruptAsyncConnectNative(JNIEnv *env, jobject obj) {
     //WRITEME
     return JNI_TRUE;
 }

 static jint waitForAsyncConnectNative(JNIEnv *env, jobject obj,
                                       jint timeout_ms) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     struct sockaddr_rc addr;
     native_data_t *nat = get_native_data(env, obj);

     env->SetIntField(obj, field_mTimeoutRemainingMs, timeout_ms);

     if (nat->rfcomm_sock < 0) {
         LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
         return -1;
     }

     if (nat->rfcomm_connected > 0) {
         LOGI("%s: RFCOMM is already connected!", __FUNCTION__);
         return 1;
     }

     /* Do an asynchronous select() */
     int n;
     fd_set rset, wset;
     struct timeval to;

     FD_ZERO(&rset);
     FD_ZERO(&wset);
     FD_SET(nat->rfcomm_sock, &rset);
     FD_SET(nat->rfcomm_sock, &wset);
     if (timeout_ms >= 0) {
         to.tv_sec = timeout_ms / 1000;
         to.tv_usec = 1000 * (timeout_ms % 1000);
     }
     n = select(nat->rfcomm_sock + 1,
                &rset,
                &wset,
                NULL,
                (timeout_ms < 0 ? NULL : &to));

     if (timeout_ms > 0) {
         jint remaining = to.tv_sec*1000 + to.tv_usec/1000;
         LOGI("Remaining time %ldms", (long)remaining);
         env->SetIntField(obj, field_mTimeoutRemainingMs,
                          remaining);
     }

     if (n <= 0) {
         if (n < 0)  {
             LOGE("select() on RFCOMM socket: %s (%d)",
                  strerror(errno),
                  errno);
             return -1;
         }
         return 0;
     }
     /* n must be equal to 1 and either rset or wset must have the
        file descriptor set. */
     LOGI("select() returned %d.", n);
     if (FD_ISSET(nat->rfcomm_sock, &rset) ||
         FD_ISSET(nat->rfcomm_sock, &wset)) {
         /* A trial async read() will tell us if everything is OK. */
         char ch;
         errno = 0;
         int nr = read(nat->rfcomm_sock, &ch, 1);
         /* It should be that nr != 1 because we just opened a socket
            and we haven't sent anything over it for the other side to
            respond... but one can't be paranoid enough.
         */
         if (nr >= 0 || errno != EAGAIN) {
             LOGE("RFCOMM async connect() error: %s (%d), nr = %d\n",
                  strerror(errno),
                  errno,
                  nr);
             /* Clear the rfcomm_connected flag to cause this function
                to re-create the socket and re-attempt the connect()
                the next time it is called.
             */
             nat->rfcomm_connected = 0;
             /* Restore the blocking properties of the socket. */
             fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags);
             return -1;
         }
         /* Restore the blocking properties of the socket. */
         fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags);
         LOGI("Successful RFCOMM socket connect.");
         nat->rfcomm_connected = 3; // input and output
         return 1;
     }
 #endif
     return -1;
 }

 static jboolean shutdownNative(JNIEnv *env, jobject obj,
                 jboolean shutdownInput) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     /* NOTE: If you change the bcode to modify nat, make sure you
        add synchronize(this) to the method calling this native
        method.
     */
     native_data_t *nat = get_native_data(env, obj);
     if (nat->rfcomm_sock < 0) {
         LOGE("socket(RFCOMM) error: socket not created");
         return JNI_FALSE;
     }
     int rc = shutdown(nat->rfcomm_sock,
             shutdownInput ? SHUT_RD : SHUT_WR);
     if (!rc) {
         nat->rfcomm_connected &=
             shutdownInput ? ~1 : ~2;
         return JNI_TRUE;
     }
 #endif
     return JNI_FALSE;
 }

 static jint isConnectedNative(JNIEnv *env, jobject obj) {
     LOGI(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     const native_data_t *nat = get_native_data(env, obj);
     return nat->rfcomm_connected;
 #endif
     return 0;
 }

 //@@@@@@@@@ bind to device???
 static jboolean bindNative(JNIEnv *env, jobject obj, jstring device,
                            jint port) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH

     /* NOTE: If you change the code to modify nat, make sure you
        add synchronize(this) to the method calling this native
        method.
     */
     const native_data_t *nat = get_native_data(env, obj);
     if (nat->rfcomm_sock < 0) {
         LOGE("socket(RFCOMM) error: socket not created");
         return JNI_FALSE;
     }

     struct sockaddr_rc laddr;
     int lm;

     lm = 0;
 /*
     lm |= RFCOMM_LM_MASTER;
     lm |= RFCOMM_LM_AUTH;
     lm |= RFCOMM_LM_ENCRYPT;
     lm |= RFCOMM_LM_SECURE;
 */

     if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, sizeof(lm)) < 0) {
         LOGE("Can't set RFCOMM link mode");
         return JNI_FALSE;
     }

     laddr.rc_family = AF_BLUETOOTH;
     bacpy(&laddr.rc_bdaddr, BDADDR_ANY);
     laddr.rc_channel = port;

     if (bind(nat->rfcomm_sock, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) {
         LOGE("Can't bind RFCOMM socket");
         return JNI_FALSE;
     }

     env->SetIntField(obj, field_mPort, port);

     return JNI_TRUE;
 #endif
     return JNI_FALSE;
 }

 static jboolean listenNative(JNIEnv *env, jobject obj, jint backlog) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     /* NOTE: If you change the code to modify nat, make sure you
        add synchronize(this) to the method calling this native
        method.
     */
     const native_data_t *nat = get_native_data(env, obj);
     if (nat->rfcomm_sock < 0) {
         LOGE("socket(RFCOMM) error: socket not created");
         return JNI_FALSE;
     }
     return listen(nat->rfcomm_sock, backlog) < 0 ? JNI_FALSE : JNI_TRUE;
 #else
     return JNI_FALSE;
 #endif
 }

 static int set_nb(int sk, bool nb) {
     int flags = fcntl(sk, F_GETFL);
     if (flags < 0) {
         LOGE("Can't get socket flags with fcntl(): %s (%d)",
              strerror(errno), errno);
         close(sk);
         return -1;
     }
     flags &= ~O_NONBLOCK;
     if (nb) flags |= O_NONBLOCK;
     int status = fcntl(sk, F_SETFL, flags);
     if (status < 0) {
         LOGE("Can't set socket to nonblocking mode with fcntl(): %s (%d)",
              strerror(errno), errno);
         close(sk);
         return -1;
     }
     return 0;
 }

 // Note: the code should check at a higher level to see whether
 // listen() has been called.
 #ifdef HAVE_BLUETOOTH
 static int do_accept(JNIEnv* env, jobject object, int sock,
                      jobject newsock,
                      jfieldID out_address,
                      bool must_succeed) {

     if (must_succeed && set_nb(sock, true) < 0)
         return -1;

     struct sockaddr_rc raddr;
     int alen = sizeof(raddr);
     int nsk = accept(sock, (struct sockaddr *) &raddr, &alen);
     if (nsk < 0) {
         LOGE("Error on accept from socket fd %d: %s (%d).",
              sock,
              strerror(errno),
              errno);
         if (must_succeed) set_nb(sock, false);
         return -1;
     }

     char addr[BTADDR_SIZE];
     get_bdaddr_as_string(&raddr.rc_bdaddr, addr);
     env->SetObjectField(newsock, out_address, env->NewStringUTF(addr));

     LOGI("Successful accept() on AG socket %d: new socket %d, address %s, RFCOMM channel %d",
          sock,
          nsk,
          addr,
          raddr.rc_channel);
     if (must_succeed) set_nb(sock, false);
     return nsk;
 }
 #endif /*HAVE_BLUETOOTH*/

 static jobject acceptNative(JNIEnv *env, jobject obj,
                             jobject newsock, jint timeoutMs) {
     LOGV(__FUNCTION__);
 #ifdef HAVE_BLUETOOTH
     native_data_t *nat = get_native_data(env, obj);
     if (nat->rfcomm_sock < 0) {
         LOGE("socket(RFCOMM) error: socket not created");
         return JNI_FALSE;
     }

     if (newsock == NULL) {
         LOGE("%s: newsock = NULL\n", __FUNCTION__);
         return JNI_FALSE;
     }

     int nsk = -1;
     if (timeoutMs < 0) {
         /* block until accept() succeeds */
         nsk = do_accept(env, obj, nat->rfcomm_sock,
                         newsock, field_mAddress, false);
         if (nsk < 0) {
             return NULL;
         }
     }
     else {
         /* wait with a timeout */

         struct pollfd fds;
         fds.fd = nat->rfcomm_sock;
         fds.events = POLLIN | POLLPRI | POLLOUT | POLLERR;

         env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, 0);
         int n = poll(&fds, 1, timeoutMs);
         if (n <= 0) {
             if (n < 0)  {
                 LOGE("listening poll() on RFCOMM socket: %s (%d)",
                      strerror(errno),
                      errno);
                 env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, timeoutMs);
             }
             else {
                 LOGI("listening poll() on RFCOMM socket timed out");
             }
             return NULL;
         }

         LOGI("listening poll() on RFCOMM socket returned %d", n);
         if (fds.fd == nat->rfcomm_sock) {
             if (fds.revents & (POLLIN | POLLPRI | POLLOUT)) {
                 LOGI("Accepting connection.\n");
                 nsk = do_accept(env, obj, nat->rfcomm_sock,
                                 newsock, field_mAddress, true);
                 if (nsk < 0) {
                     return NULL;
                 }
             }
         }
     }

     LOGI("Connection accepted, new socket fd = %d.", nsk);
     native_data_t *newnat = get_native_data(env, newsock);
     newnat->rfcomm_sock = nsk;
     newnat->rfcomm_connected = 3;
     return jniCreateFileDescriptor(env, nsk);
 #else
     return NULL;
 #endif
 }

 static JNINativeMethod sMethods[] = {
      /* name, signature, funcPtr */
     {"classInitNative", "()V", (void*)classInitNative},
     {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative},
     {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative},

     {"createNative", "()Ljava/io/FileDescriptor;", (void *)createNative},
     {"destroyNative", "()V", (void *)destroyNative},
     {"connectNative", "(Ljava/lang/String;I)Z", (void *)connectNative},
     {"connectAsyncNative", "(Ljava/lang/String;I)Z", (void *)connectAsyncNative},
     {"interruptAsyncConnectNative", "()Z", (void *)interruptAsyncConnectNative},
     {"waitForAsyncConnectNative", "(I)I", (void *)waitForAsyncConnectNative},
     {"shutdownNative", "(Z)Z", (void *)shutdownNative},
     {"isConnectedNative", "()I", (void *)isConnectedNative},

     {"bindNative", "(Ljava/lang/String;I)Z", (void*)bindNative},
     {"listenNative", "(I)Z", (void*)listenNative},
     {"acceptNative", "(Landroid/bluetooth/RfcommSocket;I)Ljava/io/FileDescriptor;", (void*)acceptNative},
 };

 int register_android_bluetooth_RfcommSocket(JNIEnv *env) {
     return AndroidRuntime::registerNativeMethods(env,
         "android/bluetooth/RfcommSocket", sMethods, NELEM(sMethods));
 }

 } /* namespace android */
	/*
	** Copyright 2006, The Android Open Source Project
	**
	** Licensed under the Apache License, Version 2.0 (the "License");
	** you may not use this file except in compliance with the License.
	** You may obtain a copy of the License at
	**
	** http://www.apache.org/licenses/LICENSE-2.0
	**
	** Unless required by applicable law or agreed to in writing, software
	** distributed under the License is distributed on an "AS IS" BASIS,
	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	** See the License for the specific language governing permissions and
	** limitations under the License.
	*/

	#define LOG_TAG "bluetooth_RfcommSocket.cpp"

	#include "android_bluetooth_common.h"
	#include "android_runtime/AndroidRuntime.h"
	#include "JNIHelp.h"
	#include "jni.h"
	#include "utils/Log.h"
	#include "utils/misc.h"

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/socket.h>
	#include <sys/uio.h>
	#include <sys/poll.h>

	#ifdef HAVE_BLUETOOTH
	#include <bluetooth/bluetooth.h>
	#include <bluetooth/rfcomm.h>
	#include <bluetooth/sco.h>
	#endif

	namespace android {

	#ifdef HAVE_BLUETOOTH
	static jfieldID field_mNativeData;
	static jfieldID field_mTimeoutRemainingMs;
	static jfieldID field_mAcceptTimeoutRemainingMs;
	static jfieldID field_mAddress;
	static jfieldID field_mPort;

	typedef struct {
	jstring address;
	const char *c_address;
	int rfcomm_channel;
	int last_read_err;
	int rfcomm_sock;
	// < 0 -- in progress,
	// 0 -- not connected
	// > 0 connected
	// 1 input is open
	// 2 output is open
	// 3 both input and output are open
	int rfcomm_connected;
	int rfcomm_sock_flags;
	} native_data_t;

	static inline native_data_t * get_native_data(JNIEnv *env, jobject object) {
	return (native_data_t *)(env->GetIntField(object, field_mNativeData));
	}

	static inline void init_socket_info(
	JNIEnv *env, jobject object,
	native_data_t *nat,
	jstring address,
	jint rfcomm_channel) {
	nat->address = (jstring)env->NewGlobalRef(address);
	nat->c_address = env->GetStringUTFChars(nat->address, NULL);
	nat->rfcomm_channel = (int)rfcomm_channel;
	}

	static inline void cleanup_socket_info(JNIEnv env, native_data_t nat) {
	if (nat->c_address != NULL) {
	env->ReleaseStringUTFChars(nat->address, nat->c_address);
	env->DeleteGlobalRef(nat->address);
	nat->c_address = NULL;
	}
	}
	#endif

	static void classInitNative(JNIEnv* env, jclass clazz) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	field_mNativeData = get_field(env, clazz, "mNativeData", "I");
	field_mTimeoutRemainingMs = get_field(env, clazz, "mTimeoutRemainingMs", "I");
	field_mAcceptTimeoutRemainingMs = get_field(env, clazz, "mAcceptTimeoutRemainingMs", "I");
	field_mAddress = get_field(env, clazz, "mAddress", "Ljava/lang/String;");
	field_mPort = get_field(env, clazz, "mPort", "I");
	#endif
	}

	static void initializeNativeDataNative(JNIEnv* env, jobject object) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH

	native_data_t nat = (native_data_t )calloc(1, sizeof(native_data_t));
	if (nat == NULL) {
	LOGE("%s: out of memory!", __FUNCTION__);
	return;
	}

	env->SetIntField(object, field_mNativeData, (jint)nat);
	nat->rfcomm_sock = -1;
	nat->rfcomm_connected = 0;
	#endif
	}

	static void cleanupNativeDataNative(JNIEnv* env, jobject object) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	native_data_t *nat = get_native_data(env, object);
	if (nat) {
	free(nat);
	}
	#endif
	}

	static jobject createNative(JNIEnv *env, jobject obj) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	int lm;
	native_data_t *nat = get_native_data(env, obj);
	nat->rfcomm_sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);

	if (nat->rfcomm_sock < 0) {
	LOGE("%s: Could not create RFCOMM socket: %s\n", __FUNCTION__,
	strerror(errno));
	return NULL;
	}

	lm = RFCOMM_LM_AUTH \| RFCOMM_LM_ENCRYPT;

	if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm,
	sizeof(lm)) < 0) {
	LOGE("%s: Can't set RFCOMM link mode", __FUNCTION__);
	close(nat->rfcomm_sock);
	return NULL;
	}

	return jniCreateFileDescriptor(env, nat->rfcomm_sock);
	#else
	return NULL;
	#endif
	}

	static void destroyNative(JNIEnv *env, jobject obj) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	native_data_t *nat = get_native_data(env, obj);
	cleanup_socket_info(env, nat);
	if (nat->rfcomm_sock >= 0) {
	close(nat->rfcomm_sock);
	nat->rfcomm_sock = -1;
	}
	#endif
	}


	static jboolean connectNative(JNIEnv *env, jobject obj,
	jstring address, jint port) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	native_data_t *nat = get_native_data(env, obj);

	if (nat->rfcomm_sock >= 0) {
	if (nat->rfcomm_connected) {
	LOGI("RFCOMM socket: %s.",
	(nat->rfcomm_connected > 0) ? "already connected" : "connection is in progress");
	return JNI_TRUE;
	}

	init_socket_info(env, obj, nat, address, port);

	struct sockaddr_rc addr;
	memset(&addr, 0, sizeof(struct sockaddr_rc));
	get_bdaddr(nat->c_address, &addr.rc_bdaddr);
	addr.rc_channel = nat->rfcomm_channel;
	addr.rc_family = AF_BLUETOOTH;
	nat->rfcomm_connected = 0;

	while (nat->rfcomm_connected == 0) {
	if (connect(nat->rfcomm_sock, (struct sockaddr *)&addr,
	sizeof(addr)) < 0) {
	if (errno == EINTR) continue;
	LOGE("connect error: %s (%d)\n", strerror(errno), errno);
	break;
	} else {
	nat->rfcomm_connected = 3; // input and output
	}
	}
	} else {
	LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
	}

	if (nat->rfcomm_connected > 0) {
	env->SetIntField(obj, field_mPort, port);
	return JNI_TRUE;
	}
	#endif
	return JNI_FALSE;
	}

	static jboolean connectAsyncNative(JNIEnv *env, jobject obj,
	jstring address, jint port) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	native_data_t *nat = get_native_data(env, obj);

	if (nat->rfcomm_sock < 0) {
	LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
	return JNI_FALSE;
	}

	if (nat->rfcomm_connected) {
	LOGI("RFCOMM socket: %s.",
	(nat->rfcomm_connected > 0) ?
	"already connected" : "connection is in progress");
	return JNI_TRUE;
	}

	init_socket_info(env, obj, nat, address, port);

	struct sockaddr_rc addr;
	memset(&addr, 0, sizeof(struct sockaddr_rc));
	get_bdaddr(nat->c_address, &addr.rc_bdaddr);
	addr.rc_channel = nat->rfcomm_channel;
	addr.rc_family = AF_BLUETOOTH;

	nat->rfcomm_sock_flags = fcntl(nat->rfcomm_sock, F_GETFL, 0);
	if (fcntl(nat->rfcomm_sock,
	F_SETFL, nat->rfcomm_sock_flags \| O_NONBLOCK) >= 0) {
	int rc;
	nat->rfcomm_connected = 0;
	errno = 0;
	rc = connect(nat->rfcomm_sock,
	(struct sockaddr *)&addr,
	sizeof(addr));

	if (rc >= 0) {
	nat->rfcomm_connected = 3;
	LOGI("RFCOMM async connect immediately successful");
	env->SetIntField(obj, field_mPort, port);
	return JNI_TRUE;
	}
	else if (rc < 0) {
	if (errno == EINPROGRESS \|\| errno == EAGAIN)
	{
	LOGI("RFCOMM async connect is in progress (%s)",
	strerror(errno));
	nat->rfcomm_connected = -1;
	env->SetIntField(obj, field_mPort, port);
	return JNI_TRUE;
	}
	else
	{
	LOGE("RFCOMM async connect error (%d): %s (%d)",
	nat->rfcomm_sock, strerror(errno), errno);
	return JNI_FALSE;
	}
	}
	} // fcntl(nat->rfcomm_sock ...)
	#endif
	return JNI_FALSE;
	}

	static jboolean interruptAsyncConnectNative(JNIEnv *env, jobject obj) {
	//WRITEME
	return JNI_TRUE;
	}

	static jint waitForAsyncConnectNative(JNIEnv *env, jobject obj,
	jint timeout_ms) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	struct sockaddr_rc addr;
	native_data_t *nat = get_native_data(env, obj);

	env->SetIntField(obj, field_mTimeoutRemainingMs, timeout_ms);

	if (nat->rfcomm_sock < 0) {
	LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__);
	return -1;
	}

	if (nat->rfcomm_connected > 0) {
	LOGI("%s: RFCOMM is already connected!", __FUNCTION__);
	return 1;
	}

	/* Do an asynchronous select() */
	int n;
	fd_set rset, wset;
	struct timeval to;

	FD_ZERO(&rset);
	FD_ZERO(&wset);
	FD_SET(nat->rfcomm_sock, &rset);
	FD_SET(nat->rfcomm_sock, &wset);
	if (timeout_ms >= 0) {
	to.tv_sec = timeout_ms / 1000;
	to.tv_usec = 1000 * (timeout_ms % 1000);
	}
	n = select(nat->rfcomm_sock + 1,
	&rset,
	&wset,
	NULL,
	(timeout_ms < 0 ? NULL : &to));

	if (timeout_ms > 0) {
	jint remaining = to.tv_sec*1000 + to.tv_usec/1000;
	LOGI("Remaining time %ldms", (long)remaining);
	env->SetIntField(obj, field_mTimeoutRemainingMs,
	remaining);
	}

	if (n <= 0) {
	if (n < 0) {
	LOGE("select() on RFCOMM socket: %s (%d)",
	strerror(errno),
	errno);
	return -1;
	}
	return 0;
	}
	/* n must be equal to 1 and either rset or wset must have the
	file descriptor set. */
	LOGI("select() returned %d.", n);
	if (FD_ISSET(nat->rfcomm_sock, &rset) \|\|
	FD_ISSET(nat->rfcomm_sock, &wset)) {
	/* A trial async read() will tell us if everything is OK. */
	char ch;
	errno = 0;
	int nr = read(nat->rfcomm_sock, &ch, 1);
	/* It should be that nr != 1 because we just opened a socket
	and we haven't sent anything over it for the other side to
	respond... but one can't be paranoid enough.
	*/
	if (nr >= 0 \|\| errno != EAGAIN) {
	LOGE("RFCOMM async connect() error: %s (%d), nr = %d\n",
	strerror(errno),
	errno,
	nr);
	/* Clear the rfcomm_connected flag to cause this function
	to re-create the socket and re-attempt the connect()
	the next time it is called.
	*/
	nat->rfcomm_connected = 0;
	/* Restore the blocking properties of the socket. */
	fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags);
	return -1;
	}
	/* Restore the blocking properties of the socket. */
	fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags);
	LOGI("Successful RFCOMM socket connect.");
	nat->rfcomm_connected = 3; // input and output
	return 1;
	}
	#endif
	return -1;
	}

	static jboolean shutdownNative(JNIEnv *env, jobject obj,
	jboolean shutdownInput) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	/* NOTE: If you change the bcode to modify nat, make sure you
	add synchronize(this) to the method calling this native
	method.
	*/
	native_data_t *nat = get_native_data(env, obj);
	if (nat->rfcomm_sock < 0) {
	LOGE("socket(RFCOMM) error: socket not created");
	return JNI_FALSE;
	}
	int rc = shutdown(nat->rfcomm_sock,
	shutdownInput ? SHUT_RD : SHUT_WR);
	if (!rc) {
	nat->rfcomm_connected &=
	shutdownInput ? ~1 : ~2;
	return JNI_TRUE;
	}
	#endif
	return JNI_FALSE;
	}

	static jint isConnectedNative(JNIEnv *env, jobject obj) {
	LOGI(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	const native_data_t *nat = get_native_data(env, obj);
	return nat->rfcomm_connected;
	#endif
	return 0;
	}

	//@@@@@@@@@ bind to device???
	static jboolean bindNative(JNIEnv *env, jobject obj, jstring device,
	jint port) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH

	/* NOTE: If you change the code to modify nat, make sure you
	add synchronize(this) to the method calling this native
	method.
	*/
	const native_data_t *nat = get_native_data(env, obj);
	if (nat->rfcomm_sock < 0) {
	LOGE("socket(RFCOMM) error: socket not created");
	return JNI_FALSE;
	}

	struct sockaddr_rc laddr;
	int lm;

	lm = 0;
	/*
	lm \|= RFCOMM_LM_MASTER;
	lm \|= RFCOMM_LM_AUTH;
	lm \|= RFCOMM_LM_ENCRYPT;
	lm \|= RFCOMM_LM_SECURE;
	*/

	if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, sizeof(lm)) < 0) {
	LOGE("Can't set RFCOMM link mode");
	return JNI_FALSE;
	}

	laddr.rc_family = AF_BLUETOOTH;
	bacpy(&laddr.rc_bdaddr, BDADDR_ANY);
	laddr.rc_channel = port;

	if (bind(nat->rfcomm_sock, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) {
	LOGE("Can't bind RFCOMM socket");
	return JNI_FALSE;
	}

	env->SetIntField(obj, field_mPort, port);

	return JNI_TRUE;
	#endif
	return JNI_FALSE;
	}

	static jboolean listenNative(JNIEnv *env, jobject obj, jint backlog) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	/* NOTE: If you change the code to modify nat, make sure you
	add synchronize(this) to the method calling this native
	method.
	*/
	const native_data_t *nat = get_native_data(env, obj);
	if (nat->rfcomm_sock < 0) {
	LOGE("socket(RFCOMM) error: socket not created");
	return JNI_FALSE;
	}
	return listen(nat->rfcomm_sock, backlog) < 0 ? JNI_FALSE : JNI_TRUE;
	#else
	return JNI_FALSE;
	#endif
	}

	static int set_nb(int sk, bool nb) {
	int flags = fcntl(sk, F_GETFL);
	if (flags < 0) {
	LOGE("Can't get socket flags with fcntl(): %s (%d)",
	strerror(errno), errno);
	close(sk);
	return -1;
	}
	flags &= ~O_NONBLOCK;
	if (nb) flags \|= O_NONBLOCK;
	int status = fcntl(sk, F_SETFL, flags);
	if (status < 0) {
	LOGE("Can't set socket to nonblocking mode with fcntl(): %s (%d)",
	strerror(errno), errno);
	close(sk);
	return -1;
	}
	return 0;
	}

	// Note: the code should check at a higher level to see whether
	// listen() has been called.
	#ifdef HAVE_BLUETOOTH
	static int do_accept(JNIEnv* env, jobject object, int sock,
	jobject newsock,
	jfieldID out_address,
	bool must_succeed) {

	if (must_succeed && set_nb(sock, true) < 0)
	return -1;

	struct sockaddr_rc raddr;
	int alen = sizeof(raddr);
	int nsk = accept(sock, (struct sockaddr *) &raddr, &alen);
	if (nsk < 0) {
	LOGE("Error on accept from socket fd %d: %s (%d).",
	sock,
	strerror(errno),
	errno);
	if (must_succeed) set_nb(sock, false);
	return -1;
	}

	char addr[BTADDR_SIZE];
	get_bdaddr_as_string(&raddr.rc_bdaddr, addr);
	env->SetObjectField(newsock, out_address, env->NewStringUTF(addr));

	LOGI("Successful accept() on AG socket %d: new socket %d, address %s, RFCOMM channel %d",
	sock,
	nsk,
	addr,
	raddr.rc_channel);
	if (must_succeed) set_nb(sock, false);
	return nsk;
	}
	#endif /HAVE_BLUETOOTH/

	static jobject acceptNative(JNIEnv *env, jobject obj,
	jobject newsock, jint timeoutMs) {
	LOGV(__FUNCTION__);
	#ifdef HAVE_BLUETOOTH
	native_data_t *nat = get_native_data(env, obj);
	if (nat->rfcomm_sock < 0) {
	LOGE("socket(RFCOMM) error: socket not created");
	return JNI_FALSE;
	}

	if (newsock == NULL) {
	LOGE("%s: newsock = NULL\n", __FUNCTION__);
	return JNI_FALSE;
	}

	int nsk = -1;
	if (timeoutMs < 0) {
	/* block until accept() succeeds */
	nsk = do_accept(env, obj, nat->rfcomm_sock,
	newsock, field_mAddress, false);
	if (nsk < 0) {
	return NULL;
	}
	}
	else {
	/* wait with a timeout */

	struct pollfd fds;
	fds.fd = nat->rfcomm_sock;
	fds.events = POLLIN \| POLLPRI \| POLLOUT \| POLLERR;

	env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, 0);
	int n = poll(&fds, 1, timeoutMs);
	if (n <= 0) {
	if (n < 0) {
	LOGE("listening poll() on RFCOMM socket: %s (%d)",
	strerror(errno),
	errno);
	env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, timeoutMs);
	}
	else {
	LOGI("listening poll() on RFCOMM socket timed out");
	}
	return NULL;
	}

	LOGI("listening poll() on RFCOMM socket returned %d", n);
	if (fds.fd == nat->rfcomm_sock) {
	if (fds.revents & (POLLIN \| POLLPRI \| POLLOUT)) {
	LOGI("Accepting connection.\n");
	nsk = do_accept(env, obj, nat->rfcomm_sock,
	newsock, field_mAddress, true);
	if (nsk < 0) {
	return NULL;
	}
	}
	}
	}

	LOGI("Connection accepted, new socket fd = %d.", nsk);
	native_data_t *newnat = get_native_data(env, newsock);
	newnat->rfcomm_sock = nsk;
	newnat->rfcomm_connected = 3;
	return jniCreateFileDescriptor(env, nsk);
	#else
	return NULL;
	#endif
	}

	static JNINativeMethod sMethods[] = {
	/* name, signature, funcPtr */
	{"classInitNative", "()V", (void*)classInitNative},
	{"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative},
	{"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative},

	{"createNative", "()Ljava/io/FileDescriptor;", (void *)createNative},
	{"destroyNative", "()V", (void *)destroyNative},
	{"connectNative", "(Ljava/lang/String;I)Z", (void *)connectNative},
	{"connectAsyncNative", "(Ljava/lang/String;I)Z", (void *)connectAsyncNative},
	{"interruptAsyncConnectNative", "()Z", (void *)interruptAsyncConnectNative},
	{"waitForAsyncConnectNative", "(I)I", (void *)waitForAsyncConnectNative},
	{"shutdownNative", "(Z)Z", (void *)shutdownNative},
	{"isConnectedNative", "()I", (void *)isConnectedNative},

	{"bindNative", "(Ljava/lang/String;I)Z", (void*)bindNative},
	{"listenNative", "(I)Z", (void*)listenNative},
	{"acceptNative", "(Landroid/bluetooth/RfcommSocket;I)Ljava/io/FileDescriptor;", (void*)acceptNative},
	};

	int register_android_bluetooth_RfcommSocket(JNIEnv *env) {
	return AndroidRuntime::registerNativeMethods(env,
	"android/bluetooth/RfcommSocket", sMethods, NELEM(sMethods));
	}

	} /* namespace android */