@op-engineering/op-sqlite 0.0.0-resolution-test

package/android/src/main/java/com/op/sqlite/OPSQLiteModule.kt

@@ -0,0 +1,119 @@
+package com.op.sqlite
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import java.io.OutputStream
+import com.facebook.react.util.RNLog;
+
+//@ReactModule(name = OPSQLiteModule.NAME)
+internal class OPSQLiteModule(context: ReactApplicationContext?) : ReactContextBaseJavaModule(context) {
+    override fun getName(): String {
+        return NAME
+    }
+
+    fun getTypedExportedConstants(): MutableMap<String, Any> {
+        val constants: MutableMap<String, Any> = HashMap()
+        val context = reactApplicationContext
+        val dbPath =
+                context.getDatabasePath("defaultDatabase")
+                        .absolutePath
+                        .replace("defaultDatabase", "")
+        constants["ANDROID_DATABASE_PATH"] = dbPath
+        val filesPath = context.filesDir.absolutePath
+        constants["ANDROID_FILES_PATH"] = filesPath
+        val externalFilesDir = context.getExternalFilesDir(null)!!.absolutePath
+        constants["ANDROID_EXTERNAL_FILES_PATH"] = externalFilesDir
+        constants["IOS_DOCUMENT_PATH"] = ""
+        constants["IOS_LIBRARY_PATH"] = ""
+        return constants
+    }
+
+    override fun getConstants(): MutableMap<String, Any>? {
+        return getTypedExportedConstants()
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun install(): Boolean {
+        return try {
+            OPSQLiteBridge.instance.install(reactApplicationContext)
+            true
+        } catch (exception: Exception) {
+            Log.e(NAME, "Install exception: $exception")
+            false
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun getDylibPath(bundleId: String, name: String) {
+        throw Exception("Do not call getDylibPath on Android")
+    }
+
+    @ReactMethod
+    fun moveAssetsDatabase(args: ReadableMap, promise: Promise) {
+        val filename = args.getString("filename")!!
+        val path = args.getString("path") ?: "custom"
+        val overwrite = if(args.hasKey("overwrite")) { args.getBoolean("overwrite") } else false
+        val context = reactApplicationContext
+        val assetsManager = context.assets
+
+        try {
+
+            val databasesFolder =
+                    context.getDatabasePath("defaultDatabase")
+                            .absolutePath
+                            .replace("defaultDatabase", "")
+
+            val outputFile = File(databasesFolder, filename)
+
+            if (outputFile.exists()) {
+                if(overwrite) {
+                    outputFile.delete()
+                } else {
+                    promise.resolve(true)
+                    return
+                }
+            }
+
+            val inputStream: InputStream = assetsManager.open("$path/$filename")
+
+            // Open the output stream for the output file
+            val outputStream: OutputStream = FileOutputStream(outputFile)
+
+            // Copy the contents from the input stream to the output stream
+            val buffer = ByteArray(1024)
+            var length: Int
+            while (inputStream.read(buffer).also { length = it } > 0) {
+                outputStream.write(buffer, 0, length)
+            }
+
+            // Close the streams
+            inputStream.close()
+            outputStream.close()
+
+            promise.resolve(true)
+        } catch (exception: Exception) {
+            RNLog.e(this.reactApplicationContext, "Exception: $exception")
+            promise.resolve(false)
+        }
+    }
+
+    override fun invalidate() {
+        super.invalidate()
+        OPSQLiteBridge.instance.invalidate()
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("op-sqlite")
+        }
+
+        const val NAME = "OPSQLite"
+    }
+}

package/android/src/main/java/com/op/sqlite/OPSQLitePackage.kt

@@ -0,0 +1,18 @@
+package com.op.sqlite
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class OPSQLitePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf<NativeModule>(OPSQLiteModule(reactContext))
+    }
+
+    override fun createViewManagers(
+            reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/paper/java/com/op/sqlite/NativeOPSQLiteSpec.java

@@ -0,0 +1,77 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.op.sqlite;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public abstract class NativeOPSQLiteSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "OPSQLite";
+
+  public NativeOPSQLiteSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  protected abstract Map<String, Object> getTypedExportedConstants();
+
+  @Override
+  @DoNotStrip
+  public final @Nullable Map<String, Object> getConstants() {
+    Map<String, Object> constants = getTypedExportedConstants();
+    if (ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD) {
+      Set<String> obligatoryFlowConstants = new HashSet<>(Arrays.asList(
+          "ANDROID_DATABASE_PATH",
+          "ANDROID_EXTERNAL_FILES_PATH",
+          "ANDROID_FILES_PATH",
+          "IOS_DOCUMENT_PATH",
+          "IOS_LIBRARY_PATH"
+      ));
+      Set<String> optionalFlowConstants = new HashSet<>();
+      Set<String> undeclaredConstants = new HashSet<>(constants.keySet());
+      undeclaredConstants.removeAll(obligatoryFlowConstants);
+      undeclaredConstants.removeAll(optionalFlowConstants);
+      if (!undeclaredConstants.isEmpty()) {
+        throw new IllegalStateException(String.format("Native Module Flow doesn't declare constants: %s", undeclaredConstants));
+      }
+      undeclaredConstants = obligatoryFlowConstants;
+      undeclaredConstants.removeAll(constants.keySet());
+      if (!undeclaredConstants.isEmpty()) {
+        throw new IllegalStateException(String.format("Native Module doesn't fill in constants: %s", undeclaredConstants));
+      }
+    }
+    return constants;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean install();
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean moveAssetsDatabase(String name, String extension);
+}