[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,20 @@ 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 = jni_utils::JavaLocalRef(env, (jstring) env->GetObjectArrayElement(hash_list, i));
+        auto hash = env->GetStringUTFChars(hash_jstring.get(), nullptr);
+        hashes.insert(hash);
+        env->ReleaseStringUTFChars(hash_jstring.get(), hash);
+    }
+
+    conf->confirm_pushed(seq_no, hashes);
 }
 
 #pragma clang diagnostic push
@@ -98,9 +99,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 +136,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/config_base.h

@@ -3,31 +3,32 @@
 
 #include "session/config/base.hpp"
 #include "util.h"
+#include "jni_utils.h"
 #include <jni.h>
 #include <string>
 
 inline session::config::ConfigBase* ptrToConfigBase(JNIEnv *env, jobject obj) {
-    jclass baseClass = env->FindClass("network/loki/messenger/libsession_util/ConfigBase");
-    jfieldID pointerField = env->GetFieldID(baseClass, "pointer", "J");
+    auto baseClass = jni_utils::JavaLocalRef(env, env->FindClass("network/loki/messenger/libsession_util/ConfigBase"));
+    jfieldID pointerField = env->GetFieldID(baseClass.get(), "pointer", "J");
     return (session::config::ConfigBase*) env->GetLongField(obj, pointerField);
 }
 
 inline std::pair<std::string, std::vector<unsigned char>> extractHashAndData(JNIEnv *env, jobject kotlin_pair) {
-    jclass pair = env->FindClass("kotlin/Pair");
-    jfieldID first = env->GetFieldID(pair, "first", "Ljava/lang/Object;");
-    jfieldID second = env->GetFieldID(pair, "second", "Ljava/lang/Object;");
-    jstring hash_as_jstring = static_cast<jstring>(env->GetObjectField(kotlin_pair, first));
-    jbyteArray data_as_jbytes = static_cast<jbyteArray>(env->GetObjectField(kotlin_pair, second));
-    auto hash_as_string = env->GetStringUTFChars(hash_as_jstring, nullptr);
-    auto data_as_vector = util::vector_from_bytes(env, data_as_jbytes);
+    auto pair = jni_utils::JavaLocalRef(env, env->FindClass("kotlin/Pair"));
+    jfieldID first = env->GetFieldID(pair.get(), "first", "Ljava/lang/Object;");
+    jfieldID second = env->GetFieldID(pair.get(), "second", "Ljava/lang/Object;");
+    auto hash_as_jstring = jni_utils::JavaLocalRef(env, static_cast<jstring>(env->GetObjectField(kotlin_pair, first)));
+    auto data_as_jbytes = jni_utils::JavaLocalRef(env, static_cast<jbyteArray>(env->GetObjectField(kotlin_pair, second)));
+    auto hash_as_string = env->GetStringUTFChars(hash_as_jstring.get(), nullptr);
+    auto data_as_vector = util::vector_from_bytes(env, data_as_jbytes.get());
     auto ret_pair = std::pair<std::string, std::vector<unsigned char>>{hash_as_string, data_as_vector};
-    env->ReleaseStringUTFChars(hash_as_jstring, hash_as_string);
+    env->ReleaseStringUTFChars(hash_as_jstring.get(), hash_as_string);
     return ret_pair;
 }
 
 inline session::config::ConfigSig* ptrToConfigSig(JNIEnv* env, jobject obj) {
-    jclass sigClass = env->FindClass("network/loki/messenger/libsession_util/ConfigSig");
-    jfieldID pointerField = env->GetFieldID(sigClass, "pointer", "J");
+    auto sigClass = jni_utils::JavaLocalRef(env, env->FindClass("network/loki/messenger/libsession_util/ConfigSig"));
+    jfieldID pointerField = env->GetFieldID(sigClass.get(), "pointer", "J");
     return (session::config::ConfigSig*) env->GetLongField(obj, pointerField);
 }
 

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/contacts.h

@@ -5,27 +5,28 @@
 #include <vector>
 #include "session/config/contacts.hpp"
 #include "util.h"
+#include "jni_utils.h"
 
 inline session::config::Contacts *ptrToContacts(JNIEnv *env, jobject obj) {
-    jclass contactsClass = env->FindClass("network/loki/messenger/libsession_util/Contacts");
-    jfieldID pointerField = env->GetFieldID(contactsClass, "pointer", "J");
+    auto contactsClass = jni_utils::JavaLocalRef(env, env->FindClass("network/loki/messenger/libsession_util/Contacts"));
+    jfieldID pointerField = env->GetFieldID(contactsClass.get(), "pointer", "J");
     return (session::config::Contacts *) env->GetLongField(obj, pointerField);
 }
 
 inline jobject serialize_contact(JNIEnv *env, session::config::contact_info info) {
-    jclass contactClass = env->FindClass("network/loki/messenger/libsession_util/util/Contact");
-    jmethodID constructor = env->GetMethodID(contactClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZLnetwork/loki/messenger/libsession_util/util/UserPic;JLnetwork/loki/messenger/libsession_util/util/ExpiryMode;)V");
-    jstring id = env->NewStringUTF(info.session_id.data());
-    jstring name = env->NewStringUTF(info.name.data());
-    jstring nickname = env->NewStringUTF(info.nickname.data());
+    auto contactClass = jni_utils::JavaLocalRef(env, env->FindClass("network/loki/messenger/libsession_util/util/Contact"));
+    jmethodID constructor = env->GetMethodID(contactClass.get(), "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZLnetwork/loki/messenger/libsession_util/util/UserPic;JLnetwork/loki/messenger/libsession_util/util/ExpiryMode;)V");
+    auto id = jni_utils::JavaLocalRef(env, env->NewStringUTF(info.session_id.data()));
+    auto name = jni_utils::JavaLocalRef(env, env->NewStringUTF(info.name.data()));
+    auto nickname = jni_utils::JavaLocalRef(env, env->NewStringUTF(info.nickname.data()));
     jboolean approved, approvedMe, blocked;
     approved = info.approved;
     approvedMe = info.approved_me;
     blocked = info.blocked;
     auto created = info.created;
-    jobject profilePic = util::serialize_user_pic(env, info.profile_picture);
-    jobject returnObj = env->NewObject(contactClass, constructor, id, name, nickname, approved,
-                                       approvedMe, blocked, profilePic, (jlong)info.priority,
+    auto profilePic = jni_utils::JavaLocalRef(env, util::serialize_user_pic(env, info.profile_picture));
+    jobject returnObj = env->NewObject(contactClass.get(), constructor, id.get(), name.get(), nickname.get(), approved,
+                                       approvedMe, blocked, profilePic.get(), (jlong)info.priority,
                                        util::serialize_expiry(env, info.exp_mode, info.exp_timer));
     return returnObj;
 }
@@ -44,35 +45,34 @@ inline session::config::contact_info deserialize_contact(JNIEnv *env, jobject in
                                  "Lnetwork/loki/messenger/libsession_util/util/UserPic;");
     getPriority = env->GetFieldID(contactClass, "priority", "J");
     getExpiry = env->GetFieldID(contactClass, "expiryMode", "Lnetwork/loki/messenger/libsession_util/util/ExpiryMode;");
-    jstring name, nickname, account_id;
-    account_id = static_cast<jstring>(env->GetObjectField(info, getId));
-    name = static_cast<jstring>(env->GetObjectField(info, getName));
-    nickname = static_cast<jstring>(env->GetObjectField(info, getNick));
+    auto account_id = jni_utils::JavaLocalRef(env, static_cast<jstring>(env->GetObjectField(info, getId)));
+    auto name = jni_utils::JavaLocalRef(env, static_cast<jstring>(env->GetObjectField(info, getName)));
+    auto nickname = jni_utils::JavaLocalRef(env, static_cast<jstring>(env->GetObjectField(info, getNick)));
     bool approved, approvedMe, blocked, hidden;
     int priority = env->GetLongField(info, getPriority);
     approved = env->GetBooleanField(info, getApproved);
     approvedMe = env->GetBooleanField(info, getApprovedMe);
     blocked = env->GetBooleanField(info, getBlocked);
-    jobject user_pic = env->GetObjectField(info, getUserPic);
-    jobject expiry_mode = env->GetObjectField(info, getExpiry);
+    auto user_pic = jni_utils::JavaLocalRef(env, env->GetObjectField(info, getUserPic));
+    auto expiry_mode = jni_utils::JavaLocalRef(env, env->GetObjectField(info, getExpiry));
 
-    auto expiry_pair = util::deserialize_expiry(env, expiry_mode);
+    auto expiry_pair = util::deserialize_expiry(env, expiry_mode.get());
 
     std::string url;
     std::vector<unsigned char> key;
 
-    if (user_pic != nullptr) {
-        auto deserialized_pic = util::deserialize_user_pic(env, user_pic);
+    if (user_pic.get() != nullptr) {
+        auto deserialized_pic = util::deserialize_user_pic(env, user_pic.get());
         auto url_jstring = deserialized_pic.first;
         auto url_bytes = env->GetStringUTFChars(url_jstring, nullptr);
         url = std::string(url_bytes);
         env->ReleaseStringUTFChars(url_jstring, url_bytes);
         key = util::vector_from_bytes(env, deserialized_pic.second);
     }
 
-    auto account_id_bytes = env->GetStringUTFChars(account_id, nullptr);
-    auto name_bytes = name ? env->GetStringUTFChars(name, nullptr) : nullptr;
-    auto nickname_bytes = nickname ? env->GetStringUTFChars(nickname, nullptr) : nullptr;
+    auto account_id_bytes = env->GetStringUTFChars(account_id.get(), nullptr);
+    auto name_bytes = name.get() ? env->GetStringUTFChars(name.get(), nullptr) : nullptr;
+    auto nickname_bytes = nickname.get() ? env->GetStringUTFChars(nickname.get(), nullptr) : nullptr;
 
     auto contact_info = conf->get_or_construct(account_id_bytes);
     if (name_bytes) {
@@ -90,12 +90,12 @@ inline session::config::contact_info deserialize_contact(JNIEnv *env, jobject in
         contact_info.profile_picture = session::config::profile_pic();
     }
 
-    env->ReleaseStringUTFChars(account_id, account_id_bytes);
+    env->ReleaseStringUTFChars(account_id.get(), account_id_bytes);
     if (name_bytes) {
-        env->ReleaseStringUTFChars(name, name_bytes);
+        env->ReleaseStringUTFChars(name.get(), name_bytes);
     }
     if (nickname_bytes) {
-        env->ReleaseStringUTFChars(nickname, nickname_bytes);
+        env->ReleaseStringUTFChars(nickname.get(), nickname_bytes);
     }
 
     contact_info.priority = priority;

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"