initial commit with base structure

Author: jerson

Makefile

@@ -0,0 +1,12 @@
+default: test
+
+test:
+	yarn test
+
+upgrade: upgrade-libs upgrade-flatbuffers
+
+upgrade-libs:
+	./scripts/upgrade_bridge_libs.sh
+
+upgrade-flatbuffers:
+	./scripts/upgrade_bridge_flatbuffers.sh

android/CMakeLists.txt

@@ -1,15 +1,36 @@
-cmake_minimum_required(VERSION 3.4.1)
+cmake_minimum_required(VERSION 3.10.0)
 
-set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 11)
+include_directories(
+        ../cpp
+        ../node_modules/react-native/ReactCommon/jsi
+)
 
-add_library(cpp
-            SHARED
-            ../cpp/example.cpp
-            cpp-adapter.cpp
+add_definitions(
+        -DFOLLY_USE_LIBCPP=1
+        -DFOLLY_NO_CONFIG=1
+        -DFOLLY_HAVE_MEMRCHR=1
 )
 
-# Specifies a path to native header files.
-include_directories(
-            ../cpp
+add_library(openpgp_bridge SHARED IMPORTED )
+
+set_target_properties(openpgp_bridge
+        PROPERTIES
+        IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libopenpgp_bridge.so
+        )
+
+add_library(fast-openpgp
+        SHARED
+        ../node_modules/react-native/ReactCommon/jsi/jsi/jsi.cpp
+        ../cpp/react-native-fast-openpgp.cpp
+        ../cpp/react-native-fast-openpgp.h
+        fast-openpgp-adapter.cpp
 )
+
+find_library(
+        log-lib
+        log )
+
+target_link_libraries(fast-openpgp
+        openpgp_bridge
+        android
+        ${log-lib})

android/build.gradle

@@ -36,15 +36,16 @@ android {
 
     externalNativeBuild {
         cmake {
-            cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+            cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all"
             abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
         }
     }
-    
+
   }
-  
+
   externalNativeBuild {
       cmake {
+          version '3.10.0+'
           path "CMakeLists.txt"
       }
   }

android/cpp-adapter.cpp

@@ -0,0 +1,81 @@
+#include <jni.h>
+#include "react-native-fast-openpgp.h"
+#include <android/log.h>
+#include <libopenpgp_bridge.h>
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_reactnativefastopenpgp_FastOpenpgpModule_initialize(JNIEnv *env, jobject thiz,
+                                                             jlong jsi_ptr) {
+    __android_log_print(ANDROID_LOG_VERBOSE, "react-native-fast-openpgp",
+                        "Initializing");
+    fastOpenPGP::install(*reinterpret_cast<facebook::jsi::Runtime *>(jsi_ptr));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_reactnativefastopenpgp_FastOpenpgpModule_destruct(JNIEnv *env, jobject thiz) {
+    fastOpenPGP::cleanup();
+}
+extern "C"
+JNIEXPORT jbyteArray JNICALL
+Java_com_reactnativefastopenpgp_FastOpenpgpModule_call(JNIEnv *env, jobject thiz,
+                                                       jstring name, jbyteArray payload) {
+
+    jboolean iscopy;
+    auto nameConstChar = env->GetStringUTFChars(name, &iscopy);
+    auto payloadBytes = env->GetByteArrayElements(payload, &iscopy);
+    auto size = env->GetArrayLength(payload);
+
+    auto nameChar = const_cast<char *>(nameConstChar);
+    auto response = OpenPGPBridgeCall(nameChar, payloadBytes, size);
+    //env->ReleaseStringUTFChars(name, nameConstChar);
+
+    if (response->error != nullptr) {
+        auto error = response->error;
+       // free(response);
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, error);
+        return nullptr;
+    }
+
+    auto result = env->NewByteArray(response->size);
+    memcpy(result, response->message, response->size);
+ //   free(response);
+    return result;
+}
+
+
+extern "C"
+JNIEXPORT jbyteArray JNICALL
+Java_com_reactnativefastopenpgp_FastOpenpgpModule_callJSI(JNIEnv *env, jobject thiz, jlong jsi_ptr,
+                                                          jstring name, jbyteArray payload) {
+    auto runtime = reinterpret_cast<jsi::Runtime *>(jsi_ptr);
+    jboolean iscopy;
+    auto nameConstChar = env->GetStringUTFChars(name, &iscopy);
+    auto nameValue = jsi::String::createFromAscii(*runtime, nameConstChar);
+    env->ReleaseStringUTFChars(name, nameConstChar);
+
+    auto payloadArray = env->GetByteArrayElements(payload, &iscopy);
+    int size = env->GetArrayLength(payload);
+
+    auto arrayBuffer = runtime->global().getPropertyAsFunction(*runtime, "ArrayBuffer");
+    jsi::Object o = arrayBuffer.callAsConstructor(*runtime, size).getObject(*runtime);
+    jsi::ArrayBuffer payloadValue = o.getArrayBuffer(*runtime);
+    memcpy(payloadValue.data(*runtime), payloadArray, size);
+
+    auto response = fastOpenPGP::call(*runtime, nameValue, payloadValue);
+
+    if (response.isString()) {
+        auto error = response.asString(*runtime);
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, error.utf8(*runtime).c_str());
+        return nullptr;
+
+    }
+    auto byteResult = response.asObject(*runtime).getArrayBuffer(*runtime);
+    auto sizeResult = byteResult.size(*runtime);
+    auto result = env->NewByteArray(sizeResult);
+    memcpy(result, byteResult.data(*runtime), sizeResult);
+    return result;
+}

android/fast-openpgp-adapter.cpp

@@ -1,36 +1,68 @@
 package com.reactnativefastopenpgp
 
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
+import androidx.annotation.NonNull
+import com.facebook.react.bridge.*
 
-class FastOpenpgpModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
-    override fun getName(): String {
-        return "FastOpenpgp"
+internal class FastOpenpgpModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    external fun initialize(jsiPtr: Long);
+    external fun destruct();
+    external fun callJSI(jsiPtr: Long, name: String, payload: ByteArray): ByteArray;
+    external fun call(name: String, payload: ByteArray): ByteArray;
+
+    companion object {
+        init {
+            System.loadLibrary("fast-openpgp")
+        }
+    }
+
+    @ReactMethod
+    fun callJSI(name: String, payload: ReadableArray, promise: Promise) {
+        Thread {
+            try {
+                val bytes = ByteArray(payload.size()) { pos -> payload.getInt(pos).toByte() }
+                val result = callJSI(this.reactApplicationContext.javaScriptContextHolder.get(), name, bytes)
+                val resultList = Arguments.createArray()
+                for (i in result.indices) {
+                    resultList.pushInt(result.get(i).toInt())
+                }
+                promise.resolve(resultList)
+            } catch (e: Exception) {
+                promise.reject(e)
+            }
+        }.start()
     }
 
-    // Example method
-    // See https://reactnative.dev/docs/native-modules-android
     @ReactMethod
-    fun multiply(a: Int, b: Int, promise: Promise) {
-    
-      promise.resolve(nativeMultiply(a, b));
-    
+    fun call(name: String, payload: ReadableArray, promise: Promise) {
+        Thread {
+            try {
+                val bytes = ByteArray(payload.size()) { pos -> payload.getInt(pos).toByte() }
+                val result = call(name, bytes)
+
+                val resultList = Arguments.createArray()
+                for (i in result.indices) {
+                    resultList.pushInt(result.get(i).toInt())
+                }
+                promise.resolve(resultList)
+            } catch (e: Exception) {
+                promise.reject(e)
+            }
+        }.start()
     }
 
-    
-    external fun nativeMultiply(a: Int, b: Int): Int;
+    @NonNull
+    override fun getName(): String {
+        return "FastOpenPGP"
+    }
 
-    companion object
-    {
+    override fun initialize() {
+        super.initialize()
+        initialize(this.reactApplicationContext.javaScriptContextHolder.get())
+    }
 
-        // Used to load the 'native-lib' library on application startup.
-        init
-        {
-            System.loadLibrary("cpp")
-        }
+    override fun onCatalystInstanceDestroy() {
+        destruct();
     }
-    
 }

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

@@ -0,0 +1,81 @@
+/* Code generated by cmd/cgo; DO NOT EDIT. */
+
+/* package command-line-arguments */
+
+
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h> /* for ptrdiff_t below */
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 3 "main.go"
+#include <stdint.h>
+#include <stdlib.h>
+typedef struct  { void* message; int size; char* error; } BytesReturn;
+
+#line 1 "cgo-generated-wrapper"
+
+
+/* End of preamble from import "C" comments.  */
+
+
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoInt64 GoInt;
+typedef GoUint64 GoUint;
+typedef __SIZE_TYPE__ GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern BytesReturn* OpenPGPBridgeCall(char* name, void* payload, int payloadSize);
+
+#ifdef __cplusplus
+}
+#endif