Message pro features

Author: SessionHero01

library/src/androidTest/kotlin/network/loki/messenger/libsession_util/protocol/SessionProtocolTest.kt

@@ -0,0 +1,23 @@
+package network.loki.messenger.libsession_util.protocol
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SessionProtocolTest {
+
+    @Test
+    fun proFeaturesForMessageWorks() {
+        val proposedFeatures = ProFeatures.from(listOf(ProFeature.PRO_BADGE))
+        val result = SessionProtocol.proFeaturesForMessage(
+            messageBody = "Hello, Session Pro!",
+            proposedFeatures
+        )
+
+        assertEquals(ProFeaturesForMsg.Status.Success, result.status)
+        assertEquals(19, result.codepointCount)
+        assertEquals(proposedFeatures, result.features)
+    }
+}

library/src/main/cpp/jni_utils.h

@@ -200,6 +200,37 @@ namespace jni_utils {
             }
     };
 
+    class JavaCharsRef {
+        JNIEnv *env;
+        jstring s;
+        std::span<jchar> data;
+
+    public:
+        JavaCharsRef(JNIEnv *env, jstring s) : env(env), s(s) {
+            const jchar *c_str = env->GetStringChars(s, nullptr);
+            data = std::span<jchar>(const_cast<jchar *>(c_str), env->GetStringLength(s));
+        }
+
+        JavaCharsRef(const JavaCharsRef &) = delete;
+
+        ~JavaCharsRef() {
+            env->ReleaseStringChars(s, data.data());
+        }
+
+        const jchar* chars() const {
+            return data.data();
+        }
+
+        size_t size() const {
+            return data.size();
+        }
+
+        // Get the data as a span. Only valid during the lifetime of this object.
+        std::span<jchar> get() const {
+            return data;
+        }
+    };
+
     /**
      * A RAII wrapper for a Java byte array. This will automatically release the byte array when it goes out of scope.
      */

library/src/main/cpp/protocol.cpp

@@ -262,4 +262,29 @@ Java_network_loki_messenger_libsession_1util_protocol_SessionProtocol_decodeForG
                 *java_to_cpp_array<32>(env, pro_backend_pub_key)
         ));
     });
+}
+
+extern "C"
+JNIEXPORT jobject JNICALL
+Java_network_loki_messenger_libsession_1util_protocol_SessionProtocol_proFeaturesForMessage(
+        JNIEnv *env, jobject thiz, jstring message_body, jlong proposed_features) {
+    return run_catching_cxx_exception_or_throws<jobject>(env, [=] {
+        JavaCharsRef message_ref(env, message_body);
+
+        auto features = session::pro_features_for_utf16(
+                reinterpret_cast<const char16_t *>(message_ref.chars()),
+                message_ref.size(),
+                static_cast<SESSION_PROTOCOL_PRO_FEATURES>(proposed_features)
+        );
+
+        auto clazz = env->FindClass("network/loki/messenger/libsession_util/protocol/ProFeaturesForMsg");
+        return env->NewObject(
+                clazz,
+                env->GetMethodID(clazz, "<init>", "(ILjava/lang/String;JI)V"),
+                static_cast<jint>(features.status),
+                features.error.empty() ? nullptr : env->NewStringUTF(std::string(features.error).c_str()),
+                static_cast<jlong>(features.features),
+                static_cast<jint>(features.codepoint_count)
+        );
+    });
 }

library/src/main/java/network/loki/messenger/libsession_util/protocol/ProFeatures.kt

@@ -14,6 +14,10 @@ enum class ProFeature(internal val bitIndex: Int) {
 value class ProFeatures(val rawValue: Long) {
     companion object {
         val NONE = ProFeatures(0L)
+
+        fun from(features: Collection<ProFeature>): ProFeatures {
+            return ProFeatures(features.toLong())
+        }
     }
 
     fun contains(feature: ProFeature): Boolean {

library/src/main/java/network/loki/messenger/libsession_util/protocol/ProFeaturesForMsg.kt

@@ -0,0 +1,37 @@
+package network.loki.messenger.libsession_util.protocol
+
+import androidx.annotation.Keep
+
+/**
+ * Represents the result of trying to augment a message with Pro features.
+ *
+ * @param status The status of the augmentation attempt.
+ * @param error An optional error message if the augmentation failed.
+ * @param features The Pro features that were successfully applied.
+ * @param codepointCount The number of codepoints in the message
+ */
+data class ProFeaturesForMsg(
+    val status: Status,
+    val error: String?,
+    val features: ProFeatures,
+    val codepointCount: Int,
+) {
+    @Keep
+    constructor(
+        statusNativeValue: Int,
+        error: String?,
+        featuresNativeValue: Long,
+        codepointCount: Int,
+    ) : this(
+        status = Status.entries.first { it.nativeValue == statusNativeValue },
+        error = error,
+        features = ProFeatures(featuresNativeValue),
+        codepointCount = codepointCount,
+    )
+
+    enum class Status(internal val nativeValue: Int) {
+        Success(0),
+        UTFDecodingError(1),
+        ExceedsCharacterLimit(2),
+    }
+}

library/src/main/java/network/loki/messenger/libsession_util/protocol/SessionProtocol.kt

@@ -55,4 +55,17 @@ object SessionProtocol : LibSessionUtilCApi() {
         groupEd25519PrivateKeys: Array<ByteArray>, // all available group private keys
         proBackendPubKey: ByteArray, // 32 bytes backend key
     ): DecodedEnvelope
+
+    private external fun proFeaturesForMessage(
+        messageBody: String,
+        proposedFeatures: Long
+    ): ProFeaturesForMsg
+
+    /**
+     * Determines which Pro features shall be applied to a message based on its content and the proposed features.
+     */
+    fun proFeaturesForMessage(
+        messageBody: String,
+        proposedFeatures: ProFeatures
+    ): ProFeaturesForMsg = proFeaturesForMessage(messageBody, proposedFeatures.rawValue)
 }