@synonymdev/react-native-pubky 0.8.0 → 0.9.1

package/android/src/main/java/com/pubky/PubkyModule.kt

@@ -5,306 +5,397 @@ 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 com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import uniffi.pubkymobile.*
+import uniffi.pubkycore.*
 
 class PubkyModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext) {
 
-  override fun getName(): String {
-    return NAME
-  }
+    override fun getName(): String {
+        return NAME
+    }
+
+    private val eventListener = object : EventListener {
+        override fun onEventOccurred(eventData: String) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("PubkyEvent", eventData)
+        }
+    }
+
+    @ReactMethod
+    fun setEventListener(promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                setEventListener(eventListener)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(null)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun auth(url: String, secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = auth(url, secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun removeEventListener(promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                removeEventListener()
+                withContext(Dispatchers.Main) {
+                    promise.resolve(null)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun parseAuthUrl(url: String, promise: Promise) {
-    try {
-      val result = parseAuthUrl(url)
-      val array = Arguments.createArray().apply {
-        result.forEach { pushString(it) }
-      }
-      promise.resolve(array)
-    } catch (e: Exception) {
-      promise.reject("Error", e.message)
+    @ReactMethod
+    fun deleteFile(url: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = deleteFile(url)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
     }
-  }
 
-  @ReactMethod
-  fun publish(recordName: String, recordContent: String, secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = publish(recordName, recordContent, secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun session(pubky: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = session(pubky)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun resolve(publicKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = resolve(publicKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun auth(url: String, secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = auth(url, secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun parseAuthUrl(url: String, promise: Promise) {
+        try {
+            val result = parseAuthUrl(url)
+            val array = Arguments.createArray().apply {
+                result.forEach { pushString(it) }
+            }
+            promise.resolve(array)
+        } catch (e: Exception) {
+            promise.reject("Error", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun publish(recordName: String, recordContent: String, secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = publish(recordName, recordContent, secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun resolve(publicKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = resolve(publicKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun signUp(secretKey: String, homeserver: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = signUp(secretKey, homeserver)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun signUp(secretKey: String, homeserver: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = signUp(secretKey, homeserver)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun signIn(secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = signIn(secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun signIn(secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = signIn(secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun signOut(secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = signOut(secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun signOut(secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = signOut(secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun put(url: String, content: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = put(url, content)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun put(url: String, content: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = put(url, content)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun get(url: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = get(url)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun get(url: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = get(url)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun publishHttps(recordName: String, target: String, secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = publishHttps(recordName, target, secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun publishHttps(recordName: String, target: String, secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = publishHttps(recordName, target, secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun resolveHttps(publicKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = resolveHttps(publicKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun resolveHttps(publicKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = resolveHttps(publicKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun list(url: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = list(url)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun list(url: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = list(url)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun generateSecretKey(promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = generate_secret_key()
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun generateSecretKey(promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = generateSecretKey()
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-  @ReactMethod
-  fun getPublicKeyFromSecretKey(secretKey: String, promise: Promise) {
-      CoroutineScope(Dispatchers.IO).launch {
-          try {
-              val result = getPublicKeyFromSecretKey(secretKey)
-              val array = Arguments.createArray().apply {
-                  result.forEach { pushString(it) }
-              }
-              withContext(Dispatchers.Main) {
-                  promise.resolve(array)
-              }
-          } catch (e: Exception) {
-              withContext(Dispatchers.Main) {
-                  promise.reject("Error", e.message)
-              }
-          }
-      }
-  }
+    @ReactMethod
+    fun getPublicKeyFromSecretKey(secretKey: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = getPublicKeyFromSecretKey(secretKey)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
+        }
+    }
 
-@ReactMethod
-fun createRecoveryFile(secretKey: String, passphrase: String, promise: Promise) {
-    try {
-        val result = createRecoveryFile(secretKey, passphrase)
-        val array = Arguments.createArray().apply {
-            result.forEach { pushString(it) }
+    @ReactMethod
+    fun createRecoveryFile(secretKey: String, passphrase: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = createRecoveryFile(secretKey, passphrase)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
         }
-        promise.resolve(array)
-    } catch (e: Exception) {
-        promise.reject("Error", e.message)
     }
-}
 
-@ReactMethod
-fun decryptRecoveryFile(recoveryFile: String, passphrase: String, promise: Promise) {
-    try {
-        val result = decryptRecoveryFile(recoveryFile, passphrase)
-        val array = Arguments.createArray().apply {
-            result.forEach { pushString(it) }
+    @ReactMethod
+    fun decryptRecoveryFile(recoveryFile: String, passphrase: String, promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                val result = decryptRecoveryFile(recoveryFile, passphrase)
+                val array = Arguments.createArray().apply {
+                    result.forEach { pushString(it) }
+                }
+                withContext(Dispatchers.Main) {
+                    promise.resolve(array)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("Error", e.message)
+                }
+            }
         }
-        promise.resolve(array)
-    } catch (e: Exception) {
-        promise.reject("Error", e.message)
     }
-}
 
-  companion object {
-    const val NAME = "Pubky"
-  }
+    companion object {
+        const val NAME = "Pubky"
+    }
 }