diff options
36 files changed, 2526 insertions, 17 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 66dcdb67..e8291200 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required (VERSION 3.1) +cmake_minimum_required (VERSION 3.1.0 FATAL_ERROR) project (tinyb) FIND_PACKAGE (Threads REQUIRED) @@ -56,9 +56,9 @@ IF(WARNINGS) IF(UNIX) IF(CMAKE_COMPILER_IS_GNUCC) ADD_DEFINITIONS(-Wall -Wextra) - ENDIF(CMAKE_COMPILER_IS_GNUCC) - ENDIF(UNIX) - ENDIF(WARNINGS) + ENDIF(CMAKE_COMPILER_IS_GNUCC) + ENDIF(UNIX) +ENDIF(WARNINGS) IF(DEBUG) IF(UNIX) @@ -71,8 +71,7 @@ ENDIF(DEBUG) find_path (SYSTEM_USR_DIR "stdlib.h") include_directories (${SYSTEM_USR_DIR}) -option (BUILDSWIG "Build swig modules." ON) -option (BUILDSWIGJAVA "Build Java API." OFF) +option (BUILDJAVA "Build Java API." OFF) add_subdirectory (src) add_subdirectory (examples) diff --git a/java/BluetoothAdapter.java b/java/BluetoothAdapter.java new file mode 100644 index 00000000..db2045fd --- /dev/null +++ b/java/BluetoothAdapter.java @@ -0,0 +1,43 @@ +import java.util.*; + +public class BluetoothAdapter extends BluetoothObject +{ + private long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothAdapter clone(); + public native boolean startDiscovery(); + public native boolean stopDiscovery(); + public native List<BluetoothDevice> getDevices(); + public native String getAddress(); + public native String getName(); + public native String getAlias(); + public native void setAlias(String value); + public native long getBluetoothClass(); + public native boolean getPowered(); + public native void setPowered(boolean value); + public native boolean getDiscoverable(); + public native void setDiscoverable(boolean value); + public native long getDiscoverableTimeout(); + public native void setDiscoverableTimout(long value); + public native boolean getPairable(); + public native void setPairable(boolean value); + public native long getPairableTimeout(); + public native void setPairableTimeout(long value); + public native boolean getDiscovering(); + public native String[] getUuids(); + public native String getModalias(); + + private native void delete(); + + private BluetoothAdapter(long instance) + { + super(instance); + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothCallback.java b/java/BluetoothCallback.java new file mode 100644 index 00000000..a4da9c74 --- /dev/null +++ b/java/BluetoothCallback.java @@ -0,0 +1,9 @@ +public abstract class BluetoothCallback implements Runnable +{ + protected BluetoothObject bObj; + + /* + * public void run() is missing because it will be implemented + * in children classes + */ +} diff --git a/java/BluetoothDevice.java b/java/BluetoothDevice.java new file mode 100644 index 00000000..06f49222 --- /dev/null +++ b/java/BluetoothDevice.java @@ -0,0 +1,50 @@ +import java.util.*; + +public class BluetoothDevice extends BluetoothObject +{ + private long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothDevice clone(); + public native boolean disconnect(); + public native boolean connect(); + public native boolean connectProfile(String arg_UUID); + public native boolean disconnectProfile(String arg_UUID); + public native boolean pair(); + public native boolean cancelPairing(); + public native List<BluetoothGattService> getServices(); + public native String getAddress(); + public native String getName(); + public native String getAlias(); + public native void setAlias(String value); + public native int getBluetoothClass(); + public native short getAppearance(); + public native String getIcon(); + public native boolean getPaired(); + public native boolean getTrusted(); + public native void setTrusted(boolean value); + public native boolean getBlocked(); + public native void setBlocked(boolean value); + public native boolean getLegacyPairing(); + public native short getRssi(); + public native boolean getConnected(); + public native String[] getUuids(); + public native String getModalias(); + public native BluetoothAdapter getAdapter(); + + private native void delete(); + /*public BluetoothDevice() + { + System.out.println("mda"); + }*/ + private BluetoothDevice(long instance) + { + super(instance); + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothEvent.java b/java/BluetoothEvent.java new file mode 100644 index 00000000..611a51dd --- /dev/null +++ b/java/BluetoothEvent.java @@ -0,0 +1,27 @@ +import java.util.*; + +public class BluetoothEvent +{ + private long nativeInstance; + + public native BluetoothType getType(); + public native String getName(); + public native String getIdentifier(); + public native boolean executeCallback(); + public native boolean hasCallback(); + + private native void init(BluetoothType type, String name, String identifier, + BluetoothObject parent, BluetoothCallback cb, Object data); + private native void delete(); + + public BluetoothEvent(BluetoothType type, String name, String identifier, + BluetoothObject parent, BluetoothCallback cb, Object data) + { + init(type, name, identifier, parent, cb, data); + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothGattCharacteristic.java b/java/BluetoothGattCharacteristic.java new file mode 100644 index 00000000..41f814b9 --- /dev/null +++ b/java/BluetoothGattCharacteristic.java @@ -0,0 +1,33 @@ +import java.util.*; + +public class BluetoothGattCharacteristic extends BluetoothObject +{ + private long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothGattCharacteristic clone(); + public native List<Byte> readValue(); + public native boolean writeValue(List<Byte> argValue); + public native boolean startNotify(); + public native boolean stopNotify(); + public native String getUuid(); + public native BluetoothGattService getService(); + public native List<Byte> getValue(); + public native boolean getNotifying(); + public native String[] getFlags(); + public native List<BluetoothGattDescriptor> getDescriptors(); + + private native void init(BluetoothGattCharacteristic obj); + private native void delete(); + + private BluetoothGattCharacteristic(long instance) + { + super(instance); + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothGattDescriptor.java b/java/BluetoothGattDescriptor.java new file mode 100644 index 00000000..c378c2fa --- /dev/null +++ b/java/BluetoothGattDescriptor.java @@ -0,0 +1,28 @@ +import java.util.*; + +public class BluetoothGattDescriptor extends BluetoothObject +{ + public long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothAdapter clone(); + + public native List<Byte> readValue(); + public native boolean writeValue(List<Byte> argValue); + public native String getUuid(); + public native BluetoothGattCharacteristic getCharacteristic(); + public native List<Byte> getValue(); + + private native void delete(); + + private BluetoothGattDescriptor(long instance) + { + super(instance); + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothGattService.java b/java/BluetoothGattService.java new file mode 100644 index 00000000..4e51f2fd --- /dev/null +++ b/java/BluetoothGattService.java @@ -0,0 +1,26 @@ +import java.util.*; + +public class BluetoothGattService extends BluetoothObject +{ + private long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothAdapter clone(); + public native String getUuid(); + public native BluetoothDevice getDevice(); + public native boolean getPrimary(); + public native List<BluetoothGattCharacteristic> getCharacteristics(); + + private native void delete(); + + private BluetoothGattService(long instance) + { + super(instance); + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothManager.java b/java/BluetoothManager.java new file mode 100644 index 00000000..00d64541 --- /dev/null +++ b/java/BluetoothManager.java @@ -0,0 +1,40 @@ +import java.util.*; + +public class BluetoothManager +{ + private long nativeInstance; + private static BluetoothManager inst; + + public native BluetoothType getBluetoothType(); + public native BluetoothObject getObject(BluetoothType type, String name, + String identifier, BluetoothObject parent); + public native List<BluetoothObject> getObjects(BluetoothType type, String name, + String identifier, BluetoothObject parent); + public native List<BluetoothAdapter> getAdapters(); + public native List<BluetoothDevice> getDevices(); + public native List<BluetoothGattService> getServices(); + public native boolean setDefaultAdapter(BluetoothAdapter adapter); + public native boolean startDiscovery(); + public native boolean stopDiscovery(); + + private native void init(); + private native void delete(); + private BluetoothManager() + { + init(); + } + public static synchronized BluetoothManager getBluetoothManager() + { + if (inst == null) + { + inst = new BluetoothManager(); + inst.init(); + } + return inst; + } + + protected void finalize() + { + delete(); + } +} diff --git a/java/BluetoothObject.java b/java/BluetoothObject.java new file mode 100644 index 00000000..2965b5a1 --- /dev/null +++ b/java/BluetoothObject.java @@ -0,0 +1,31 @@ +import java.util.*; + +public class BluetoothObject +{ + long nativeInstance; + + public native BluetoothType getBluetoothType(); + public native BluetoothObject clone(); + + private native void delete(); + private native boolean operatorEqual(BluetoothObject obj); + + protected BluetoothObject(long instance) + { + nativeInstance = instance; + } + + protected void finalize() + { + delete(); + } + + public boolean equals(BluetoothObject obj) + { + if (obj == null) + { + return false; + } + return operatorEqual(obj); + } +} diff --git a/java/BluetoothType.java b/java/BluetoothType.java new file mode 100644 index 00000000..d533a837 --- /dev/null +++ b/java/BluetoothType.java @@ -0,0 +1,8 @@ +public enum BluetoothType +{ + NONE, ADAPTER, DEVICE, + GATT_SERVICE, GATT_CHARACTERISTIC, + GATT_DESCRIPTOR; + + private long nativeInstance; +} diff --git a/java/ObjectArgCallback.java b/java/ObjectArgCallback.java new file mode 100644 index 00000000..e8468144 --- /dev/null +++ b/java/ObjectArgCallback.java @@ -0,0 +1,14 @@ +public class ObjectArgCallback extends BluetoothCallback +{ + private Object callbackArg; + + public ObjectArgCallback(BluetoothObject bObj, Object callbackArg) + { + this.bObj = bObj; + this.callbackArg = callbackArg; + } + + public void run() + { + } +} diff --git a/java/ObjectArrayArgCallback.java b/java/ObjectArrayArgCallback.java new file mode 100644 index 00000000..9a5c5e64 --- /dev/null +++ b/java/ObjectArrayArgCallback.java @@ -0,0 +1,14 @@ +public class ObjectArrayArgCallback extends BluetoothCallback +{ + private Object[] callbackArg; + + public ObjectArrayArgCallback(BluetoothObject bObj, Object[] callbackArg) + { + this.bObj = bObj; + this.callbackArg = callbackArg; + } + + public void run() + { + } +} diff --git a/java/jni/BluetoothAdapter.cxx b/java/jni/BluetoothAdapter.cxx new file mode 100644 index 00000000..56b568e2 --- /dev/null +++ b/java/jni/BluetoothAdapter.cxx @@ -0,0 +1,212 @@ +#include "tinyb/BluetoothAdapter.hpp" +#include "tinyb/BluetoothDevice.hpp" +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothAdapter.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothAdapter_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "ADAPTER"); +} + +jobject Java_BluetoothAdapter_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothAdapter>(env, obj, "BluetoothAdapter"); +} + +jboolean Java_BluetoothAdapter_startDiscovery(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->start_discovery() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothAdapter_stopDiscovery(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->stop_discovery() ? JNI_TRUE : JNI_FALSE; +} + +jobject Java_BluetoothAdapter_getDevices(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::vector<std::unique_ptr<BluetoothDevice>> array = obj_adapter->get_devices(); + jobject result = convert_vector_to_jobject<BluetoothDevice>(env, array, + "BluetoothDevice", + "(J)V"); + + return result; +} + +jstring Java_BluetoothAdapter_getAddress(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::string address = obj_adapter->get_address(); + + return env->NewStringUTF((const char *)address.c_str()); +} + +jstring Java_BluetoothAdapter_getName(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::string name = obj_adapter->get_name(); + + return env->NewStringUTF((const char *)name.c_str()); +} + +jstring Java_BluetoothAdapter_getAlias(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::string alias = obj_adapter->get_alias(); + + return env->NewStringUTF((const char *)alias.c_str()); +} + +void Java_BluetoothAdapter_setAlias(JNIEnv *env, jobject obj, jstring str) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + jboolean is_copy = JNI_TRUE; + const char *str_chars = (char *)env->GetStringUTFChars(str, &is_copy); + const std::string string_to_write = std::string(str_chars); + + env->ReleaseStringUTFChars(str, str_chars); + + obj_adapter->set_alias(string_to_write); +} + +jlong Java_BluetoothAdapter_getBluetoothClass(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return (jlong)obj_adapter->get_class(); +} + +jboolean Java_BluetoothAdapter_getPowered(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->get_powered() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothAdapter_setPowered(JNIEnv *env, jobject obj, jboolean val) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + bool val_to_write = from_jboolean_to_bool(val); + obj_adapter->set_powered(val_to_write); +} + +jboolean Java_BluetoothAdapter_getDiscoverable(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->get_discoverable() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothAdapter_setDiscoverable(JNIEnv *env, jobject obj, jboolean val) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + bool val_to_write = from_jboolean_to_bool(val); + obj_adapter->set_discoverable(val_to_write); +} + +jlong Java_BluetoothAdapter_getDiscoverableTimeout(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return (jlong)obj_adapter->get_discoverable_timeout(); +} + +void Java_BluetoothAdapter_setDiscoverableTimout(JNIEnv *env, jobject obj, jlong timeout) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + if (timeout < 0) + { + throw std::invalid_argument("timeout argument is negative\n"); + } + obj_adapter->set_discoverable_timeout((unsigned int)timeout); +} + +jboolean Java_BluetoothAdapter_getPairable(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->get_pairable() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothAdapter_setPairable(JNIEnv *env, jobject obj, jboolean val) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + bool val_to_write = from_jboolean_to_bool(val); + obj_adapter->set_pairable(val_to_write); +} + +jlong Java_BluetoothAdapter_getPairableTimeout(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return (jlong)obj_adapter->get_pairable_timeout(); +} + +void Java_BluetoothAdapter_setPairableTimeout(JNIEnv *env, jobject obj, jlong timeout) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + if (timeout < 0) + { + throw std::invalid_argument("timeout argument is negative\n"); + } + obj_adapter->set_pairable_timeout((unsigned int)timeout); +} + +jboolean Java_BluetoothAdapter_getDiscovering(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + + return obj_adapter->get_discovering() ? JNI_TRUE : JNI_FALSE; +} + +jobjectArray Java_BluetoothAdapter_getUuids(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::vector<std::string> uuids = obj_adapter->get_uuids(); + unsigned int uuids_size = uuids.size(); + + jclass string_class = search_class(env, "Ljava/lang/String;"); + jobjectArray result = env->NewObjectArray(uuids_size, string_class, 0); + + for (unsigned int i = 0; i < uuids_size; ++i) + { + std::string str_elem = uuids.at(i); + jobject elem = env->NewStringUTF((const char *)str_elem.c_str()); + env->SetObjectArrayElement(result, i, elem); + } + + return result; +} + +jstring Java_BluetoothAdapter_getModalias(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *obj_adapter = getInstance<BluetoothAdapter>(env, obj); + std::string modalias = obj_adapter->get_modalias(); + + return env->NewStringUTF((const char *)modalias.c_str()); +} + +void Java_BluetoothAdapter_delete(JNIEnv *env, jobject obj) +{ + BluetoothAdapter *adapter = getInstance<BluetoothAdapter>(env, obj); + delete adapter; +} + diff --git a/java/jni/BluetoothAdapter.h b/java/jni/BluetoothAdapter.h new file mode 100644 index 00000000..688979aa --- /dev/null +++ b/java/jni/BluetoothAdapter.h @@ -0,0 +1,205 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothAdapter */ + +#ifndef _Included_BluetoothAdapter +#define _Included_BluetoothAdapter +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothAdapter + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothAdapter_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: clone + * Signature: ()LBluetoothAdapter; + */ +JNIEXPORT jobject JNICALL Java_BluetoothAdapter_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: startDiscovery + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_startDiscovery + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: stopDiscovery + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_stopDiscovery + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getDevices + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothAdapter_getDevices + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getAddress + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothAdapter_getAddress + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getName + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothAdapter_getName + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getAlias + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothAdapter_getAlias + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setAlias + * Signature: (Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setAlias + (JNIEnv *, jobject, jstring); + +/* + * Class: BluetoothAdapter + * Method: getBluetoothClass + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_BluetoothAdapter_getBluetoothClass + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getPowered + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_getPowered + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setPowered + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setPowered + (JNIEnv *, jobject, jboolean); + +/* + * Class: BluetoothAdapter + * Method: getDiscoverable + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_getDiscoverable + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setDiscoverable + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setDiscoverable + (JNIEnv *, jobject, jboolean); + +/* + * Class: BluetoothAdapter + * Method: getDiscoverableTimeout + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_BluetoothAdapter_getDiscoverableTimeout + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setDiscoverableTimout + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setDiscoverableTimout + (JNIEnv *, jobject, jlong); + +/* + * Class: BluetoothAdapter + * Method: getPairable + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_getPairable + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setPairable + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setPairable + (JNIEnv *, jobject, jboolean); + +/* + * Class: BluetoothAdapter + * Method: getPairableTimeout + * Signature: ()J + */ +JNIEXPORT jlong JNICALL Java_BluetoothAdapter_getPairableTimeout + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: setPairableTimeout + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_setPairableTimeout + (JNIEnv *, jobject, jlong); + +/* + * Class: BluetoothAdapter + * Method: getDiscovering + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothAdapter_getDiscovering + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getUuids + * Signature: ()[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_BluetoothAdapter_getUuids + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: getModalias + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothAdapter_getModalias + (JNIEnv *, jobject); + +/* + * Class: BluetoothAdapter + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothAdapter_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothCallback.h b/java/jni/BluetoothCallback.h new file mode 100644 index 00000000..fe28bd5d --- /dev/null +++ b/java/jni/BluetoothCallback.h @@ -0,0 +1,13 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothCallback */ + +#ifndef _Included_BluetoothCallback +#define _Included_BluetoothCallback +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothDevice.cxx b/java/jni/BluetoothDevice.cxx new file mode 100644 index 00000000..0dcf9327 --- /dev/null +++ b/java/jni/BluetoothDevice.cxx @@ -0,0 +1,255 @@ +#include "tinyb/BluetoothAdapter.hpp" +#include "tinyb/BluetoothDevice.hpp" +#include "tinyb/BluetoothGattService.hpp" +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothDevice.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothAdapter_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "DEVICE"); +} + +jobject Java_BluetoothDevice_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothDevice>(env, obj, "BluetoothDevice"); +} + +jboolean Java_BluetoothDevice_disconnect(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->disconnect() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothDevice_connect(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->connect() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothDevice_connectProfile(JNIEnv *env, jobject obj, jstring str) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + jboolean is_copy = JNI_TRUE; + const char *str_chars = (char *)env->GetStringUTFChars(str, &is_copy); + const std::string string_to_write = std::string(str_chars); + + env->ReleaseStringUTFChars(str, str_chars); + + return obj_device->connect_profile(string_to_write); +} + +jboolean Java_BluetoothDevice_disconnectProfile(JNIEnv *env, jobject obj, jstring str) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + jboolean is_copy = JNI_TRUE; + const char *str_chars = (char *)env->GetStringUTFChars(str, &is_copy); + const std::string string_to_write = std::string(str_chars); + + env->ReleaseStringUTFChars(str, str_chars); + + return obj_device->disconnect_profile(string_to_write); +} + +jboolean Java_BluetoothDevice_pair(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->pair() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothDevice_cancelPairing(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->cancel_pairing() ? JNI_TRUE : JNI_FALSE; +} + +jobject Java_BluetoothDevice_getServices(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::vector<std::unique_ptr<BluetoothGattService>> array = obj_device->get_services(); + jobject result = convert_vector_to_jobject<BluetoothGattService>(env, array, + "BluetoothGattService", + "(J)V"); + + return result; +} + +jstring Java_BluetoothDevice_getAddress(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::string address = obj_device->get_address(); + + return env->NewStringUTF((const char *)address.c_str()); +} + +jstring Java_BluetoothDevice_getName(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::string name = obj_device->get_name(); + + return env->NewStringUTF((const char *)name.c_str()); +} + +jstring Java_BluetoothDevice_getAlias(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::string alias = obj_device->get_alias(); + + return env->NewStringUTF((const char *)alias.c_str()); +} + +void Java_BluetoothDevice_setAlias(JNIEnv *env, jobject obj, jstring str) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + jboolean is_copy = JNI_TRUE; + const char *str_chars = (char *)env->GetStringUTFChars(str, &is_copy); + const std::string string_to_write = std::string(str_chars); + + env->ReleaseStringUTFChars(str, str_chars); + + obj_device->set_alias(string_to_write); +} + +jint Java_BluetoothDevice_getBluetoothClass(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return (jlong)obj_device->get_class(); +} + +jshort Java_BluetoothDevice_getAppearance(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return (jshort)obj_device->get_appearance(); +} + +jstring Java_BluetoothDevice_getIcon(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::string icon = obj_device->get_icon(); + + return env->NewStringUTF((const char *)icon.c_str()); +} + +jboolean Java_BluetoothDevice_getPaired(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->get_paired() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothDevice_getTrusted(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->get_trusted() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothDevice_setTrusted(JNIEnv *env, jobject obj, jboolean val) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + bool val_to_write = from_jboolean_to_bool(val); + obj_device->set_trusted(val_to_write); +} + +jboolean Java_BluetoothDevice_getBlocked(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->get_blocked() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothDevice_setBlocked(JNIEnv *env, jobject obj, jboolean val) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + bool val_to_write = from_jboolean_to_bool(val); + obj_device->set_blocked(val_to_write); +} + +jboolean Java_BluetoothDevice_getLegacyPairing(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->get_legacy_pairing() ? JNI_TRUE : JNI_FALSE; +} + +jshort Java_BluetoothDevice_getRssi(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return (jshort)obj_device->get_rssi(); +} + +jboolean Java_BluetoothDevice_getConnected(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + + return obj_device->get_connected() ? JNI_TRUE : JNI_FALSE; +} + +jobjectArray Java_BluetoothDevice_getUuids(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::vector<std::string> uuids = obj_device->get_uuids(); + unsigned int uuids_size = uuids.size(); + + jclass string_class = search_class(env, "Ljava/lang/String;"); + jobjectArray result = env->NewObjectArray(uuids_size, string_class, 0); + + for (unsigned int i = 0; i < uuids_size; ++i) + { + std::string str_elem = uuids.at(i); + jobject elem = env->NewStringUTF((const char *)str_elem.c_str()); + env->SetObjectArrayElement(result, i, elem); + } + + return result; +} + +jstring Java_BluetoothDevice_getModalias(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + std::string modalias = obj_device->get_modalias(); + + return env->NewStringUTF((const char *)modalias.c_str()); +} + +jobject Java_BluetoothDevice_getAdapter(JNIEnv *env, jobject obj) +{ + BluetoothDevice *obj_device = getInstance<BluetoothDevice>(env, obj); + BluetoothAdapter *obj_adapter = obj_device->get_adapter().clone(); + + jclass b_adapter_class = search_class(env, "BluetoothAdapter"); + jmethodID b_adapter_ctor = search_method(env, b_adapter_class, "<init>", + "(J)V", false); + jobject result = env->NewObject(b_adapter_class, b_adapter_ctor, (jlong)obj_adapter); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + return result; +} + +void Java_BluetoothDevice_delete(JNIEnv *env, jobject obj) +{ + BluetoothDevice *b_device = getInstance<BluetoothDevice>(env, obj); + delete b_device; +} + diff --git a/java/jni/BluetoothDevice.h b/java/jni/BluetoothDevice.h new file mode 100644 index 00000000..3c03fcae --- /dev/null +++ b/java/jni/BluetoothDevice.h @@ -0,0 +1,237 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothDevice */ + +#ifndef _Included_BluetoothDevice +#define _Included_BluetoothDevice +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothDevice + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothDevice_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: clone + * Signature: ()LBluetoothDevice; + */ +JNIEXPORT jobject JNICALL Java_BluetoothDevice_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: disconnect + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_disconnect + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: connect + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_connect + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: connectProfile + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_connectProfile + (JNIEnv *, jobject, jstring); + +/* + * Class: BluetoothDevice + * Method: disconnectProfile + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_disconnectProfile + (JNIEnv *, jobject, jstring); + +/* + * Class: BluetoothDevice + * Method: pair + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_pair + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: cancelPairing + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_cancelPairing + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getServices + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothDevice_getServices + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getAddress + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothDevice_getAddress + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getName + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothDevice_getName + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getAlias + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothDevice_getAlias + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: setAlias + * Signature: (Ljava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_BluetoothDevice_setAlias + (JNIEnv *, jobject, jstring); + +/* + * Class: BluetoothDevice + * Method: getBluetoothClass + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_BluetoothDevice_getBluetoothClass + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getAppearance + * Signature: ()S + */ +JNIEXPORT jshort JNICALL Java_BluetoothDevice_getAppearance + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getIcon + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothDevice_getIcon + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getPaired + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_getPaired + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getTrusted + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_getTrusted + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: setTrusted + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_BluetoothDevice_setTrusted + (JNIEnv *, jobject, jboolean); + +/* + * Class: BluetoothDevice + * Method: getBlocked + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_getBlocked + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: setBlocked + * Signature: (Z)V + */ +JNIEXPORT void JNICALL Java_BluetoothDevice_setBlocked + (JNIEnv *, jobject, jboolean); + +/* + * Class: BluetoothDevice + * Method: getLegacyPairing + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_getLegacyPairing + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getRssi + * Signature: ()S + */ +JNIEXPORT jshort JNICALL Java_BluetoothDevice_getRssi + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getConnected + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothDevice_getConnected + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getUuids + * Signature: ()[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_BluetoothDevice_getUuids + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getModalias + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothDevice_getModalias + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: getAdapter + * Signature: ()LBluetoothAdapter; + */ +JNIEXPORT jobject JNICALL Java_BluetoothDevice_getAdapter + (JNIEnv *, jobject); + +/* + * Class: BluetoothDevice + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothDevice_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothEvent.cxx b/java/jni/BluetoothEvent.cxx new file mode 100644 index 00000000..9f6b9720 --- /dev/null +++ b/java/jni/BluetoothEvent.cxx @@ -0,0 +1,32 @@ +#include "BluetoothEvent.h" + +jobject Java_BluetoothEvent_getType(JNIEnv *env, jobject obj) +{ +} + +jstring Java_BluetoothEvent_getName(JNIEnv *env, jobject obj) +{ +} + +jstring Java_BluetoothEvent_getIdentifier(JNIEnv *env, jobject obj) +{ +} + +jboolean Java_BluetoothEvent_executeCallback(JNIEnv *env, jobject obj) +{ +} + +jboolean Java_BluetoothEvent_hasCallback(JNIEnv *env, jobject obj) +{ +} + +void Java_BluetoothEvent_init(JNIEnv *env, jobject obj, jobject type, jstring name, + jstring identifier, jobject parent, jobject callback, + jobject arg_data) +{ +} + +void Java_BluetoothEvent_delete(JNIEnv *env, jobject obj) +{ +} + diff --git a/java/jni/BluetoothEvent.h b/java/jni/BluetoothEvent.h new file mode 100644 index 00000000..6fab5f65 --- /dev/null +++ b/java/jni/BluetoothEvent.h @@ -0,0 +1,69 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothEvent */ + +#ifndef _Included_BluetoothEvent +#define _Included_BluetoothEvent +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothEvent + * Method: getType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothEvent_getType + (JNIEnv *, jobject); + +/* + * Class: BluetoothEvent + * Method: getName + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothEvent_getName + (JNIEnv *, jobject); + +/* + * Class: BluetoothEvent + * Method: getIdentifier + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothEvent_getIdentifier + (JNIEnv *, jobject); + +/* + * Class: BluetoothEvent + * Method: executeCallback + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothEvent_executeCallback + (JNIEnv *, jobject); + +/* + * Class: BluetoothEvent + * Method: hasCallback + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothEvent_hasCallback + (JNIEnv *, jobject); + +/* + * Class: BluetoothEvent + * Method: init + * Signature: (LBluetoothType;Ljava/lang/String;Ljava/lang/String;LBluetoothObject;LBluetoothCallback;Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL Java_BluetoothEvent_init + (JNIEnv *, jobject, jobject, jstring, jstring, jobject, jobject, jobject); + +/* + * Class: BluetoothEvent + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothEvent_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothGattCharacteristic.cxx b/java/jni/BluetoothGattCharacteristic.cxx new file mode 100644 index 00000000..2b2cfbe4 --- /dev/null +++ b/java/jni/BluetoothGattCharacteristic.cxx @@ -0,0 +1,185 @@ +#include "tinyb/BluetoothGattCharacteristic.hpp" +#include "tinyb/BluetoothGattDescriptor.hpp" +#include "tinyb/BluetoothGattService.hpp" +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothGattCharacteristic.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothGattCharacteristic_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "GATT_CHARACTERISTIC"); +} + +jobject Java_BluetoothGattCharacteristic_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothGattCharacteristic>(env, obj, "BluetoothGattCharacteristic"); +} + +jobject Java_BluetoothGattCharacteristic_readValue(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + std::vector<unsigned char> array = obj_gatt_char->read_value(); + unsigned int array_size = array.size(); + + jmethodID arraylist_add; + jobject result = get_new_arraylist(env, array_size, &arraylist_add); + + jclass byte_class = search_class(env, "Ljava/lang/Byte"); + jmethodID byte_ctor = search_method(env, byte_class, "<init>", "(B)V", false); + + for (unsigned int i = 0; i < array_size; ++i) + { + unsigned char elem = array.at(i); + jobject byte_obj = env->NewObject(byte_class, byte_ctor, elem); + if (byte_obj == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + env->CallBooleanMethod(result, arraylist_add, byte_obj); + } + + return result; +} + +jboolean Java_BluetoothGattCharacteristic_writeValue(JNIEnv *env, jobject obj, jobject argValue) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + jclass arraylist_class = search_class(env, "Ljava/util/ArrayList;"); + jmethodID arraylist_get = search_method(env, arraylist_class, "get", + "(I)Ljava/lang/Object;", false); + jmethodID arraylist_size = search_method(env, arraylist_class, "size", + "()I", false); + unsigned int size = env->CallIntMethod(argValue, arraylist_size); + + std::vector<unsigned char> array(size); + for (unsigned int i = 0; i < size; ++i) + { + unsigned char elem = env->CallByteMethod(argValue, arraylist_get, i); + array.push_back(elem); + } + + return obj_gatt_char->write_value(array); +} + +jboolean Java_BluetoothGattCharacteristic_startNotify(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + return obj_gatt_char->start_notify() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothGattCharacteristic_stopNotify(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + return obj_gatt_char->stop_notify() ? JNI_TRUE : JNI_FALSE; +} + +jstring Java_BluetoothGattCharacteristic_getUuid(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + std::string uuid = obj_gatt_char->get_uuid(); + + return env->NewStringUTF((const char *)uuid.c_str()); +} + +jobject Java_BluetoothGattCharacteristic_getService(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + BluetoothGattService *obj_gatt_serv = obj_gatt_char->get_service().clone(); + + jclass b_gatt_serv_class = search_class(env, "BluetoothGattService"); + jmethodID b_gatt_serv_ctor = search_method(env, b_gatt_serv_class, "<init>", + "(J)V", false); + jobject result = env->NewObject(b_gatt_serv_class, b_gatt_serv_ctor, (jlong)obj_gatt_serv); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + return result; +} + +jobject Java_BluetoothGattCharacteristic_getValue(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + std::vector<unsigned char> array = obj_gatt_char->get_value(); + unsigned int array_size = array.size(); + + jmethodID arraylist_add; + jobject result = get_new_arraylist(env, array_size, &arraylist_add); + + jclass byte_class = search_class(env, "Ljava/lang/Byte"); + jmethodID byte_ctor = search_method(env, byte_class, "<init>", "(B)V", false); + + for (unsigned int i = 0; i < array_size; ++i) + { + unsigned char elem = array.at(i); + jobject byte_obj = env->NewObject(byte_class, byte_ctor, elem); + if (byte_obj == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + env->CallBooleanMethod(result, arraylist_add, byte_obj); + } + + return result; +} + +jboolean Java_BluetoothGattCharacteristic_getNotifying(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + return obj_gatt_char->get_notifying() ? JNI_TRUE : JNI_FALSE; +} + +jobjectArray Java_BluetoothGattCharacteristic_getFlags(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + std::vector<std::string> flags = obj_gatt_char->get_flags(); + unsigned int flags_size = flags.size(); + + jclass string_class = search_class(env, "Ljava/lang/String;"); + jobjectArray result = env->NewObjectArray(flags_size, string_class, 0); + + for (unsigned int i = 0; i < flags_size; ++i) + { + std::string str_elem = flags.at(i); + jobject elem = env->NewStringUTF((const char *)str_elem.c_str()); + env->SetObjectArrayElement(result, i, elem); + } + + return result; +} + +jobject Java_BluetoothGattCharacteristic_getDescriptors(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + std::vector<std::unique_ptr<BluetoothGattDescriptor>> array = obj_gatt_char->get_descriptors(); + + jobject result = convert_vector_to_jobject<BluetoothGattDescriptor>(env, array, + "BluetoothGattDescriptor", + "(J)V"); + return result; +} + +void Java_BluetoothGattCharacteristic_delete(JNIEnv *env, jobject obj) +{ + BluetoothGattCharacteristic *obj_gatt_char = + getInstance<BluetoothGattCharacteristic>(env, obj); + delete obj_gatt_char; +} + diff --git a/java/jni/BluetoothGattCharacteristic.h b/java/jni/BluetoothGattCharacteristic.h new file mode 100644 index 00000000..efb44419 --- /dev/null +++ b/java/jni/BluetoothGattCharacteristic.h @@ -0,0 +1,125 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothGattCharacteristic */ + +#ifndef _Included_BluetoothGattCharacteristic +#define _Included_BluetoothGattCharacteristic +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothGattCharacteristic + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: clone + * Signature: ()LBluetoothGattCharacteristic; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: readValue + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_readValue + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: writeValue + * Signature: (Ljava/util/List;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattCharacteristic_writeValue + (JNIEnv *, jobject, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: startNotify + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattCharacteristic_startNotify + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: stopNotify + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattCharacteristic_stopNotify + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getUuid + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothGattCharacteristic_getUuid + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getService + * Signature: ()LBluetoothGattService; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_getService + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getValue + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_getValue + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getNotifying + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattCharacteristic_getNotifying + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getFlags + * Signature: ()[Ljava/lang/String; + */ +JNIEXPORT jobjectArray JNICALL Java_BluetoothGattCharacteristic_getFlags + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: getDescriptors + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattCharacteristic_getDescriptors + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: init + * Signature: (LBluetoothGattCharacteristic;)V + */ +JNIEXPORT void JNICALL Java_BluetoothGattCharacteristic_init + (JNIEnv *, jobject, jobject); + +/* + * Class: BluetoothGattCharacteristic + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothGattCharacteristic_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothGattDescriptor.cxx b/java/jni/BluetoothGattDescriptor.cxx new file mode 100644 index 00000000..f218fe02 --- /dev/null +++ b/java/jni/BluetoothGattDescriptor.cxx @@ -0,0 +1,127 @@ +#include "tinyb/BluetoothGattCharacteristic.hpp" +#include "tinyb/BluetoothGattDescriptor.hpp" +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothGattDescriptor.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothGattDescriptor_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "GATT_DESCRIPTOR"); +} + +jobject Java_BluetoothGattDescriptor_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothGattDescriptor>(env, obj, "BluetoothGattDescriptor"); +} + +jobject Java_BluetoothGattDescriptor_readValue(JNIEnv *env, jobject obj) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + std::vector<unsigned char> array = obj_gatt_desc->read_value(); + unsigned int array_size = array.size(); + + jmethodID arraylist_add; + jobject result = get_new_arraylist(env, array_size, &arraylist_add); + + jclass byte_class = search_class(env, "Ljava/lang/Byte"); + jmethodID byte_ctor = search_method(env, byte_class, "<init>", "(B)V", false); + + for (unsigned int i = 0; i < array_size; ++i) + { + unsigned char elem = array.at(i); + jobject byte_obj = env->NewObject(byte_class, byte_ctor, elem); + if (byte_obj == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + env->CallBooleanMethod(result, arraylist_add, byte_obj); + } + + return result; +} + +jboolean Java_BluetoothGattDescriptor_writeValue(JNIEnv *env, jobject obj, jobject argValue) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + + jclass arraylist_class = search_class(env, "Ljava/util/ArrayList;"); + jmethodID arraylist_get = search_method(env, arraylist_class, "get", + "(I)Ljava/lang/Object;", false); + jmethodID arraylist_size = search_method(env, arraylist_class, "size", + "()I", false); + unsigned int size = env->CallIntMethod(argValue, arraylist_size); + + std::vector<unsigned char> array(size); + for (unsigned int i = 0; i < size; ++i) + { + unsigned char elem = env->CallByteMethod(argValue, arraylist_get, i); + array.push_back(elem); + } + + return obj_gatt_desc->write_value(array); +} + +jstring Java_BluetoothGattDescriptor_getUuid(JNIEnv *env, jobject obj) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + std::string uuid = obj_gatt_desc->get_uuid(); + + return env->NewStringUTF((const char *)uuid.c_str()); +} + +jobject Java_BluetoothGattDescriptor_getCharacteristic(JNIEnv *env, jobject obj) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + BluetoothGattCharacteristic *obj_gatt_char = obj_gatt_desc->get_characteristic().clone(); + + jclass b_gatt_char_class = search_class(env, "BluetoothGattCharacteristic"); + jmethodID b_gatt_char_ctor = search_method(env, b_gatt_char_class, "<init>", + "(J)V", false); + jobject result = env->NewObject(b_gatt_char_class, b_gatt_char_ctor, (jlong)obj_gatt_char); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + return result; +} + +jobject Java_BluetoothGattDescriptor_getValue(JNIEnv *env, jobject obj) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + std::vector<unsigned char> array = obj_gatt_desc->get_value(); + unsigned int array_size = array.size(); + + jmethodID arraylist_add; + jobject result = get_new_arraylist(env, array_size, &arraylist_add); + + jclass byte_class = search_class(env, "Ljava/lang/Byte"); + jmethodID byte_ctor = search_method(env, byte_class, "<init>", "(B)V", false); + + for (unsigned int i = 0; i < array_size; ++i) + { + unsigned char elem = array.at(i); + jobject byte_obj = env->NewObject(byte_class, byte_ctor, elem); + if (byte_obj == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + env->CallBooleanMethod(result, arraylist_add, byte_obj); + } + + return result; + +} + +void Java_BluetoothGattDescriptor_delete(JNIEnv *env, jobject obj) +{ + BluetoothGattDescriptor *obj_gatt_desc = getInstance<BluetoothGattDescriptor>(env, obj); + delete obj_gatt_desc; +} + diff --git a/java/jni/BluetoothGattDescriptor.h b/java/jni/BluetoothGattDescriptor.h new file mode 100644 index 00000000..42fd959c --- /dev/null +++ b/java/jni/BluetoothGattDescriptor.h @@ -0,0 +1,77 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothGattDescriptor */ + +#ifndef _Included_BluetoothGattDescriptor +#define _Included_BluetoothGattDescriptor +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothGattDescriptor + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattDescriptor_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: clone + * Signature: ()LBluetoothAdapter; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattDescriptor_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: readValue + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattDescriptor_readValue + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: writeValue + * Signature: (Ljava/util/List;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattDescriptor_writeValue + (JNIEnv *, jobject, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: getUuid + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothGattDescriptor_getUuid + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: getCharacteristic + * Signature: ()LBluetoothGattCharacteristic; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattDescriptor_getCharacteristic + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: getValue + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattDescriptor_getValue + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattDescriptor + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothGattDescriptor_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothGattService.cxx b/java/jni/BluetoothGattService.cxx new file mode 100644 index 00000000..39efad0f --- /dev/null +++ b/java/jni/BluetoothGattService.cxx @@ -0,0 +1,72 @@ +#include "tinyb/BluetoothDevice.hpp" +#include "tinyb/BluetoothGattService.hpp" +#include "tinyb/BluetoothGattCharacteristic.hpp" +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothGattService.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothGattService_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "GATT_SERVICE"); +} + +jobject Java_BluetoothGattService_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothGattService>(env, obj, "BluetoothGattService"); +} + +jstring Java_BluetoothGattService_getUuid(JNIEnv *env, jobject obj) +{ + BluetoothGattService *obj_gatt_serv = getInstance<BluetoothGattService>(env, obj); + std::string uuid = obj_gatt_serv->get_uuid(); + + return env->NewStringUTF((const char *)uuid.c_str()); +} + +jobject Java_BluetoothGattService_getDevice(JNIEnv *env, jobject obj) +{ + BluetoothGattService *obj_gatt_serv = getInstance<BluetoothGattService>(env, obj); + BluetoothDevice *obj_device = obj_gatt_serv->get_device().clone(); + + jclass b_device_class = search_class(env, "BluetoothDevice"); + jmethodID b_device_ctor = search_method(env, b_device_class, "<init>", + "(J)V", false); + jobject result = env->NewObject(b_device_class, b_device_ctor, (jlong)obj_device); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + return result; +} + +jboolean Java_BluetoothGattService_getPrimary(JNIEnv *env, jobject obj) +{ + BluetoothGattService *obj_gatt_serv = getInstance<BluetoothGattService>(env, obj); + + return obj_gatt_serv->get_primary() ? JNI_TRUE : JNI_FALSE; +} + +jobject Java_BluetoothGattService_getCharacteristics(JNIEnv *env, jobject obj) +{ + BluetoothGattService *obj_gatt_serv = getInstance<BluetoothGattService>(env, obj); + std::vector<std::unique_ptr<BluetoothGattCharacteristic>> array = + obj_gatt_serv->get_characteristics(); + jobject result = convert_vector_to_jobject<BluetoothGattCharacteristic>(env, array, + "BluetoothGattCharacteristic", + "(J)V"); + return result; +} + +void Java_BluetoothGattService_delete(JNIEnv *env, jobject obj) +{ + BluetoothGattService *obj_gatt_serv = getInstance<BluetoothGattService>(env, obj); + delete obj_gatt_serv; +} + diff --git a/java/jni/BluetoothGattService.h b/java/jni/BluetoothGattService.h new file mode 100644 index 00000000..81addb34 --- /dev/null +++ b/java/jni/BluetoothGattService.h @@ -0,0 +1,69 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothGattService */ + +#ifndef _Included_BluetoothGattService +#define _Included_BluetoothGattService +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothGattService + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattService_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: clone + * Signature: ()LBluetoothAdapter; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattService_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: getUuid + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_BluetoothGattService_getUuid + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: getDevice + * Signature: ()LBluetoothDevice; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattService_getDevice + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: getPrimary + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothGattService_getPrimary + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: getCharacteristics + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothGattService_getCharacteristics + (JNIEnv *, jobject); + +/* + * Class: BluetoothGattService + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothGattService_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothManager.cxx b/java/jni/BluetoothManager.cxx new file mode 100644 index 00000000..749eac72 --- /dev/null +++ b/java/jni/BluetoothManager.cxx @@ -0,0 +1,110 @@ +#include "tinyb/BluetoothAdapter.hpp" +#include "tinyb/BluetoothDevice.hpp" +#include "tinyb/BluetoothGattService.hpp" +#include "tinyb/BluetoothManager.hpp" + +#include "BluetoothManager.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothManager_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "NONE"); +} + +jobject Java_BluetoothManager_getObject(JNIEnv *env, jobject obj, jobject type, + jstring name, jstring identifier, jobject parent) +{ + (void)env; + (void)obj; + (void)type; + (void)name; + (void)identifier; + (void)parent; + + return nullptr; +} + +jobject Java_BluetoothManager_getObjects(JNIEnv *env, jobject obj, jobject type, + jstring name, jstring identifier, jobject parent) +{ + (void)env; + (void)obj; + (void)type; + (void)name; + (void)identifier; + (void)parent; + + return nullptr; +} + +jobject Java_BluetoothManager_getAdapters(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + + std::vector<std::unique_ptr<BluetoothAdapter>> array = manager->get_adapters(); + jobject result = convert_vector_to_jobject<BluetoothAdapter>(env, array, + "BluetoothAdapter", + "(J)V"); + return result; +} + +jobject Java_BluetoothManager_getDevices(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + + std::vector<std::unique_ptr<BluetoothDevice>> array = manager->get_devices(); + jobject result = convert_vector_to_jobject<BluetoothDevice>(env, array, + "BluetoothDevice", + "(J)V"); + return result; + +} + +jobject Java_BluetoothManager_getServices(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + + std::vector<std::unique_ptr<BluetoothGattService>> array = manager->get_services(); + jobject result = convert_vector_to_jobject<BluetoothGattService>(env, array, + "BluetoothGattService", + "(J)V"); + return result; +} + +jboolean Java_BluetoothManager_setDefaultAdapter(JNIEnv *env, jobject obj, jobject adapter) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + BluetoothAdapter *b_adapter = getInstance<BluetoothAdapter>(env, adapter); + + return manager->set_default_adapter(b_adapter); +} + +jboolean Java_BluetoothManager_startDiscovery(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + return manager->start_discovery() ? JNI_TRUE : JNI_FALSE; +} + +jboolean Java_BluetoothManager_stopDiscovery(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + return manager->start_discovery() ? JNI_TRUE : JNI_FALSE; +} + +void Java_BluetoothManager_init(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = BluetoothManager::get_bluetooth_manager(); + setInstance<BluetoothManager>(env, obj, manager); +} + +void Java_BluetoothManager_delete(JNIEnv *env, jobject obj) +{ + BluetoothManager *manager = getInstance<BluetoothManager>(env, obj); + delete manager; +} + diff --git a/java/jni/BluetoothManager.h b/java/jni/BluetoothManager.h new file mode 100644 index 00000000..65f2db47 --- /dev/null +++ b/java/jni/BluetoothManager.h @@ -0,0 +1,101 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothManager */ + +#ifndef _Included_BluetoothManager +#define _Included_BluetoothManager +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothManager + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: getObject + * Signature: (LBluetoothType;Ljava/lang/String;Ljava/lang/String;LBluetoothObject;)LBluetoothObject; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getObject + (JNIEnv *, jobject, jobject, jstring, jstring, jobject); + +/* + * Class: BluetoothManager + * Method: getObjects + * Signature: (LBluetoothType;Ljava/lang/String;Ljava/lang/String;LBluetoothObject;)Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getObjects + (JNIEnv *, jobject, jobject, jstring, jstring, jobject); + +/* + * Class: BluetoothManager + * Method: getAdapters + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getAdapters + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: getDevices + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getDevices + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: getServices + * Signature: ()Ljava/util/List; + */ +JNIEXPORT jobject JNICALL Java_BluetoothManager_getServices + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: setDefaultAdapter + * Signature: (LBluetoothAdapter;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothManager_setDefaultAdapter + (JNIEnv *, jobject, jobject); + +/* + * Class: BluetoothManager + * Method: startDiscovery + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothManager_startDiscovery + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: stopDiscovery + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothManager_stopDiscovery + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: init + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothManager_init + (JNIEnv *, jobject); + +/* + * Class: BluetoothManager + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothManager_delete + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothObject.cxx b/java/jni/BluetoothObject.cxx new file mode 100644 index 00000000..cb1d5b51 --- /dev/null +++ b/java/jni/BluetoothObject.cxx @@ -0,0 +1,35 @@ +#include "tinyb/BluetoothObject.hpp" + +#include "BluetoothObject.h" + +#include "helper.h" + +using namespace tinyb; + +jobject Java_BluetoothObject_getBluetoothType(JNIEnv *env, jobject obj) +{ + (void)obj; + + return get_bluetooth_type(env, "NONE"); +} + +jobject Java_BluetoothObject_clone(JNIEnv *env, jobject obj) +{ + return generic_clone<BluetoothObject>(env, obj, "BluetoothObject"); +} + +void Java_BluetoothObject_delete(JNIEnv *env, jobject obj) +{ + BluetoothObject *obj_b = getInstance<BluetoothObject>(env, obj); + + delete obj_b; +} + +jboolean Java_BluetoothObject_operatorEqual(JNIEnv *env, jobject obj, jobject other) +{ + BluetoothObject *obj_b = getInstance<BluetoothObject>(env, obj); + BluetoothObject *obj_other = getInstance<BluetoothObject>(env, other); + + return (*obj_b) == (*obj_other); +} + diff --git a/java/jni/BluetoothObject.h b/java/jni/BluetoothObject.h new file mode 100644 index 00000000..193c9632 --- /dev/null +++ b/java/jni/BluetoothObject.h @@ -0,0 +1,45 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothObject */ + +#ifndef _Included_BluetoothObject +#define _Included_BluetoothObject +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: BluetoothObject + * Method: getBluetoothType + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothObject_getBluetoothType + (JNIEnv *, jobject); + +/* + * Class: BluetoothObject + * Method: clone + * Signature: ()LBluetoothType; + */ +JNIEXPORT jobject JNICALL Java_BluetoothObject_clone + (JNIEnv *, jobject); + +/* + * Class: BluetoothObject + * Method: delete + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_BluetoothObject_delete + (JNIEnv *, jobject); + +/* + * Class: BluetoothObject + * Method: operatorEqual + * Signature: (LBluetoothObject;)Z + */ +JNIEXPORT jboolean JNICALL Java_BluetoothObject_operatorEqual + (JNIEnv *, jobject, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/BluetoothType.h b/java/jni/BluetoothType.h new file mode 100644 index 00000000..5c80ea78 --- /dev/null +++ b/java/jni/BluetoothType.h @@ -0,0 +1,13 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class BluetoothType */ + +#ifndef _Included_BluetoothType +#define _Included_BluetoothType +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/ObjectArgCallback.h b/java/jni/ObjectArgCallback.h new file mode 100644 index 00000000..884d8432 --- /dev/null +++ b/java/jni/ObjectArgCallback.h @@ -0,0 +1,13 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class ObjectArgCallback */ + +#ifndef _Included_ObjectArgCallback +#define _Included_ObjectArgCallback +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/ObjectArrayArgCallback.h b/java/jni/ObjectArrayArgCallback.h new file mode 100644 index 00000000..081bbd5b --- /dev/null +++ b/java/jni/ObjectArrayArgCallback.h @@ -0,0 +1,13 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class ObjectArrayArgCallback */ + +#ifndef _Included_ObjectArrayArgCallback +#define _Included_ObjectArrayArgCallback +#ifdef __cplusplus +extern "C" { +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/java/jni/helper.cxx b/java/jni/helper.cxx new file mode 100644 index 00000000..9f41eea3 --- /dev/null +++ b/java/jni/helper.cxx @@ -0,0 +1,115 @@ +#include <jni.h> +#include <memory> +#include <stdexcept> +#include <vector> + +#include "helper.h" + +jfieldID getInstanceField(JNIEnv *env, jobject obj) +{ + jclass clazz = env->GetObjectClass(obj); + // J == long + return env->GetFieldID(clazz, "nativeInstance", "J"); +} + +jclass search_class(JNIEnv *env, const char *clazz_name) +{ + jclass clazz = env->FindClass(clazz_name); + if (clazz == NULL) + { + throw std::runtime_error("no class found\n"); + } + return clazz; +} + +jmethodID search_method(JNIEnv *env, jclass clazz, const char *method_name, + const char *prototype, bool is_static) +{ + jmethodID method; + if(is_static) + { + method = env->GetStaticMethodID(clazz, method_name, prototype); + } + else + { + method = env->GetMethodID(clazz, method_name, prototype); + } + + if(method == NULL) + { + throw std::runtime_error("no method found\n"); + } + + return method; +} + +jfieldID search_field(JNIEnv *env, jclass clazz, const char *field_name, + const char *type, bool is_static) +{ + jfieldID field; + if(is_static) + { + field = env->GetStaticFieldID(clazz, field_name, type); + } + else + { + field = env->GetFieldID(clazz, field_name, type); + } + + if(field == NULL) + { + throw std::runtime_error("no method found\n"); + } + + return field; +} + +bool from_jboolean_to_bool(jboolean val) +{ + bool result; + + if (val == JNI_TRUE) + { + result = true; + } + else + { + if (val == JNI_FALSE) + { + result = false; + } + else + { + throw std::invalid_argument("the jboolean value is not true/false\n"); + } + } + + return result; +} + +jobject get_bluetooth_type(JNIEnv *env, const char *field_name) +{ + jclass b_type_enum = search_class(env, "BluetoothType"); + + jfieldID b_type_field = search_field(env, b_type_enum, field_name, "l", true); + + jobject result = env->GetStaticObjectField(b_type_enum, b_type_field); + return result; +} + + +jobject get_new_arraylist(JNIEnv *env, unsigned int size, jmethodID *add) +{ + jclass arraylist_class = search_class(env, "Ljava/util/ArrayList;"); + jmethodID arraylist_ctor = search_method(env, arraylist_class, "<init>", "(I)V", false); + + jobject result = env->NewObject(arraylist_class, arraylist_ctor, size); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + *add = search_method(env, arraylist_class, "add", "(Ljava/lang/Object;)Z", false); + + return result; +} diff --git a/java/jni/helper.h b/java/jni/helper.h new file mode 100644 index 00000000..30617506 --- /dev/null +++ b/java/jni/helper.h @@ -0,0 +1,74 @@ +#ifndef _HELPER_H_ +#define _HELPER_H_ + +#include <vector> + +jfieldID getInstanceField(JNIEnv *env, jobject obj); + +jclass search_class(JNIEnv *env, const char *clazz_name); +jmethodID search_method(JNIEnv *env, jclass clazz, const char *method_name, + const char *prototype, bool is_static); +jfieldID search_field(JNIEnv *env, jclass clazz, const char *field_name, + const char *type, bool is_static); +bool from_jboolean_to_bool(jboolean val); +jobject get_bluetooth_type(JNIEnv *env, const char *field_name); +jobject get_new_arraylist(JNIEnv *env, unsigned int size, jmethodID *add); + +template <typename T> +T *getInstance(JNIEnv *env, jobject obj) +{ + jlong instance = env->GetLongField(obj, getInstanceField(env, obj)); + return reinterpret_cast<T *>(instance); +} + +template <typename T> +void setInstance(JNIEnv *env, jobject obj, T *t) +{ + jlong instance = reinterpret_cast<jlong>(t); + env->SetLongField(obj, getInstanceField(env, obj), instance); +} + +template <typename T> +jobject generic_clone(JNIEnv *env, jobject obj, const char *class_name) +{ + T *obj_generic = getInstance<T>(env, obj); + T *copy_generic = new T(*obj_generic); + + jclass generic_class = search_class(env, class_name); + jmethodID generic_ctor = search_method(env, generic_class, "<init>", "(J)V", false); + + jobject result = env->NewObject(generic_class, generic_ctor, (jlong)copy_generic); + if (result == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + + return result; +} + +template <typename T> +jobject convert_vector_to_jobject(JNIEnv *env, std::vector<std::unique_ptr<T>>& array, + const char *class_name, const char *ctor_prototype) +{ + unsigned int array_size = array.size(); + + jmethodID arraylist_add; + jobject result = get_new_arraylist(env, array_size, &arraylist_add); + + jclass clazz = search_class(env, class_name); + jmethodID clazz_ctor = search_method(env, clazz, "<init>", ctor_prototype, false); + + for (unsigned int i = 0; i < array_size; ++i) + { + T *elem = array.at(i).release(); + jobject object = env->NewObject(clazz, clazz_ctor, (long)elem); + if (object == NULL) + { + throw std::runtime_error("cannot create instance of class\n"); + } + env->CallBooleanMethod(result, arraylist_add, object); + } + return result; +} + +#endif diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3a016b30..262faf0e 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -27,6 +27,7 @@ set (tinyb_LIB_SRCS ) set (tinyb_LIB_GLOB_HEADERS + ${PROJECT_SOURCE_DIR}/api/tinyb.h ${PROJECT_SOURCE_DIR}/api/tinyb.hpp ) @@ -56,14 +57,3 @@ tinyb_create_install_pkgconfig (tinyb.pc lib${LIB_SUFFIX}/pkgconfig) install(TARGETS tinyb LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) -if (BUILDSWIG) - find_package (SWIG) - if (SWIG_FOUND) - include (${SWIG_USE_FILE}) - set_source_files_properties (tinyb.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src") - - if (BUILDSWIGJAVA) - add_subdirectory (java) - endif () - endif () -endif () |