@moxtradeveloper/react-native-moxo-module 10.11.2 → 10.13.1

package/android/src/main/java/com/moxomodule/MoxoModulePackage.kt

@@ -1,17 +1,25 @@
 package com.moxomodule
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
+class MoxoModulePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == MoxoModuleModule.NAME) MoxoModuleModule(reactContext) else null
 
-class MoxoModulePackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(MoxoModuleModule(reactContext))
-  }
-
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mapOf(
+      MoxoModuleModule.NAME to ReactModuleInfo(
+        name = MoxoModuleModule.NAME,
+        className = MoxoModuleModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true,
+      )
+    )
   }
 }

package/ios/MoxoModule.h

@@ -0,0 +1,5 @@
+#import <MoxoModuleSpec/MoxoModuleSpec.h>
+
+@interface MoxoModule : NativeMoxoModuleSpecBase <NativeMoxoModuleSpec>
+
+@end

package/ios/MoxoModule.mm

@@ -0,0 +1,123 @@
+#import "MoxoModule.h"
+
+#import <MEPSDK/MEPSDK.h>
+
+#if __has_include(<react_native_moxo_module/react_native_moxo_module-Swift.h>)
+#import <react_native_moxo_module/react_native_moxo_module-Swift.h>
+#else
+#import "react_native_moxo_module-Swift.h"
+#endif
+
+@implementation MoxoModule {
+  MoxoModuleImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(MoxoModule)
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _impl = [MoxoModuleImpl new];
+    __weak MoxoModule *weakSelf = self;
+    _impl.onUnreadMessageCountUpdated = ^(NSNumber *count) {
+      [weakSelf emitOnUnreadMessageCountUpdated:count];
+    };
+    _impl.onTapWindowClose = ^{
+      [weakSelf emitOnTapWindowClose];
+    };
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (void)setup:(NSString *)domain options:(NSDictionary *)options
+{
+  [_impl setupWithDomain:domain options:options];
+}
+
+- (void)link:(NSString *)token resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl linkWithToken:token resolve:resolve reject:reject];
+}
+
+- (void)unlink:(BOOL)keepNotification
+{
+  [_impl unlinkWithKeepNotification:keepNotification];
+}
+
+- (void)showMEPWindow
+{
+  [_impl showMEPWindow];
+}
+
+- (void)hideMEPWindow
+{
+  [_impl hideMEPWindow];
+}
+
+- (void)changeLanguage:(NSString *)language
+{
+  [_impl changeLanguage:language];
+}
+
+- (void)openChat:(NSString *)chatId
+    feedSequence:(NSNumber *)feedSequence
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl openChatWithChatId:chatId feedSequence:feedSequence resolve:resolve reject:reject];
+}
+
+- (void)openRelation:(NSDictionary *)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl openRelationWithUser:options resolve:resolve reject:reject];
+}
+
+- (void)getUnreadMessageCount:(NSDictionary *)options
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl getUnreadMessageCountWithResolve:resolve];
+}
+
+- (void)registerNotification:(NSString *)deviceToken
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl registerNotificationWithDeviceToken:deviceToken resolve:resolve reject:reject];
+}
+
+- (void)parseNotification:(NSDictionary *)payload resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl parseNotificationWithPayload:payload resolve:resolve reject:reject];
+}
+
+- (void)showMeetRinger:(NSString *)sessionId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  reject(@"-1", @"showMeetRinger is only supported on Android", nil);
+}
+
+- (void)startMeet:(NSString *)topic
+          options:(NSDictionary *)options
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl startMeetWithTopic:topic options:options resolve:resolve reject:reject];
+}
+
+// iOS always reports close taps through MEPClientDelegate.
+- (void)enableTapWindowCloseEvent
+{
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeMoxoModuleSpecJSI>(params);
+}
+
+@end

package/ios/MoxoModuleImpl.swift

@@ -0,0 +1,153 @@
+import Foundation
+import MEPSDK
+
+@objc(MoxoModuleImpl)
+public class MoxoModuleImpl: NSObject, MEPClientDelegate {
+    public typealias Resolve = (Any?) -> Void
+    public typealias Reject = (String, String, Error?) -> Void
+
+    let default_error_code = 999
+    let default_error_message = "invalid parameters"
+
+    @objc public var onUnreadMessageCountUpdated: ((NSNumber) -> Void)?
+    @objc public var onTapWindowClose: (() -> Void)?
+
+    @objc public func setup(domain: String, options: [String: Any]?) {
+        MEPClient.sharedInstance().setup(withDomain: domain, linkConfig: nil)
+        MEPClient.sharedInstance().delegate = self
+    }
+
+    @objc public func link(token: String, resolve: @escaping Resolve, reject: @escaping Reject) {
+        MEPClient.sharedInstance().linkUser(withAccessToken: token) { error in
+            Self.complete(error, resolve: resolve, reject: reject) { true }
+        }
+    }
+
+    @objc public func unlink(keepNotification: Bool) {
+        DispatchQueue.main.async {
+            if keepNotification {
+                MEPClient.sharedInstance().localUnlink()
+            } else {
+                MEPClient.sharedInstance().unlink()
+            }
+        }
+    }
+
+    @objc public func showMEPWindow() {
+        DispatchQueue.main.async {
+            MEPClient.sharedInstance().showMEPWindow()
+        }
+    }
+
+    @objc public func hideMEPWindow() {
+        DispatchQueue.main.async {
+            MEPClient.sharedInstance().hideMEPWindow()
+        }
+    }
+
+    @objc public func changeLanguage(_ language: String) {
+        DispatchQueue.main.async {
+            MEPClient.sharedInstance().changeLanguage(language)
+        }
+    }
+
+    @objc public func openChat(chatId: String, feedSequence: NSNumber?, resolve: @escaping Resolve, reject: @escaping Reject) {
+        let sequence = feedSequence == 0 ? nil : feedSequence
+        DispatchQueue.main.async {
+            MEPClient.sharedInstance().openChat(chatId, withFeedSequence: sequence) { error in
+                Self.complete(error, resolve: resolve, reject: reject) { true }
+            }
+        }
+    }
+
+    @objc public func openRelation(user: [String: Any], resolve: @escaping Resolve, reject: @escaping Reject) {
+        DispatchQueue.main.async {
+            if let uniqueId = user["uniqueId"] as? String {
+                MEPClient.sharedInstance().openRelationChat(withUniqueID: uniqueId) { error in
+                    Self.complete(error, resolve: resolve, reject: reject) { true }
+                }
+            } else if let email = user["email"] as? String {
+                MEPClient.sharedInstance().openRelationChat(withEmail: email) { error in
+                    Self.complete(error, resolve: resolve, reject: reject) { true }
+                }
+            } else {
+                let err = NSError(domain: MEPSDKErrorDomain, code: self.default_error_code, userInfo: [NSLocalizedDescriptionKey: "No uniqueId or email found"])
+                reject("\(self.default_error_code)", self.default_error_message, err)
+            }
+        }
+    }
+
+    @objc public func getUnreadMessageCount(resolve: @escaping Resolve) {
+        resolve(MEPClient.sharedInstance().getUnreadMessageCount())
+    }
+
+    @objc public func startMeet(topic: String, options: [String: Any]?, resolve: @escaping Resolve, reject: @escaping Reject) {
+        let options = options ?? [:]
+        DispatchQueue.main.async {
+            let meetOption = MEPStartMeetOptions()
+            meetOption.topic = topic
+            meetOption.chatID = options["chat_id"] as? String
+            meetOption.uniqueIDs = options["unique_ids"] as? [String]
+            meetOption.autoJoinAudio = options["auto_join_audio"] as? Bool ?? true
+            meetOption.autoStartVideo = options["auto_start_video"] as? Bool ?? false
+            meetOption.autoRecording = options["auto_recording"] as? Bool ?? false
+            meetOption.instantCall = options["instant_call"] as? Bool ?? false
+            MEPClient.sharedInstance().startMeet(withOption: meetOption) { error, meetId in
+                Self.complete(error, resolve: resolve, reject: reject) { ["session_id": meetId] }
+            }
+        }
+    }
+
+    // MARK: Notification
+
+    @objc public func registerNotification(deviceToken: String, resolve: @escaping Resolve, reject: @escaping Reject) {
+        guard let data = Data(hex: deviceToken) else {
+            reject("\(default_error_code)", "Invalid device token", nil)
+            return
+        }
+        MEPClient.sharedInstance().registerNotification(withDeviceToken: data) { error in
+            Self.complete(error, resolve: resolve, reject: reject) { true }
+        }
+    }
+
+    @objc public func parseNotification(payload: [String: Any], resolve: @escaping Resolve, reject: @escaping Reject) {
+        MEPClient.sharedInstance().parseRemoteNotification(payload) { error, ret in
+            Self.complete(error, resolve: resolve, reject: reject) { ret }
+        }
+    }
+
+    // MARK: MEPClientDelegate
+
+    public func client(_ client: MEPClient, didUpdateUnreadCount unreadCount: UInt) {
+        onUnreadMessageCountUpdated?(NSNumber(value: unreadCount))
+    }
+
+    public func client(_ client: MEPClient, didTapClose sender: Any?) {
+        onTapWindowClose?()
+    }
+
+    private static func complete(_ error: Error?, resolve: Resolve, reject: Reject, result: () -> Any?) {
+        if let error {
+            let err = error as NSError
+            reject("\(err.code)", err.localizedDescription, err)
+        } else {
+            resolve(result())
+        }
+    }
+}
+
+extension Data {
+    init?(hex: String) {
+        guard !hex.isEmpty, hex.count.isMultiple(of: 2) else {
+            return nil
+        }
+
+        let chars = Array(hex)
+        let bytes = stride(from: 0, to: chars.count, by: 2)
+            .map { String(chars[$0]) + String(chars[$0 + 1]) }
+            .compactMap { UInt8($0, radix: 16) }
+
+        guard bytes.count * 2 == hex.count else { return nil }
+        self.init(bytes)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxtradeveloper/react-native-moxo-module",
-  "version": "10.11.2",
+  "version": "10.13.1",
   "description": "Plugin for adding Moxo services to React Native Apps.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -12,7 +12,6 @@
     "lib",
     "android",
     "ios",
-    "cpp",
     "scripts",
     "*.podspec",
     "!lib/typescript/example",
@@ -32,10 +31,8 @@
     "postinstall": "node scripts/download-mepsdk.js",
     "test": "jest",
     "typescript": "tsc --noEmit",
-    "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "example": "yarn --cwd example",
-    "bootstrap": "yarn example && yarn install && yarn example pods",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build",
+    "lint": "eslint .",
+    "clean": "del-cli android/build lib",
     "doc": "typedoc ./src/index.tsx --skipErrorChecking"
   },
   "keywords": [
@@ -58,38 +55,35 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native-community/eslint-config": "^3.0.2",
-    "@release-it/conventional-changelog": "^5.0.0",
-    "@types/jest": "^28.1.2",
-    "@types/react": "~17.0.21",
-    "@types/react-native": "0.70.0",
-    "del-cli": "^5.0.0",
-    "eslint": "^8.4.1",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^28.1.1",
-    "pod-install": "^0.1.0",
-    "prettier": "^2.0.5",
-    "react": "18.1.0",
-    "react-native": "0.70.6",
-    "react-native-builder-bob": "^0.20.0",
-    "release-it": "^15.0.0",
-    "typedoc": "^0.24.8",
-    "typescript": "^4.5.2"
-  },
-  "resolutions": {
-    "@types/react": "17.0.21"
+    "@react-native/babel-preset": "^0.88.0",
+    "@react-native/eslint-config": "0.88.0",
+    "@react-native/jest-preset": "^0.88.0",
+    "@release-it/conventional-changelog": "^12.0.2",
+    "@types/jest": "^30.0.0",
+    "@types/react": "^19.3.0",
+    "del-cli": "^8.0.1",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.7",
+    "jest": "^30.5.2",
+    "pod-install": "^1.2.1",
+    "prettier": "^3.9.10",
+    "react": "19.3.1",
+    "react-native": "0.88.0",
+    "react-native-builder-bob": "^0.44.1",
+    "release-it": "^21.1.1",
+    "typedoc": "^0.28.20",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
+    "react-native": ">=0.80.0"
   },
   "engines": {
-    "node": ">= 16.0.0"
+    "node": ">= 22.13.0"
   },
-  "packageManager": "^yarn@1.22.15",
   "jest": {
-    "preset": "react-native",
+    "preset": "@react-native/jest-preset",
     "modulePathIgnorePatterns": [
       "<rootDir>/example/node_modules",
       "<rootDir>/lib/"
@@ -117,29 +111,6 @@
       }
     }
   },
-  "eslintConfig": {
-    "root": true,
-    "extends": [
-      "@react-native-community",
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": [
-        "error",
-        {
-          "quoteProps": "consistent",
-          "singleQuote": true,
-          "tabWidth": 2,
-          "trailingComma": "es5",
-          "useTabs": false
-        }
-      ]
-    }
-  },
-  "eslintIgnore": [
-    "node_modules/",
-    "lib/"
-  ],
   "prettier": {
     "quoteProps": "consistent",
     "singleQuote": true,
@@ -163,8 +134,21 @@
   },
   "moxoSdk": {
     "ios": {
-      "version": "10.11.1",
+      "version": "10.13.1",
       "downloadUrl": "https://mxrepo.moxo.com/repository/customer-raw-releases/mepsdk/dynamic/Dynamic_MEPSDK_iOS_v${version}.zip"
     }
+  },
+  "codegenConfig": {
+    "name": "MoxoModuleSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.moxomodule"
+    },
+    "ios": {
+      "modulesProvider": {
+        "MoxoModule": "MoxoModule"
+      }
+    }
   }
 }

package/react-native-moxo-module.podspec

@@ -1,7 +1,6 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
   s.name         = "react-native-moxo-module"
@@ -11,28 +10,14 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "15.0" }
+  s.platforms    = { :ios => "15.6" }
   s.source       = { :git => "https://github.com/Moxtra/react-native-moxo-module.git", :tag => "#{s.version}" }
   s.source_files = "ios/**/*.{h,m,mm,swift}"
-  s.public_header_files = 'ios/*.h'
-  s.swift_version = '5.0'
-  s.dependency "React-Core"
-  
+  s.private_header_files = "ios/**/*.h"
+  s.swift_version = "5.9"
+
   # MEPSDK is embedded directly - downloaded via npm postinstall
-  s.vendored_frameworks = 'ios/Frameworks/MEPSDK.xcframework'
+  s.vendored_frameworks = "ios/Frameworks/MEPSDK.xcframework"
 
-  # Don't install the dependencies when we run `pod install` in the old architecture.
-  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    s.pod_target_xcconfig    = {
-        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-    }
-    s.dependency "React-Codegen"
-    s.dependency "RCT-Folly"
-    s.dependency "RCTRequired"
-    s.dependency "RCTTypeSafety"
-    s.dependency "ReactCommon/turbomodule/core"
-  end
+  install_modules_dependencies(s)
 end

package/scripts/download-mepsdk.js

@@ -24,8 +24,9 @@ const MEPSDK_DOWNLOAD_URL = (sdkConfig.downloadUrl || '').replace(
 );
 
 const FRAMEWORK_DIR = path.join(__dirname, '..', 'ios', 'Frameworks');
-const FRAMEWORK_PATH = path.join(FRAMEWORK_DIR, 'MEPSDKDylib.xcframework');
-const ZIP_PATH = path.join(FRAMEWORK_DIR, 'MEPSDKDylib.xcframework.zip');
+const FRAMEWORK_PATH = path.join(FRAMEWORK_DIR, 'MEPSDK.xcframework');
+const VERSION_PATH = path.join(FRAMEWORK_DIR, '.version');
+const ZIP_PATH = path.join(FRAMEWORK_DIR, 'MEPSDK.xcframework.zip');
 
 function downloadFile(url, dest) {
   return new Promise((resolve, reject) => {
@@ -36,7 +37,7 @@ function downloadFile(url, dest) {
 
     const request = protocol.get(url, (response) => {
       // Handle redirects
-      if (response.statusCode === 301 || response.statusCode === 302) {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
         file.close();
         fs.unlinkSync(dest);
         return downloadFile(response.headers.location, dest)
@@ -80,13 +81,18 @@ async function main() {
     process.exit(1);
   }
 
-  // Skip if framework already exists
-  if (fs.existsSync(FRAMEWORK_PATH)) {
-    console.log('MEPSDKDylib.xcframework already exists, skipping download.');
+  // Skip if the configured framework version already exists
+  const installedVersion = fs.existsSync(VERSION_PATH)
+    ? fs.readFileSync(VERSION_PATH, 'utf8').trim()
+    : null;
+  if (fs.existsSync(FRAMEWORK_PATH) && installedVersion === MEPSDK_VERSION) {
+    console.log(
+      `MEPSDK.xcframework ${MEPSDK_VERSION} already exists, skipping download.`
+    );
     return;
   }
 
-  console.log(`\n📦 Downloading MEPSDKDylib ${MEPSDK_VERSION}...\n`);
+  console.log(`\n📦 Downloading MEPSDK ${MEPSDK_VERSION}...\n`);
 
   // Create Frameworks directory
   if (!fs.existsSync(FRAMEWORK_DIR)) {
@@ -98,6 +104,9 @@ async function main() {
     await downloadFile(MEPSDK_DOWNLOAD_URL, ZIP_PATH);
     console.log('Download complete. Extracting...');
 
+    // Replace any previously installed version
+    fs.rmSync(FRAMEWORK_PATH, { recursive: true, force: true });
+
     // Extract the zip file
     execSync(`unzip -o "${ZIP_PATH}" -d "${FRAMEWORK_DIR}"`, {
       stdio: 'inherit',
@@ -105,10 +114,11 @@ async function main() {
 
     // Clean up zip file
     fs.unlinkSync(ZIP_PATH);
+    fs.writeFileSync(VERSION_PATH, MEPSDK_VERSION);
 
-    console.log('\n✅ MEPSDKDylib.xcframework installed successfully!\n');
+    console.log('\n✅ MEPSDK.xcframework installed successfully!\n');
   } catch (error) {
-    console.error('\n❌ Failed to download MEPSDKDylib:', error.message);
+    console.error('\n❌ Failed to download MEPSDK:', error.message);
     console.error(
       '\nPlease ensure the CDN URL is correct or manually download the framework.'
     );

package/src/NativeMoxoModule.ts

@@ -0,0 +1,30 @@
+import { TurboModuleRegistry } from 'react-native';
+import type { CodegenTypes, TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setup(domain: string, options?: CodegenTypes.UnsafeObject): void;
+  link(token: string): Promise<boolean>;
+  unlink(keepNotification: boolean): void;
+  showMEPWindow(): void;
+  hideMEPWindow(): void;
+  changeLanguage(language: string): void;
+  openChat(chatId: string, feedSequence?: number): Promise<boolean>;
+  openRelation(options: CodegenTypes.UnsafeObject): Promise<boolean>;
+  getUnreadMessageCount(options?: CodegenTypes.UnsafeObject): Promise<number>;
+  registerNotification(deviceToken: string): Promise<boolean>;
+  parseNotification(
+    payload: CodegenTypes.UnsafeObject
+  ): Promise<CodegenTypes.UnsafeObject>;
+  showMeetRinger(sessionId: string): Promise<string>;
+  startMeet(
+    topic: string,
+    options?: CodegenTypes.UnsafeObject
+  ): Promise<CodegenTypes.UnsafeObject>;
+  // Android only takes over the close button once JS subscribes.
+  enableTapWindowCloseEvent(): void;
+
+  readonly onUnreadMessageCountUpdated: CodegenTypes.EventEmitter<number>;
+  readonly onTapWindowClose: CodegenTypes.EventEmitter<void>;
+}
+
+export default TurboModuleRegistry.get<Spec>('MoxoModule');