[SES-3717] - Add support for multi-part config and tidy up JNI usages

.drone.yml

@@ -16,7 +16,7 @@ steps:
     environment:
       ANDROID_HOME: /usr/lib/android-sdk
     commands:
-      - apt-get -y install ninja-build
+      - apt-get -y update && apt-get -y install ninja-build
       - update-java-alternatives -s java-1.17.0-openjdk-amd64
       - env VERSION=`git describe --tags --dirty` ./gradlew publish
 
@@ -26,5 +26,5 @@ steps:
       SSH_KEY:
         from_secret: SSH_KEY
     commands:
-      - apt-get -y install python3
+      - apt-get -y update && apt-get -y install python3
       - ./scripts/upload-maven-artifacts.py

library/src/main/cpp/config_base.cpp

@@ -29,24 +29,17 @@ Java_network_loki_messenger_libsession_1util_ConfigBase_push(JNIEnv *env, jobjec
     return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto config = ptrToConfigBase(env, thiz);
-        auto push_tuple = config->push();
-        auto to_push_str = std::get<1>(push_tuple);
-        auto to_delete = std::get<2>(push_tuple);
+        auto [seq_no, to_push, to_delete] = config->push();
+
+        jobject messages = jni_utils::jlist_from_collection(env, to_push, [](JNIEnv *env, const std::vector<unsigned char> &data) {
+            return jni_utils::session_bytes_from_range(env, data);
+        });
+
+        jobject obsoleteHashes = jni_utils::jstring_list_from_collection(env, to_delete);
 
-        jbyteArray returnByteArray = util::bytes_from_vector(env, to_push_str);
-        jlong seqNo = std::get<0>(push_tuple);
         jclass returnObjectClass = env->FindClass("network/loki/messenger/libsession_util/util/ConfigPush");
-        jclass stackClass = env->FindClass("java/util/Stack");
-        jmethodID methodId = env->GetMethodID(returnObjectClass, "<init>", "([BJLjava/util/List;)V");
-        jmethodID stack_init = env->GetMethodID(stackClass, "<init>", "()V");
-        jobject our_stack = env->NewObject(stackClass, stack_init);
-        jmethodID push_stack = env->GetMethodID(stackClass, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-        for (auto entry : to_delete) {
-            auto entry_jstring = env->NewStringUTF(entry.data());
-            env->CallObjectMethod(our_stack, push_stack, entry_jstring);
-        }
-        jobject returnObject = env->NewObject(returnObjectClass, methodId, returnByteArray, seqNo, our_stack);
-        return returnObject;
+        jmethodID methodId = env->GetMethodID(returnObjectClass, "<init>", "(Ljava/util/List;JLjava/util/List;)V");
+        return env->NewObject(returnObjectClass, methodId, messages, static_cast<jlong>(seq_no), obsoleteHashes);
     });
 }
 
@@ -75,12 +68,21 @@ Java_network_loki_messenger_libsession_1util_ConfigBase_encryptionDomain(JNIEnv
 JNIEXPORT void JNICALL
 Java_network_loki_messenger_libsession_1util_ConfigBase_confirmPushed(JNIEnv *env, jobject thiz,
                                                                       jlong seq_no,
-                                                                      jstring new_hash_jstring) {
+                                                                      jobjectArray hash_list) {
     std::lock_guard lock{util::util_mutex_};
     auto conf = ptrToConfigBase(env, thiz);
-    auto new_hash = env->GetStringUTFChars(new_hash_jstring, nullptr);
-    conf->confirm_pushed(seq_no, new_hash);
-    env->ReleaseStringUTFChars(new_hash_jstring, new_hash);
+    auto hash_list_size = env->GetArrayLength(hash_list);
+    std::unordered_set<std::string> hashes(hash_list_size);
+
+    for (int i = 0; i < hash_list_size; i++) {
+        auto hash_jstring = (jstring) env->GetObjectArrayElement(hash_list, i);
+        auto hash = env->GetStringUTFChars(hash_jstring, nullptr);
+        hashes.insert(hash);
+        env->ReleaseStringUTFChars(hash_jstring, hash);
+        env->DeleteLocalRef(hash_jstring);
+    }
+
+    conf->confirm_pushed(seq_no, hashes);
 }
 
 #pragma clang diagnostic push
@@ -98,9 +100,7 @@ Java_network_loki_messenger_libsession_1util_ConfigBase_merge___3Lkotlin_Pair_2(
             auto pair = extractHashAndData(env, jElement);
             configs.push_back(pair);
         }
-        auto returned = conf->merge(configs);
-        auto string_stack = util::build_string_stack(env, returned);
-        return string_stack;
+        return jni_utils::jstring_list_from_collection(env, conf->merge(configs));
     });
 }
 
@@ -137,16 +137,8 @@ Java_network_loki_messenger_libsession_1util_ConfigBase_00024Companion_kindFor(J
 
 extern "C"
 JNIEXPORT jobject JNICALL
-Java_network_loki_messenger_libsession_1util_ConfigBase_currentHashes(JNIEnv *env, jobject thiz) {
+Java_network_loki_messenger_libsession_1util_ConfigBase_activeHashes(JNIEnv *env, jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto conf = ptrToConfigBase(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    auto vec = conf->current_hashes();
-    for (std::string element: vec) {
-        env->CallObjectMethod(our_stack, push, env->NewStringUTF(element.data()));
-    }
-    return our_stack;
+    return jni_utils::jstring_list_from_collection(env, conf->active_hashes());
 }

library/src/main/cpp/contacts.cpp

@@ -69,14 +69,6 @@ Java_network_loki_messenger_libsession_1util_Contacts_all(JNIEnv *env, jobject t
     return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto contacts = ptrToContacts(env, thiz);
-        jclass stack = env->FindClass("java/util/Stack");
-        jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-        jobject our_stack = env->NewObject(stack, init);
-        jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-        for (const auto &contact: *contacts) {
-            auto contact_obj = serialize_contact(env, contact);
-            env->CallObjectMethod(our_stack, push, contact_obj);
-        }
-        return our_stack;
+        return jni_utils::jlist_from_collection(env, *ptrToContacts(env, thiz), serialize_contact);
     });
 }

library/src/main/cpp/conversation.cpp

@@ -1,5 +1,6 @@
 #include <jni.h>
 #include "conversation.h"
+#include "jni_utils.h"
 
 
 extern "C"
@@ -266,57 +267,35 @@ Java_network_loki_messenger_libsession_1util_ConversationVolatileConfig_all(JNIE
                                                                             jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto convos = ptrToConvoInfo(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (const auto& convo : *convos) {
-        auto contact_obj = serialize_any(env, convo);
-        env->CallObjectMethod(our_stack, push, contact_obj);
-    }
-    return our_stack;
+
+    return jni_utils::jlist_from_collection(env, *convos, serialize_any);
 }
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_ConversationVolatileConfig_allOneToOnes(JNIEnv *env,
                                                                                      jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto convos = ptrToConvoInfo(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto contact = convos->begin_1to1(); contact != convos->end(); ++contact)
-        env->CallObjectMethod(our_stack, push, serialize_one_to_one(env, *contact));
-    return our_stack;
+    return jni_utils::jlist_from_iterator(env, convos->begin_1to1(), convos->end(),
+                                          serialize_one_to_one);
 }
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_ConversationVolatileConfig_allCommunities(JNIEnv *env,
                                                                                       jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto convos = ptrToConvoInfo(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto contact = convos->begin_communities(); contact != convos->end(); ++contact)
-        env->CallObjectMethod(our_stack, push, serialize_open_group(env, *contact));
-    return our_stack;
+    return jni_utils::jlist_from_iterator(env, convos->begin_communities(), convos->end(),
+                                          serialize_open_group);
 }
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_ConversationVolatileConfig_allLegacyClosedGroups(
         JNIEnv *env, jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto convos = ptrToConvoInfo(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto contact = convos->begin_legacy_groups(); contact != convos->end(); ++contact)
-        env->CallObjectMethod(our_stack, push, serialize_legacy_group(env, *contact));
-    return our_stack;
+    return jni_utils::jlist_from_iterator(env, convos->begin_legacy_groups(), convos->end(),
+                                          serialize_legacy_group);
 }
 
 extern "C"
@@ -325,13 +304,8 @@ Java_network_loki_messenger_libsession_1util_ConversationVolatileConfig_allClose
                                                                                         jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto convos = ptrToConvoInfo(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto contact = convos->begin_groups(); contact != convos->end(); ++contact)
-        env->CallObjectMethod(our_stack, push, serialize_closed_group(env, *contact));
-    return our_stack;
+    return jni_utils::jlist_from_iterator(env, convos->begin_groups(), convos->end(),
+                                          serialize_closed_group);
 }
 
 extern "C"

library/src/main/cpp/group_keys.cpp

@@ -57,16 +57,7 @@ JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_groupKeys(JNIEnv *env, jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto config = ptrToKeys(env, thiz);
-    auto keys = config->group_keys();
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto& key : keys) {
-        auto key_bytes = util::bytes_from_span(env, key);
-        env->CallObjectMethod(our_stack, push, key_bytes);
-    }
-    return our_stack;
+    return jni_utils::jlist_from_collection(env, config->group_keys(), util::bytes_from_span);
 }
 
 extern "C"
@@ -206,34 +197,16 @@ JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_keys(JNIEnv *env, jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto ptr = ptrToKeys(env, thiz);
-    auto keys = ptr->group_keys();
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto& key : keys) {
-        auto key_bytes = util::bytes_from_span(env, key);
-        env->CallObjectMethod(our_stack, push, key_bytes);
-    }
-    return our_stack;
+    return jni_utils::jlist_from_collection(env, ptr->group_keys(), util::bytes_from_span);
 }
 
 extern "C"
 JNIEXPORT jobject JNICALL
-Java_network_loki_messenger_libsession_1util_GroupKeysConfig_currentHashes(JNIEnv *env,
+Java_network_loki_messenger_libsession_1util_GroupKeysConfig_activeHashes(JNIEnv *env,
                                                                            jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto ptr = ptrToKeys(env, thiz);
-    auto existing = ptr->current_hashes();
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_list = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto& hash : existing) {
-        auto hash_bytes = env->NewStringUTF(hash.data());
-        env->CallObjectMethod(our_list, push, hash_bytes);
-    }
-    return our_list;
+    return jni_utils::jstring_list_from_collection(env, ptr->active_hashes());
 }
 extern "C"
 JNIEXPORT jbyteArray JNICALL

library/src/main/cpp/group_members.cpp

@@ -29,15 +29,7 @@ JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_GroupMembersConfig_all(JNIEnv *env, jobject thiz) {
     std::lock_guard lock{util::util_mutex_};
     auto config = ptrToMembers(env, thiz);
-    jclass stack = env->FindClass("java/util/Stack");
-    jmethodID init = env->GetMethodID(stack, "<init>", "()V");
-    jobject our_stack = env->NewObject(stack, init);
-    jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (auto& member : *config) {
-        auto member_obj = util::serialize_group_member(env, member);
-        env->CallObjectMethod(our_stack, push, member_obj);
-    }
-    return our_stack;
+    return jni_utils::jlist_from_collection(env, *config, util::serialize_group_member);
 }
 
 extern "C"

library/src/main/cpp/jni_utils.h

@@ -3,6 +3,10 @@
 
 #include <jni.h>
 #include <exception>
+#include <ranges>
+#include <type_traits>
+
+#include "util.h"
 
 namespace jni_utils {
     /**
@@ -49,6 +53,43 @@ namespace jni_utils {
             return RetT();
         });
     }
+
+    template <typename IterBegin, typename IterEnd, typename ConvertItemFunc>
+    jobject jlist_from_iterator(JNIEnv *env, IterBegin begin, IterEnd end, const ConvertItemFunc &func) {
+        jclass list_clazz = env->FindClass("java/util/ArrayList");
+        jmethodID init = env->GetMethodID(list_clazz, "<init>", "()V");
+        jobject our_list = env->NewObject(list_clazz, init);
+        jmethodID push = env->GetMethodID(list_clazz, "add", "(Ljava/lang/Object;)Z");
+
+        for (auto iter = begin; iter != end; ++iter) {
+            jobject item_java = func(env, *iter);
+            env->CallBooleanMethod(our_list, push, item_java);
+            env->DeleteLocalRef(item_java);
+        }
+
+        env->DeleteLocalRef(list_clazz);
+        return our_list;
+    }
+
+    template <typename Collection, typename ConvertItemFunc>
+    jobject jlist_from_collection(JNIEnv *env, const Collection& obj, const ConvertItemFunc &func) {
+        return jlist_from_iterator(env, obj.begin(), obj.end(), func);
+    }
+
+    template <typename Collection>
+    jobject jstring_list_from_collection(JNIEnv *env, const Collection& obj) {
+        return jlist_from_collection(env, obj, util::jstringFromOptional);
+    }
+
+    template <typename Collection>
+    jobject session_bytes_from_range(JNIEnv *env, const Collection &obj) {
+        jclass bytes_clazz = env->FindClass("network/loki/messenger/libsession_util/util/Bytes");
+        jmethodID init = env->GetMethodID(bytes_clazz, "<init>", "([B)V");
+
+        auto bytes_array = env->NewByteArray(static_cast<jsize>(obj.size()));
+        env->SetByteArrayRegion(bytes_array, 0, static_cast<jsize>(obj.size()), reinterpret_cast<const jbyte *>(obj.data()));
+        return env->NewObject(bytes_clazz, init, bytes_array);
+    }
 }
 
 #endif //SESSION_ANDROID_JNI_UTILS_H