feat: add bytes methods and using embeded TextEncoder and TextDecoder (#113)

* feat: add bytes methods and using embeded TextEncoder and TextDecoder

* chore: update readme

* chore: removed unused dep

* chore: fix types

* chore: fix types

Author: jerson

README.md

@@ -10,12 +10,12 @@
 ## JSI
 
 
-If you want to use with `JSI` instead of `NativeModules` you need to set
+If you want to use with `NativeModules` instead of `JSI` you need to set
 
 ```typescript
 import OpenPGP from "react-native-fast-openpgp";
 
-OpenPGP.useJSI = true;
+OpenPGP.useJSI = false;
 ```
 if you need to use generate methods it is a good idea to disable it, because for now JSI will block your UI but it is faster compared to NativeModules
 
@@ -27,9 +27,11 @@ if you need to use generate methods it is a good idea to disable it, because for
 import OpenPGP from "react-native-fast-openpgp";
 
 const encrypted = await OpenPGP.encrypt(message: string, publicKey: string, signedEntity?: Entity, fileHints?: FileHints, options?: KeyOptions ): Promise<string>;
+const encrypted = await OpenPGP.encryptBytes(message: Uint8Array, publicKey: string, signedEntity?: Entity, fileHints?: FileHints, options?: KeyOptions ): Promise<Uint8Array>;
 const outputFile = await OpenPGP.encryptFile(inputFile: string, outputFile: string, publicKey: string, signedEntity?: Entity, fileHints?: FileHints, options?: KeyOptions): Promise<number>;
 
 const encryptedSymmetric = await OpenPGP.encryptSymmetric(message: string, passphrase: string, fileHints?: FileHints, options?: KeyOptions ): Promise<string>;
+const encryptedSymmetric = await OpenPGP.encryptSymmetricBytes(message: Uint8Array, passphrase: string, fileHints?: FileHints, options?: KeyOptions ): Promise<Uint8Array>;
 const outputFile = await OpenPGP.encryptSymmetricFile(inputFile: string, outputFile: string, passphrase: string, fileHints?: FileHints, options?: KeyOptions ): Promise<number> ;
 ```
 
@@ -38,9 +40,11 @@ const outputFile = await OpenPGP.encryptSymmetricFile(inputFile: string, outputF
 import OpenPGP from "react-native-fast-openpgp";
 
 const decrypted = await OpenPGP.decrypt(message: string, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<string>;
+const decrypted = await OpenPGP.decryptBytes(message: Uint8Array, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<Uint8Array>;
 const outputFile = await OpenPGP.decryptFile(inputFile: string, outputFile: string, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<number>;
 
 const decryptedSymmetric = await OpenPGP.decryptSymmetric(message: string, passphrase: string, options?: KeyOptions ): Promise<string>;
+const decryptedSymmetric = await OpenPGP.decryptSymmetricBytes(message: Uint8Array, passphrase: string, options?: KeyOptions ): Promise<Uint8Array>;
 const outputFile = await OpenPGP.decryptSymmetricFile(inputFile: string, outputFile: string, passphrase: string, options?: KeyOptions ): Promise<number> ;
 ```
 
@@ -49,9 +53,12 @@ const outputFile = await OpenPGP.decryptSymmetricFile(inputFile: string, outputF
 import OpenPGP from "react-native-fast-openpgp";
 
 const signed = await OpenPGP.sign(message: string, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<string>;
+const signed = await OpenPGP.signBytes(message: Uint8Array, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<Uint8Array>;
+const signed = await OpenPGP.signBytesToString(message: Uint8Array, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<string>;
 const signed = await OpenPGP.signFile(inputFile: string, privateKey: string, passphrase: string, options?: KeyOptions ): Promise<string>;
 
 const verified = await OpenPGP.verify(signature: string, message: string, publicKey: string ): Promise<boolean>;
+const verified = await OpenPGP.verifyBytes(signature: string, message: Uint8Array, publicKey: string ): Promise<boolean>;
 const verified = await OpenPGP.verifyFile(signature: string, inputFile: string,publicKey: string): Promise<boolean>;
 ```
 

android/fast-openpgp-adapter.cpp

@@ -92,3 +92,96 @@ Java_com_fastopenpgp_FastOpenpgpModule_callNative(JNIEnv* env,
 
   return result;
 }
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_fastopenpgp_FastOpenpgpModule_encodeTextNative(JNIEnv* env, jobject thiz, jstring input, jstring encoding) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* inputCStr = env->GetStringUTFChars(input, nullptr);
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+
+    if (inputCStr == nullptr || encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input' or 'encoding'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    BytesReturn* response = OpenPGPEncodeText(const_cast<char*>(inputCStr), const_cast<char*>(encodingCStr));
+
+    // Release allocated resources
+    env->ReleaseStringUTFChars(input, inputCStr);
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+
+    if (response->error != nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, response->error);
+        free(response);
+        return nullptr;
+    }
+
+    // Create a new byte array to return the encoded data
+    jbyteArray result = env->NewByteArray(response->size);
+    if (result == nullptr) {
+        free(response);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for result");
+        return nullptr;
+    }
+
+    env->SetByteArrayRegion(result, 0, response->size, reinterpret_cast<jbyte*>(response->message));
+    free(response);
+
+    return result;
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_fastopenpgp_FastOpenpgpModule_decodeTextNative(JNIEnv* env, jobject thiz, jbyteArray input, jstring encoding, 
+                                          jint fatal, jint ignoreBOM, jint stream) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+    if (encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'encoding'");
+        return nullptr;
+    }
+
+    // Convert Java byte array to C byte array
+    jsize size = env->GetArrayLength(input);
+    jbyte* inputBytes = env->GetByteArrayElements(input, nullptr);
+    if (inputBytes == nullptr) {
+        env->ReleaseStringUTFChars(encoding, encodingCStr);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    char* decodedString = OpenPGPDecodeText(inputBytes, size, const_cast<char*>(encodingCStr), fatal, ignoreBOM, stream);
+
+    // Release resources
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+    env->ReleaseByteArrayElements(input, inputBytes, JNI_ABORT);
+
+    if (decodedString == nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, "Decoding failed");
+        return nullptr;
+    }
+
+    // Convert C string to Java string and return
+    jstring result = env->NewStringUTF(decodedString);
+    free(decodedString);
+    return result;
+}

android/src/main/java/com/fastopenpgp/FastOpenpgpModule.kt

@@ -12,6 +12,8 @@ internal class FastOpenpgpModule(reactContext: ReactApplicationContext) :
   external fun initialize(jsContext: Long)
   external fun destruct();
   external fun callNative(name: String, payload: ByteArray): ByteArray;
+  external fun encodeTextNative(input: String, encoding: String): ByteArray
+  external fun decodeTextNative(input: ByteArray, encoding: String, fatal: Int, ignoreBOM: Int, stream: Int): String
 
   companion object {
     init {
@@ -38,6 +40,32 @@ internal class FastOpenpgpModule(reactContext: ReactApplicationContext) :
     }.start()
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun encodeText(input: String, encoding: String): WritableArray {
+      return try {
+          val result = encodeTextNative(input, encoding) 
+          Arguments.createArray().apply {
+              result.forEach { byteValue: Byte -> pushInt(byteValue.toInt() and 0xFF) } 
+          }
+      } catch (e: Exception) {
+          Log.e(TAG, "Encoding error", e)
+          throw RuntimeException("ENCODE_ERROR: Failed to encode text")
+      }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun decodeText(input: ReadableArray, encoding: String, fatal: Boolean, ignoreBOM: Boolean, stream: Boolean): String {
+      return try {
+          val bytes = ByteArray(input.size()) { index ->
+              input.getInt(index).toByte()
+          }
+          decodeTextNative(bytes, encoding, if (fatal) 1 else 0, if (ignoreBOM) 1 else 0, if (stream) 1 else 0)
+      } catch (e: Exception) {
+          Log.e(TAG, "Decoding error", e)
+          throw RuntimeException("DECODE_ERROR: Failed to decode text")
+      }
+  }
+
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
     Log.d(TAG, "Attempting to install JSI bindings...")

android/src/main/jniLibs/arm64-v8a/libopenpgp_bridge.h

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* OpenPGPBridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* OpenPGPEncodeText(char* input, char* encoding);
+extern char* OpenPGPDecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/arm64-v8a/libopenpgp_bridge.so

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* OpenPGPBridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* OpenPGPEncodeText(char* input, char* encoding);
+extern char* OpenPGPDecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/armeabi-v7a/libopenpgp_bridge.h

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* OpenPGPBridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* OpenPGPEncodeText(char* input, char* encoding);
+extern char* OpenPGPDecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }

android/src/main/jniLibs/armeabi-v7a/libopenpgp_bridge.so

@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* OpenPGPBridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* OpenPGPEncodeText(char* input, char* encoding);
+extern char* OpenPGPDecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }