BT Socket Factory creation and connecting with java code

common/CMakeLists.txt

@@ -68,6 +68,7 @@ add_library( LiteCoreJNI SHARED
     ${JNI_SRC}/native_c4listener.cc
     ${JNI_SRC}/native_c4multipeerreplicator.cc
     ${JNI_SRC}/native_c4peerdiscoveryprovider.cc
+    ${JNI_SRC}/native_c4btsocketfactory.cc
     ${JNI_SRC}/native_bluetoothpeer.cc
     ${JNI_SRC}/MetadataHelper.cc
     ${JNI_SRC}/native_c4observer.cc
@@ -96,6 +97,9 @@ target_link_options(
 
 target_link_libraries( LiteCoreJNI
     LiteCore
+    # Below are needed on Android.  If this gets moved to Java as well this will need
+    # to be changed
     "log"
+    c++_static
+    c++abi
 )
-

common/main/cpp/MetadataHelper.cc

@@ -29,10 +29,12 @@ namespace litecore::jni {
             jstring jKey = (jstring)env->CallObjectMethod(entry, getKeyMethod);
             jbyteArray jValue = (jbyteArray)env->CallObjectMethod(entry, getValueMethod);
 
-            std::string key = JstringToUTF8(env, jKey);
-            jbyteArraySlice value(env, jValue);
+            {
+                std::string key = JstringToUTF8(env, jKey);
+                jbyteArraySlice value(env, jValue);
 
-            metadata[std::string(key)] = fleece::alloc_slice(value);
+                metadata[std::string(key)] = fleece::alloc_slice(value);
+            }
 
             env->DeleteLocalRef(entry);
             env->DeleteLocalRef(jKey);
@@ -41,6 +43,9 @@ namespace litecore::jni {
 
         env->DeleteLocalRef(entrySet);
         env->DeleteLocalRef(entries);
+        env->DeleteLocalRef(mapClass);
+        env->DeleteLocalRef(setClass);
+        env->DeleteLocalRef(entryClass);
 
         return metadata;
     }
@@ -50,7 +55,16 @@ namespace litecore::jni {
         // Create HashMap
         jclass hashMapClass = env->FindClass("java/util/HashMap");
         jmethodID hashMapInit = env->GetMethodID(hashMapClass, "<init>", "(I)V");
-        jobject hashMap = env->NewObject(hashMapClass, hashMapInit);
+
+
+        size_t rawSize = metadata.size();
+        jint size = (rawSize > 10000) ? 0 : static_cast<jint>(rawSize);
+
+        jobject hashMap = env->NewObject(hashMapClass, hashMapInit, size);
+        if (env->ExceptionCheck()) {
+            env->ExceptionClear();
+            return env->NewObject(hashMapClass, hashMapInit, 0);
+        }
 
         // Put method for HashMap
         jmethodID hashMapPut = env->GetMethodID(

common/main/cpp/com_couchbase_lite_internal_core_impl_NativeBluetoothPeer.h

@@ -6,7 +6,7 @@
 #include <jni.h>
 
 #ifdef __cplusplus
-extern "C++" {
+extern "C" {
 #endif
 
 /*

common/main/cpp/com_couchbase_lite_internal_core_impl_NativeC4BTSocketFactory.h

@@ -0,0 +1,21 @@
+#ifndef ANDROID_COM_COUCHBASE_LITE_INTERNAL_CORE_IMPL_NATIVEC4BTSOCKETFACTORY_H
+#define ANDROID_COM_COUCHBASE_LITE_INTERNAL_CORE_IMPL_NATIVEC4BTSOCKETFACTORY_H
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C++" {
+#endif
+
+JNIEXPORT jlong JNICALL
+Java_com_couchbase_lite_internal_core_impl_NativeC4BTSocketFactory_registerBTSocketFactory(
+        JNIEnv*, jclass);
+
+JNIEXPORT jlong JNICALL
+Java_com_couchbase_lite_internal_core_impl_NativeC4BTSocketFactory_fromNative(
+        JNIEnv*, jclass, jlong, jstring, jstring, jlong, jstring, jint);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //ANDROID_COM_COUCHBASE_LITE_INTERNAL_CORE_IMPL_NATIVEC4BTSOCKETFACTORY_H

common/main/cpp/com_couchbase_lite_internal_core_impl_NativeC4PeerDiscoveryProvider.h

@@ -4,7 +4,7 @@
 #define COUCHBASE_LITE_JAVA_EE_ROOT_COM_COUCHBASE_LITE_INTERNAL_CORE_IMPL_NATIVEC4PEERDISCOVERYPROVIDER_H
 
 #ifdef __cplusplus
-extern "C++" {
+extern "C" {
 #endif
 
 JNIEXPORT jlong JNICALL
@@ -50,10 +50,23 @@ JNIEXPORT jlongArray JNICALL
 Java_com_couchbase_lite_internal_core_impl_NativeC4PeerDiscoveryProvider_peersWithProvider(
         JNIEnv *env, jclass thiz, jlong providerPtr);
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jbyteArray JNICALL
 Java_com_couchbase_lite_internal_core_impl_NativeC4PeerDiscoveryProvider_serviceUuidFromPeerGroup(
         JNIEnv* env, jclass, jstring peerGroup);
 
+JNIEXPORT void JNICALL
+Java_com_couchbase_lite_internal_core_impl_NativeC4PeerDiscoveryProvider_createIncomingSocket(
+        JNIEnv* env, jclass,
+        jlong providerPtr,
+        jlong peerPtr,
+        jlong btSocketHandle,
+        jstring jUrl);
+
+JNIEXPORT jlong JNICALL
+Java_com_couchbase_lite_internal_core_impl_NativeC4PeerDiscoveryProvider_getSocketFactory(
+        JNIEnv* env, jclass,
+        jlong providerPtr);
+
 #ifdef __cplusplus
 }
 #endif

common/main/cpp/native_bluetoothpeer.cc

@@ -16,7 +16,7 @@ static C4Peer* getPeer(jlong peerPtr) {
     return reinterpret_cast<C4Peer*>(peerPtr);
 }
 
-extern "C++" {
+extern "C" {
     JNIEXPORT jstring JNICALL
     Java_com_couchbase_lite_internal_core_impl_NativeBluetoothPeer_getId(
             JNIEnv *env, jclass clazz, jlong peerPtr) {
@@ -75,7 +75,7 @@ extern "C++" {
             JNIEnv *env, jclass clazz, jlong peerPtr, jstring jurl) {
         std::string url = JstringToUTF8(env, jurl);
 
-        BluetoothPeer *peer = static_cast<BluetoothPeer*>(getPeer(peerPtr));
+        auto *peer = dynamic_cast<BluetoothPeer*>(getPeer(peerPtr));
         if (!peer) return;
 
         peer->resolvingUrl(url, kC4NoError);
@@ -87,4 +87,4 @@ extern "C++" {
         fleece::release(reinterpret_cast<const fleece::RefCounted*>(peerPtr));
     }
 }
-#endif
+#endif

common/main/cpp/native_bluetoothpeer_internal.h

@@ -5,6 +5,18 @@
 
 #include "c4PeerDiscovery.hh"
 #include "c4Error.h"
+#include "c4Socket.h"
+
+namespace litecore::jni {
+    /// The BT C4SocketFactory — defined in native_c4btsocketfactory.cc
+    extern const C4SocketFactory kBTSocketFactory;
+}
+
+struct BTNativeHandle {
+    jlong       btSocketHandle;   // key into Java's sSocketHandles map
+    std::string peerID;           // BT MAC address / CBL peer ID
+};
+
 
 class BluetoothPeer final : public C4Peer {
     using C4Peer::C4Peer;

common/main/cpp/native_c4btsocketfactory.cc

@@ -0,0 +1,211 @@
+#if defined(COUCHBASE_ENTERPRISE) && defined(__ANDROID__)
+
+#include "c4Socket.h"
+#include "c4Socket.hh"
+#include "c4SocketTypes.h"
+#include "native_glue.hh"
+#include "native_bluetoothpeer_internal.h"
+#include "com_couchbase_lite_internal_core_impl_NativeC4BTSocketFactory.h"
+
+#include <string>
+
+using namespace litecore;
+using namespace litecore::jni;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Java class / method cache
+// ─────────────────────────────────────────────────────────────────────────────
+
+static jclass    cls_C4BTSocketFactory;
+static jmethodID m_open;
+static jmethodID m_write;
+static jmethodID m_completedReceive;
+static jmethodID m_close;
+static jmethodID m_dispose;
+static jmethodID m_attached;
+
+bool litecore::jni::initC4BTSocketFactory(JNIEnv* env) {
+    jclass localCls = env->FindClass(
+            "com/couchbase/lite/internal/p2p/ble/BluetoothSocketFactory");
+    if (!localCls) return false;
+
+    cls_C4BTSocketFactory = reinterpret_cast<jclass>(env->NewGlobalRef(localCls));
+    env->DeleteLocalRef(localCls);
+    if (!cls_C4BTSocketFactory) return false;
+
+    // static void open(long c4socketPeer, long factoryToken, String peerID)
+    m_open = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                    "open", "(JJLjava/lang/String;)V");
+    if (!m_open) return false;
+
+    // static void write(long c4socketPeer, byte[] data)
+    m_write = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                     "write", "(J[B)V");
+    if (!m_write) return false;
+
+    // static void completedReceive(long c4socketPeer, long byteCount)
+    m_completedReceive = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                                "completedReceive", "(JJ)V");
+    if (!m_completedReceive) return false;
+
+    // static void close(long c4socketPeer)
+    m_close = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                     "close", "(J)V");
+    if (!m_close) return false;
+
+    // static void dispose(long c4socketPeer)
+    m_dispose = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                       "dispose", "(J)V");
+    if (!m_dispose) return false;
+
+    // static void attached(long c4socketPeer, long btSocketHandle, String peerID)
+    m_attached = env->GetStaticMethodID(cls_C4BTSocketFactory,
+                                        "attached", "(JJLjava/lang/String;)V");
+    if (!m_attached) return false;
+
+    jniLog("C4BTSocketFactory: callbacks initialized");
+    return true;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// C4SocketFactory callback implementations
+// ─────────────────────────────────────────────────────────────────────────────
+
+static void btOpen(C4Socket*       socket,
+                   const C4Address* addr,
+                   C4Slice          options,
+                   void*            context) {
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btOpen");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) return;
+
+    c4socket_retain(socket);
+
+    // addr->hostname carries the CBL peer-ID / BT MAC address as a C4Slice.
+    // toJString(env, C4Slice) is the correct helper (same as native_c4socket.cc).
+    jstring jPeerID = toJString(env, addr->hostname);
+
+    env->CallStaticVoidMethod(
+            cls_C4BTSocketFactory, m_open,
+            (jlong) socket,
+            (jlong) context,    // factoryToken = context set at registration
+            jPeerID);
+
+    if (envState == JNI_EDETACHED) {
+        detachJVM("btOpen");
+    } else {
+        if (jPeerID) env->DeleteLocalRef(jPeerID);
+    }
+}
+
+static void btWrite(C4Socket* socket, C4SliceResult allocatedData) {
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btWrite");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) {
+        c4slice_free(allocatedData);
+        return;
+    }
+
+    jbyteArray jData = toJByteArray(env, allocatedData);
+    c4slice_free(allocatedData);
+
+    env->CallStaticVoidMethod(cls_C4BTSocketFactory, m_write, (jlong) socket, jData);
+
+    if (envState == JNI_EDETACHED) {
+        detachJVM("btWrite");
+    } else {
+        if (jData) env->DeleteLocalRef(jData);
+    }
+}
+
+static void btCompletedReceive(C4Socket* socket, size_t byteCount) {
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btCompletedReceive");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) return;
+
+    env->CallStaticVoidMethod(cls_C4BTSocketFactory, m_completedReceive,
+                              (jlong) socket, (jlong) byteCount);
+
+    if (envState == JNI_EDETACHED) detachJVM("btCompletedReceive");
+}
+
+static void btClose(C4Socket* socket) {
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btClose");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) return;
+
+    env->CallStaticVoidMethod(cls_C4BTSocketFactory, m_close, (jlong) socket);
+
+    if (envState == JNI_EDETACHED) detachJVM("btClose");
+}
+
+static void btDispose(C4Socket* socket) {
+    auto* ctx = static_cast<BTNativeHandle*>(socket->getNativeHandle());
+    if (ctx) {
+        socket->setNativeHandle(nullptr);
+        delete ctx;
+    }
+
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btDispose");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) return;
+
+    env->CallStaticVoidMethod(cls_C4BTSocketFactory, m_dispose, (jlong) socket);
+
+    if (envState == JNI_EDETACHED) detachJVM("btDispose");
+}
+
+/**
+ * btAttached – called by LiteCore after c4socket_fromNative creates the
+ * peripheral (incoming) C4Socket.
+ *
+ * Retrieves the BTNativeHandle stored by fromNative via setNativeHandle(),
+ * forwards {btSocketHandle, peerID} to Java, then frees the handle.
+ */
+static void btAttached(C4Socket* socket) {
+    auto* ctx = static_cast<BTNativeHandle*>(socket->getNativeHandle());
+    if (!ctx) return;
+
+    // Clear immediately so btDispose won't double-free.
+    socket->setNativeHandle(nullptr);
+
+    JNIEnv* env = nullptr;
+    jint envState = attachJVM(&env, "btAttached");
+    if (envState != JNI_OK && envState != JNI_EDETACHED) {
+        delete ctx;
+        return;
+    }
+
+    jstring jPeerID = env->NewStringUTF((ctx->peerID).c_str());
+
+    env->CallStaticVoidMethod(
+            cls_C4BTSocketFactory, m_attached,
+            (jlong) socket,
+            ctx->btSocketHandle,
+            jPeerID);
+
+    delete ctx;
+
+    if (envState == JNI_EDETACHED) {
+        detachJVM("btAttached");
+    } else {
+        if (jPeerID) env->DeleteLocalRef(jPeerID);
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// The factory struct
+// ─────────────────────────────────────────────────────────────────────────────
+namespace litecore::jni {
+    const C4SocketFactory kBTSocketFactory{
+            .framing         = kC4WebSocketClientFraming,
+            .context         = nullptr,          // filled in at registration time
+            .open            = btOpen,
+            .write           = btWrite,
+            .completedReceive = btCompletedReceive,
+            .close           = btClose,
+            .dispose         = btDispose,
+            .attached        = btAttached,
+    };
+}
+#endif // COUCHBASE_ENTERPRISE && __ANDROID__