Programs/bluetooth_android.c - brltty - Git at Google

 /*
  * BRLTTY - A background process providing access to the console screen (when in
  *          text mode) for a blind person using a refreshable braille display.
  *
  * Copyright (C) 1995-2023 by The BRLTTY Developers.
  *
  * BRLTTY comes with ABSOLUTELY NO WARRANTY.
  *
  * This is free software, placed under the terms of the
  * GNU Lesser General Public License, as published by the Free Software
  * Foundation; either version 2.1 of the License, or (at your option) any
  * later version. Please see the file LICENSE-LGPL for details.
  *
  * Web Page: http://brltty.app/
  *
  * This software is maintained by Dave Mielke <dave@mielke.cc>.
  */

 #include "prologue.h"

 #include <string.h>
 #include <errno.h>

 #include "log.h"
 #include "io_bluetooth.h"
 #include "bluetooth_internal.h"
 #include "async_handle.h"
 #include "async_io.h"
 #include "io_misc.h"
 #include "thread.h"
 #include "system_java.h"

 static jclass connectionClass = NULL;
 static jmethodID connectionConstructor = 0;
 static jmethodID canDiscoverMethod = 0;
 static jmethodID openMethod = 0;
 static jmethodID closeMethod = 0;
 static jmethodID writeMethod = 0;

 static int
 bthGetConnectionClass (JNIEnv *env) {
   return findJavaClass(
     env, &connectionClass, JAVA_OBJ_BRLTTY("BluetoothConnection")
   );
 }

 static int
 bthGetConnectionConstructor (JNIEnv *env) {
   return findJavaConstructor(
     env, &connectionConstructor, connectionClass,
     JAVA_SIG_CONSTRUCTOR(
       JAVA_SIG_LONG // address
     )
   );
 }

 static int
 bthGetCanDiscoverMethod (JNIEnv *env) {
   return findJavaInstanceMethod(
     env, &canDiscoverMethod, connectionClass, "canDiscover",
     JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
     )
   );
 }

 static int
 bthGetOpenMethod (JNIEnv *env) {
   return findJavaInstanceMethod(
     env, &openMethod, connectionClass, "open",
     JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
       JAVA_SIG_INT // inputPipe
       JAVA_SIG_INT // channel
       JAVA_SIG_BOOLEAN // secure
     )
   );
 }

 static int
 bthGetCloseMethod (JNIEnv *env) {
   return findJavaInstanceMethod(
     env, &closeMethod, connectionClass, "close",
     JAVA_SIG_METHOD(JAVA_SIG_VOID,
     )
   );
 }

 static int
 bthGetWriteMethod (JNIEnv *env) {
   return (findJavaInstanceMethod(
     env, &writeMethod, connectionClass, "write",
     JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
       JAVA_SIG_ARRAY(JAVA_SIG_BYTE)) // bytes
     )
   );
 }

 struct BluetoothConnectionExtensionStruct {
   JNIEnv *env;

   jobject connection;
   AsyncHandle inputMonitor;
   int inputPipe[2];
 };

 BluetoothConnectionExtension *
 bthNewConnectionExtension (uint64_t bda) {
   BluetoothConnectionExtension *bcx;

   if ((bcx = malloc(sizeof(*bcx)))) {
     memset(bcx, 0, sizeof(*bcx));

     bcx->inputPipe[0] = INVALID_FILE_DESCRIPTOR;
     bcx->inputPipe[1] = INVALID_FILE_DESCRIPTOR;

     if ((bcx->env = getJavaNativeInterface())) {
       if (bthGetConnectionClass(bcx->env)) {
         if (bthGetConnectionConstructor(bcx->env)) {
           jobject localReference = (*bcx->env)->NewObject(bcx->env, connectionClass, connectionConstructor, bda);

           if (!clearJavaException(bcx->env, 1)) {
             jobject globalReference = (*bcx->env)->NewGlobalRef(bcx->env, localReference);

             (*bcx->env)->DeleteLocalRef(bcx->env, localReference);
             localReference = NULL;

             if (globalReference) {
               bcx->connection = globalReference;
               return bcx;
             } else {
               logMallocError();
               clearJavaException(bcx->env, 0);
             }
           }
         }
       }
     }

     free(bcx);
   } else {
     logMallocError();
   }

   return NULL;
 }

 static void
 bthCancelInputMonitor (BluetoothConnectionExtension *bcx) {
   if (bcx->inputMonitor) {
     asyncCancelRequest(bcx->inputMonitor);
     bcx->inputMonitor = NULL;
   }
 }

 void
 bthReleaseConnectionExtension (BluetoothConnectionExtension *bcx) {
   bthCancelInputMonitor(bcx);

   if (bcx->connection) {
     if (bthGetCloseMethod(bcx->env)) {
       (*bcx->env)->CallVoidMethod(bcx->env, bcx->connection, closeMethod);
     }

     (*bcx->env)->DeleteGlobalRef(bcx->env, bcx->connection);
     clearJavaException(bcx->env, 1);
   }

   closeFile(&bcx->inputPipe[0]);
   closeFile(&bcx->inputPipe[1]);

   free(bcx);
 }

 typedef struct {
   BluetoothConnectionExtension *const bcx;
   uint8_t const channel;
   int const timeout;

   int error;
 } OpenBluetoothConnectionData;

 THREAD_FUNCTION(runOpenBluetoothConnection) {
   OpenBluetoothConnectionData *obc = argument;
   JNIEnv *env;

   if ((env = getJavaNativeInterface())) {
     if (pipe(obc->bcx->inputPipe) != -1) {
       if (setBlockingIo(obc->bcx->inputPipe[0], 0)) {
         if (bthGetOpenMethod(env)) {
           jboolean result = (*env)->CallBooleanMethod(env, obc->bcx->connection, openMethod,
                                                       obc->bcx->inputPipe[1], obc->channel, JNI_FALSE);

           if (!clearJavaException(env, 1)) {
             if (result == JNI_TRUE) {
               closeFile(&obc->bcx->inputPipe[1]);
               obc->error = 0;
               goto done;
             }
           }

           errno = EIO;
         }
       }

       closeFile(&obc->bcx->inputPipe[0]);
       closeFile(&obc->bcx->inputPipe[1]);
     } else {
       logSystemError("pipe");
     }
   }

   obc->error = errno;
 done:
   return NULL;
 }

 int
 bthOpenChannel (BluetoothConnectionExtension *bcx, uint8_t channel, int timeout) {
   OpenBluetoothConnectionData obc = {
     .bcx = bcx,
     .channel = channel,
     .timeout = timeout,

     .error = EIO
   };

   if (callThreadFunction("bluetooth-open", runOpenBluetoothConnection, &obc, NULL)) {
     if (!obc.error) return 1;
     errno = obc.error;
   }

   return 0;
 }

 int
 bthDiscoverChannel (
   uint8_t *channel, BluetoothConnectionExtension *bcx,
   const void *uuidBytes, size_t uuidLength,
   int timeout
 ) {
   JNIEnv *env = bcx->env;

   if (bthGetCanDiscoverMethod(env)) {
     jboolean result = (*env)->CallBooleanMethod(env, bcx->connection, canDiscoverMethod);

     if (!clearJavaException(env, 1)) {
       int yes = result == JNI_TRUE;

       if (yes) {
         logMessage(LOG_CATEGORY(BLUETOOTH_IO), "can discover serial port channel");
         *channel = 0;
       } else {
         errno = ENOENT;
       }

       return yes;
     }
   }

   errno = EIO;
   return 0;
 }

 int
 bthMonitorInput (BluetoothConnection *connection, AsyncMonitorCallback *callback, void *data) {
   BluetoothConnectionExtension *bcx = connection->extension;

   bthCancelInputMonitor(bcx);
   if (!callback) return 1;
   return asyncMonitorFileInput(&bcx->inputMonitor, bcx->inputPipe[0], callback, data);
 }

 int
 bthPollInput (BluetoothConnectionExtension *bcx, int timeout) {
   return awaitFileInput(bcx->inputPipe[0], timeout);
 }

 ssize_t
 bthGetData (
   BluetoothConnectionExtension *bcx, void *buffer, size_t size,
   int initialTimeout, int subsequentTimeout
 ) {
   return readFile(bcx->inputPipe[0], buffer, size, initialTimeout, subsequentTimeout);
 }

 ssize_t
 bthPutData (BluetoothConnectionExtension *bcx, const void *buffer, size_t size) {
   if (bthGetWriteMethod(bcx->env)) {
     jbyteArray bytes = (*bcx->env)->NewByteArray(bcx->env, size);

     if (bytes) {
       jboolean result;

       (*bcx->env)->SetByteArrayRegion(bcx->env, bytes, 0, size, buffer);
       result = (*bcx->env)->CallBooleanMethod(bcx->env, bcx->connection, writeMethod, bytes);
       (*bcx->env)->DeleteLocalRef(bcx->env, bytes);

       if (!clearJavaException(bcx->env, 1)) {
         if (result == JNI_TRUE) {
           return size;
         }
       }

       errno = EIO;
     } else {
       errno = ENOMEM;
     }
   } else {
     errno = ENOSYS;
   }

   logSystemError("Bluetooth write");
   return -1;
 }

 char *
 bthObtainDeviceName (uint64_t bda, int timeout) {
   char *name = NULL;
   JNIEnv *env = getJavaNativeInterface();

   if (env) {
     if (bthGetConnectionClass(env)) {
       static jmethodID method = 0;

       if (findJavaStaticMethod(env, &method, connectionClass, "getName",
                                JAVA_SIG_METHOD(JAVA_SIG_STRING,
                                                JAVA_SIG_LONG // address
                                               ))) {
         jstring jName = (*env)->CallStaticObjectMethod(env, connectionClass, method, bda);

         if (jName) {
           const char *cName = (*env)->GetStringUTFChars(env, jName, NULL);

           if (cName) {
             if (!(name = strdup(cName))) logMallocError();
             (*env)->ReleaseStringUTFChars(env, jName, cName);
           } else {
             logMallocError();
             clearJavaException(env, 0);
           }

           (*env)->DeleteLocalRef(env, jName);
         } else {
           logMallocError();
           clearJavaException(env, 0);
         }
       }
     }
   }

   return name;
 }

 static jmethodID getPairedDeviceCountMethod = 0;
 static jmethodID getPairedDeviceAddressMethod = 0;
 static jmethodID getPairedDeviceNameMethod = 0;

 static int
 bthGetPairedDeviceCountMethod (JNIEnv *env) {
   return findJavaStaticMethod(
     env, &getPairedDeviceCountMethod, connectionClass, "getPairedDeviceCount",
     JAVA_SIG_METHOD(JAVA_SIG_INT,
     )
   );
 }

 static int
 bthGetPairedDeviceAddressMethod (JNIEnv *env) {
   return findJavaStaticMethod(
     env, &getPairedDeviceAddressMethod, connectionClass, "getPairedDeviceAddress",
     JAVA_SIG_METHOD(JAVA_SIG_STRING,
       JAVA_SIG_INT // index
     )
   );
 }

 static int
 bthGetPairedDeviceNameMethod (JNIEnv *env) {
   return findJavaStaticMethod(
     env, &getPairedDeviceNameMethod, connectionClass, "getPairedDeviceName",
     JAVA_SIG_METHOD(JAVA_SIG_STRING,
       JAVA_SIG_INT // index
     )
   );
 }

 static JNIEnv *
 bthGetPairedDeviceMethods (void) {
   JNIEnv *env = getJavaNativeInterface();

   if (env) {
     if (bthGetConnectionClass(env)) {
       if (bthGetPairedDeviceCountMethod(env)) {
         if (bthGetPairedDeviceAddressMethod(env)) {
           if (bthGetPairedDeviceNameMethod(env)) {
             return env;
           }
         }
       }
     }
   }

   return NULL;
 }

 void
 bthProcessDiscoveredDevices (
   DiscoveredBluetoothDeviceTester *testDevice, void *data
 ) {
   JNIEnv *env = bthGetPairedDeviceMethods();

   if (env) {
     jint count = (*env)->CallStaticIntMethod(env, connectionClass, getPairedDeviceCountMethod);

     for (jint index=0; index<count; index+=1) {
       int found = 0;
       jstring jAddress = (*env)->CallStaticObjectMethod(env, connectionClass, getPairedDeviceAddressMethod, index);

       if (jAddress) {
         const char *cAddress = (*env)->GetStringUTFChars(env, jAddress, NULL);

         if (cAddress) {
           uint64_t address;

           if (bthParseAddress(&address, cAddress)) {
             jstring jName = (*env)->CallStaticObjectMethod(env, connectionClass, getPairedDeviceNameMethod, index);
             const char *cName = jName? (*env)->GetStringUTFChars(env, jName, NULL): NULL;

             const DiscoveredBluetoothDevice device = {
               .address = address,
               .name = cName,
               .paired = 1
             };

             if (testDevice(&device, data)) found = 1;
             if (cName) (*env)->ReleaseStringUTFChars(env, jName, cName);
             if (jName) (*env)->DeleteLocalRef(env, jName);
           }

           (*env)->ReleaseStringUTFChars(env, jAddress, cAddress);
         }

         (*env)->DeleteLocalRef(env, jAddress);
       }

       if (found) break;
     }
   }
 }
	/*
	* BRLTTY - A background process providing access to the console screen (when in
	* text mode) for a blind person using a refreshable braille display.
	*
	* Copyright (C) 1995-2023 by The BRLTTY Developers.
	*
	* BRLTTY comes with ABSOLUTELY NO WARRANTY.
	*
	* This is free software, placed under the terms of the
	* GNU Lesser General Public License, as published by the Free Software
	* Foundation; either version 2.1 of the License, or (at your option) any
	* later version. Please see the file LICENSE-LGPL for details.
	*
	* Web Page: http://brltty.app/
	*
	* This software is maintained by Dave Mielke <dave@mielke.cc>.
	*/

	#include "prologue.h"

	#include <string.h>
	#include <errno.h>

	#include "log.h"
	#include "io_bluetooth.h"
	#include "bluetooth_internal.h"
	#include "async_handle.h"
	#include "async_io.h"
	#include "io_misc.h"
	#include "thread.h"
	#include "system_java.h"

	static jclass connectionClass = NULL;
	static jmethodID connectionConstructor = 0;
	static jmethodID canDiscoverMethod = 0;
	static jmethodID openMethod = 0;
	static jmethodID closeMethod = 0;
	static jmethodID writeMethod = 0;

	static int
	bthGetConnectionClass (JNIEnv *env) {
	return findJavaClass(
	env, &connectionClass, JAVA_OBJ_BRLTTY("BluetoothConnection")
	);
	}

	static int
	bthGetConnectionConstructor (JNIEnv *env) {
	return findJavaConstructor(
	env, &connectionConstructor, connectionClass,
	JAVA_SIG_CONSTRUCTOR(
	JAVA_SIG_LONG // address
	)
	);
	}

	static int
	bthGetCanDiscoverMethod (JNIEnv *env) {
	return findJavaInstanceMethod(
	env, &canDiscoverMethod, connectionClass, "canDiscover",
	JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
	)
	);
	}

	static int
	bthGetOpenMethod (JNIEnv *env) {
	return findJavaInstanceMethod(
	env, &openMethod, connectionClass, "open",
	JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
	JAVA_SIG_INT // inputPipe
	JAVA_SIG_INT // channel
	JAVA_SIG_BOOLEAN // secure
	)
	);
	}

	static int
	bthGetCloseMethod (JNIEnv *env) {
	return findJavaInstanceMethod(
	env, &closeMethod, connectionClass, "close",
	JAVA_SIG_METHOD(JAVA_SIG_VOID,
	)
	);
	}

	static int
	bthGetWriteMethod (JNIEnv *env) {
	return (findJavaInstanceMethod(
	env, &writeMethod, connectionClass, "write",
	JAVA_SIG_METHOD(JAVA_SIG_BOOLEAN,
	JAVA_SIG_ARRAY(JAVA_SIG_BYTE)) // bytes
	)
	);
	}

	struct BluetoothConnectionExtensionStruct {
	JNIEnv *env;

	jobject connection;
	AsyncHandle inputMonitor;
	int inputPipe[2];
	};

	BluetoothConnectionExtension *
	bthNewConnectionExtension (uint64_t bda) {
	BluetoothConnectionExtension *bcx;

	if ((bcx = malloc(sizeof(*bcx)))) {
	memset(bcx, 0, sizeof(*bcx));

	bcx->inputPipe[0] = INVALID_FILE_DESCRIPTOR;
	bcx->inputPipe[1] = INVALID_FILE_DESCRIPTOR;

	if ((bcx->env = getJavaNativeInterface())) {
	if (bthGetConnectionClass(bcx->env)) {
	if (bthGetConnectionConstructor(bcx->env)) {
	jobject localReference = (*bcx->env)->NewObject(bcx->env, connectionClass, connectionConstructor, bda);

	if (!clearJavaException(bcx->env, 1)) {
	jobject globalReference = (*bcx->env)->NewGlobalRef(bcx->env, localReference);

	(*bcx->env)->DeleteLocalRef(bcx->env, localReference);
	localReference = NULL;

	if (globalReference) {
	bcx->connection = globalReference;
	return bcx;
	} else {
	logMallocError();
	clearJavaException(bcx->env, 0);
	}
	}
	}
	}
	}

	free(bcx);
	} else {
	logMallocError();
	}

	return NULL;
	}

	static void
	bthCancelInputMonitor (BluetoothConnectionExtension *bcx) {
	if (bcx->inputMonitor) {
	asyncCancelRequest(bcx->inputMonitor);
	bcx->inputMonitor = NULL;
	}
	}

	void
	bthReleaseConnectionExtension (BluetoothConnectionExtension *bcx) {
	bthCancelInputMonitor(bcx);

	if (bcx->connection) {
	if (bthGetCloseMethod(bcx->env)) {
	(*bcx->env)->CallVoidMethod(bcx->env, bcx->connection, closeMethod);
	}

	(*bcx->env)->DeleteGlobalRef(bcx->env, bcx->connection);
	clearJavaException(bcx->env, 1);
	}

	closeFile(&bcx->inputPipe[0]);
	closeFile(&bcx->inputPipe[1]);

	free(bcx);
	}

	typedef struct {
	BluetoothConnectionExtension *const bcx;
	uint8_t const channel;
	int const timeout;

	int error;
	} OpenBluetoothConnectionData;

	THREAD_FUNCTION(runOpenBluetoothConnection) {
	OpenBluetoothConnectionData *obc = argument;
	JNIEnv *env;

	if ((env = getJavaNativeInterface())) {
	if (pipe(obc->bcx->inputPipe) != -1) {
	if (setBlockingIo(obc->bcx->inputPipe[0], 0)) {
	if (bthGetOpenMethod(env)) {
	jboolean result = (*env)->CallBooleanMethod(env, obc->bcx->connection, openMethod,
	obc->bcx->inputPipe[1], obc->channel, JNI_FALSE);

	if (!clearJavaException(env, 1)) {
	if (result == JNI_TRUE) {
	closeFile(&obc->bcx->inputPipe[1]);
	obc->error = 0;
	goto done;
	}
	}

	errno = EIO;
	}
	}

	closeFile(&obc->bcx->inputPipe[0]);
	closeFile(&obc->bcx->inputPipe[1]);
	} else {
	logSystemError("pipe");
	}
	}

	obc->error = errno;
	done:
	return NULL;
	}

	int
	bthOpenChannel (BluetoothConnectionExtension *bcx, uint8_t channel, int timeout) {
	OpenBluetoothConnectionData obc = {
	.bcx = bcx,
	.channel = channel,
	.timeout = timeout,

	.error = EIO
	};

	if (callThreadFunction("bluetooth-open", runOpenBluetoothConnection, &obc, NULL)) {
	if (!obc.error) return 1;
	errno = obc.error;
	}

	return 0;
	}

	int
	bthDiscoverChannel (
	uint8_t channel, BluetoothConnectionExtension bcx,
	const void *uuidBytes, size_t uuidLength,
	int timeout
	) {
	JNIEnv *env = bcx->env;

	if (bthGetCanDiscoverMethod(env)) {
	jboolean result = (*env)->CallBooleanMethod(env, bcx->connection, canDiscoverMethod);

	if (!clearJavaException(env, 1)) {
	int yes = result == JNI_TRUE;

	if (yes) {
	logMessage(LOG_CATEGORY(BLUETOOTH_IO), "can discover serial port channel");
	*channel = 0;
	} else {
	errno = ENOENT;
	}

	return yes;
	}
	}

	errno = EIO;
	return 0;
	}

	int
	bthMonitorInput (BluetoothConnection connection, AsyncMonitorCallback callback, void *data) {
	BluetoothConnectionExtension *bcx = connection->extension;

	bthCancelInputMonitor(bcx);
	if (!callback) return 1;
	return asyncMonitorFileInput(&bcx->inputMonitor, bcx->inputPipe[0], callback, data);
	}

	int
	bthPollInput (BluetoothConnectionExtension *bcx, int timeout) {
	return awaitFileInput(bcx->inputPipe[0], timeout);
	}

	ssize_t
	bthGetData (
	BluetoothConnectionExtension bcx, void buffer, size_t size,
	int initialTimeout, int subsequentTimeout
	) {
	return readFile(bcx->inputPipe[0], buffer, size, initialTimeout, subsequentTimeout);
	}

	ssize_t
	bthPutData (BluetoothConnectionExtension bcx, const void buffer, size_t size) {
	if (bthGetWriteMethod(bcx->env)) {
	jbyteArray bytes = (*bcx->env)->NewByteArray(bcx->env, size);

	if (bytes) {
	jboolean result;

	(*bcx->env)->SetByteArrayRegion(bcx->env, bytes, 0, size, buffer);
	result = (*bcx->env)->CallBooleanMethod(bcx->env, bcx->connection, writeMethod, bytes);
	(*bcx->env)->DeleteLocalRef(bcx->env, bytes);

	if (!clearJavaException(bcx->env, 1)) {
	if (result == JNI_TRUE) {
	return size;
	}
	}

	errno = EIO;
	} else {
	errno = ENOMEM;
	}
	} else {
	errno = ENOSYS;
	}

	logSystemError("Bluetooth write");
	return -1;
	}

	char *
	bthObtainDeviceName (uint64_t bda, int timeout) {
	char *name = NULL;
	JNIEnv *env = getJavaNativeInterface();

	if (env) {
	if (bthGetConnectionClass(env)) {
	static jmethodID method = 0;

	if (findJavaStaticMethod(env, &method, connectionClass, "getName",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	JAVA_SIG_LONG // address
	))) {
	jstring jName = (*env)->CallStaticObjectMethod(env, connectionClass, method, bda);

	if (jName) {
	const char cName = (env)->GetStringUTFChars(env, jName, NULL);

	if (cName) {
	if (!(name = strdup(cName))) logMallocError();
	(*env)->ReleaseStringUTFChars(env, jName, cName);
	} else {
	logMallocError();
	clearJavaException(env, 0);
	}

	(*env)->DeleteLocalRef(env, jName);
	} else {
	logMallocError();
	clearJavaException(env, 0);
	}
	}
	}
	}

	return name;
	}

	static jmethodID getPairedDeviceCountMethod = 0;
	static jmethodID getPairedDeviceAddressMethod = 0;
	static jmethodID getPairedDeviceNameMethod = 0;

	static int
	bthGetPairedDeviceCountMethod (JNIEnv *env) {
	return findJavaStaticMethod(
	env, &getPairedDeviceCountMethod, connectionClass, "getPairedDeviceCount",
	JAVA_SIG_METHOD(JAVA_SIG_INT,
	)
	);
	}

	static int
	bthGetPairedDeviceAddressMethod (JNIEnv *env) {
	return findJavaStaticMethod(
	env, &getPairedDeviceAddressMethod, connectionClass, "getPairedDeviceAddress",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	JAVA_SIG_INT // index
	)
	);
	}

	static int
	bthGetPairedDeviceNameMethod (JNIEnv *env) {
	return findJavaStaticMethod(
	env, &getPairedDeviceNameMethod, connectionClass, "getPairedDeviceName",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	JAVA_SIG_INT // index
	)
	);
	}

	static JNIEnv *
	bthGetPairedDeviceMethods (void) {
	JNIEnv *env = getJavaNativeInterface();

	if (env) {
	if (bthGetConnectionClass(env)) {
	if (bthGetPairedDeviceCountMethod(env)) {
	if (bthGetPairedDeviceAddressMethod(env)) {
	if (bthGetPairedDeviceNameMethod(env)) {
	return env;
	}
	}
	}
	}
	}

	return NULL;
	}

	void
	bthProcessDiscoveredDevices (
	DiscoveredBluetoothDeviceTester testDevice, void data
	) {
	JNIEnv *env = bthGetPairedDeviceMethods();

	if (env) {
	jint count = (*env)->CallStaticIntMethod(env, connectionClass, getPairedDeviceCountMethod);

	for (jint index=0; index<count; index+=1) {
	int found = 0;
	jstring jAddress = (*env)->CallStaticObjectMethod(env, connectionClass, getPairedDeviceAddressMethod, index);

	if (jAddress) {
	const char cAddress = (env)->GetStringUTFChars(env, jAddress, NULL);

	if (cAddress) {
	uint64_t address;

	if (bthParseAddress(&address, cAddress)) {
	jstring jName = (*env)->CallStaticObjectMethod(env, connectionClass, getPairedDeviceNameMethod, index);
	const char cName = jName? (env)->GetStringUTFChars(env, jName, NULL): NULL;

	const DiscoveredBluetoothDevice device = {
	.address = address,
	.name = cName,
	.paired = 1
	};

	if (testDevice(&device, data)) found = 1;
	if (cName) (*env)->ReleaseStringUTFChars(env, jName, cName);
	if (jName) (*env)->DeleteLocalRef(env, jName);
	}

	(*env)->ReleaseStringUTFChars(env, jAddress, cAddress);
	}

	(*env)->DeleteLocalRef(env, jAddress);
	}

	if (found) break;
	}
	}
	}