@developer_tribe/react-native-comnyx 0.6.1 → 0.7.0

package/android/src/main/java/com/comnyx/ComnyxModule.kt

@@ -1,23 +1,125 @@
 package com.comnyx
 
+import com.comnyx.messaging.ComnyxMessaging
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
 
 @ReactModule(name = ComnyxModule.NAME)
 class ComnyxModule(reactContext: ReactApplicationContext) :
-  NativeComnyxSpec(reactContext) {
+  ReactContextBaseJavaModule(reactContext) {
+  private val comnyxMessaging : ComnyxMessaging
+
+  init {
+    comnyxMessaging = ComnyxMessaging(reactContext)
+    __self = this
+  }
 
   override fun getName(): String {
     return NAME
   }
 
-  // Example method
-  // See https://reactnative.dev/docs/native-modules-android
-  override fun multiply(a: Double, b: Double): Double {
-    return a * b
+  private fun sendEvent(reactContext: ReactContext, eventName: String, params: Any?) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+  }
+
+  @ReactMethod
+  fun initialize(promise: Promise) {
+      comnyxMessaging.initialize( { token ->
+        val params = Arguments.createMap()
+        params.putString("token", token)
+        sendEvent(reactApplicationContext, "TOKEN_INIT", params)
+        val activity = reactApplicationContext.currentActivity
+        if(activity?.intent !== null){
+          ComnyxModule.handleNewIntent(activity.intent)
+        }
+        promise.resolve(true)
+        },
+        { exception ->
+          promise.reject("TOKEN_FAILED", exception.message, exception)
+        }
+      )
+  }
+
+  @ReactMethod
+ fun checkOptIn(promise: Promise) {
+   this.comnyxMessaging.checkOptIn(
+      { isGranted ->
+        promise.resolve(isGranted)
+      },
+      { exception ->
+        promise.reject("ERROR_CHECK_OPT_IN", exception.message, exception)
+      }
+    )
+  }
+
+  @ReactMethod
+  fun optIn(promise: Promise) {
+    comnyxMessaging.optIn(
+      { isGranted ->
+        promise.resolve(isGranted)
+      },
+      { exception ->
+        promise.reject("ERROR_OPT_IN", exception.message, exception)
+      }
+    )
+  }
+
+  fun onNotificationShown(params: WritableMap) {
+        //TODO: type ios, android should be same
+    sendEvent(reactApplicationContext, "NOTIFICATION_RECEIVED", params)
+  }
+
+  fun onNotificationClicked(params: WritableMap) {
+    sendEvent(reactApplicationContext, "NOTIFICATION_CLICKED", params)
   }
 
   companion object {
     const val NAME = "Comnyx"
+    var __self: ComnyxModule? = null
+
+    fun handleNewIntent(intent: android.content.Intent?) {
+      val type = intent?.getStringExtra("comnyx_type")
+      if(type != "notification_clicked" && type != "notification_shown") {
+        return
+      }
+       intent?.let {
+        val params = Arguments.createMap()
+        it.extras?.let { extras ->
+          for (key in extras.keySet()) {
+            val value = extras.get(key)
+            when (value) {
+              is String -> params.putString(key, value)
+              is Int -> params.putInt(key, value)
+              is Boolean -> params.putBoolean(key, value)
+              is Double -> params.putDouble(key, value)
+            }
+          }
+        }
+         if(type == "notification_clicked"){
+           __self?.onNotificationClicked(params)
+
+         } else {
+           __self?.onNotificationShown(params)
+
+         }
+       }
+    }
   }
 }

package/android/src/main/java/com/comnyx/ComnyxPackage.kt

@@ -1,5 +1,4 @@
 package com.comnyx
-
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
@@ -9,24 +8,29 @@ import java.util.HashMap
 
 class ComnyxPackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == ComnyxModule.NAME) {
-      ComnyxModule(reactContext)
-    } else {
-      null
+    return when (name) {
+      ComnyxModule.NAME -> ComnyxModule(reactContext)
+      else -> null
     }
   }
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
     return ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+
+      // Add ComnyxModule
       moduleInfos[ComnyxModule.NAME] = ReactModuleInfo(
         ComnyxModule.NAME,
         ComnyxModule.NAME,
         false,  // canOverrideExistingModule
         false,  // needsEagerInit
         false,  // isCxxModule
-        true // isTurboModule
+        false // isTurboModule
       )
+
+      // Add NotificationPermissionModule
+
+
       moduleInfos
     }
   }

package/android/src/main/java/com/comnyx/src/messaging/ComnyxMessaging.kt

@@ -0,0 +1,45 @@
+package com.comnyx.messaging
+
+import com.comnyx.src.messaging.permissions.NotificationPermission
+import com.facebook.react.bridge.ReactApplicationContext
+
+class ComnyxMessaging(reactApplicationContext: ReactApplicationContext) {
+    private val fcm : FCM?
+    private val reactApplicationContext : ReactApplicationContext
+
+    init {
+        this.reactApplicationContext = reactApplicationContext
+        this.fcm = FCM(reactApplicationContext)
+    }
+
+    public fun initialize(onSuccess: (token: String) -> Unit, onError: (exception: Exception) -> Unit) {
+        this.fcm!!.getToken(
+          onSuccess = { token ->
+            onSuccess(token)
+          },
+          onError = { exception ->
+            onError(exception)
+          }
+        )
+    }
+
+    public fun checkOptIn(onSuccess: (isGranted: Boolean) -> Unit, onError: (exception: Exception) -> Unit) {
+        try {
+            val notificationPermission = NotificationPermission(reactApplicationContext)
+            val isGranted = notificationPermission.isPermissionGranted()
+            onSuccess(isGranted)
+        } catch (e: Exception) {
+            onError(e)
+        }
+    }
+
+    public fun optIn(onSuccess: (isGranted: Boolean) -> Unit, onError: (exception: Exception) -> Unit) {
+        try {
+            val notificationPermission = NotificationPermission(reactApplicationContext)
+            notificationPermission.requestPermission(onSuccess, onError)
+        } catch (e: Exception) {
+            onError(e)
+        }
+    }
+
+}

package/android/src/main/java/com/comnyx/src/messaging/firebase/FCM.kt

@@ -0,0 +1,38 @@
+package com.comnyx.messaging
+
+import android.content.Context
+import android.util.Log
+import com.google.firebase.FirebaseApp
+import com.google.firebase.messaging.FirebaseMessaging
+
+class FCM(private val context: Context) {
+    companion object {
+        private const val TAG = "Comnyx"
+    }
+
+    init {
+        try {
+            if (FirebaseApp.getApps(context).isEmpty()) {
+                FirebaseApp.initializeApp(context)
+                Log.d(TAG, "Firebase initialized successfully")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize Firebase", e)
+        }
+    }
+
+    fun getToken(onSuccess: (String) -> Unit, onError: (Exception) -> Unit) {
+        FirebaseMessaging.getInstance().token
+            .addOnCompleteListener { task ->
+                if (task.isSuccessful) {
+                    val token = task.result
+                    Log.d(TAG, "FCM token: $token")
+                    onSuccess(token)
+                } else {
+                    val exception = task.exception ?: Exception("Unknown error occurred")
+                    Log.e(TAG, "Failed to get FCM token", exception)
+                    onError(exception)
+                }
+            }
+    }
+}

package/android/src/main/java/com/comnyx/src/messaging/firebase/FirebaseMessagingService.kt

@@ -0,0 +1,45 @@
+package com.comnyx.messaging
+
+import android.util.Log
+import com.comnyx.ComnyxModule
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+
+
+class MyFirebaseMessagingService : FirebaseMessagingService() {
+
+    private lateinit var notificationsHelper: NotificationsHelper
+
+    override fun onCreate() {
+        super.onCreate()
+        notificationsHelper = NotificationsHelper(this)
+    }
+
+    override fun onMessageReceived(remoteMessage: RemoteMessage) {
+      //https://stackoverflow.com/a/40083727
+        super.onMessageReceived(remoteMessage)
+        Log.d("MyFirebaseMessagingService","onMessageReceived($remoteMessage)")
+       val title: String = remoteMessage.data["title"] ?: remoteMessage.notification?.title ?: ""
+       val body: String = remoteMessage.data["body"] ?: remoteMessage.notification?.body ?: ""
+
+        notificationsHelper.showNotification(title, body, remoteMessage.data)
+    }
+
+
+
+
+    override fun onNewToken(token: String) {
+        sendRegistrationToServer(token)
+    }
+
+
+    private fun sendRegistrationToServer(token: String) {
+        //TODO: send token to server
+        Log.d("MyFirebaseMessagingService","sendRegistrationTokenToServer($token)")
+    }
+
+
+    companion object {
+
+    }
+}

package/android/src/main/java/com/comnyx/src/messaging/notifications/NotificationsService.kt

@@ -0,0 +1,82 @@
+package com.comnyx.messaging
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.comnyx.ComnyxModule
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+class NotificationsHelper(private val context: Context) {
+
+    companion object {
+        private const val CHANNEL_ID = "COMNYX_NOTIFICATION_CHANNEL"
+        private const val NOTIFICATION_ID = 1001
+    }
+
+    init {
+        createNotificationChannel()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name = "Standard Notifications"
+            val description = "Regular notifications channel"
+            val importance = NotificationManager.IMPORTANCE_DEFAULT
+            val channel = NotificationChannel(CHANNEL_ID, name, importance)
+            channel.description = description
+
+            val notificationManager = context.getSystemService(NotificationManager::class.java)
+            channel.apply {
+                lightColor = Color.BLUE
+                enableLights(true)
+                setShowBadge(true)
+                enableVibration(true)
+            }
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    fun showNotification(title: String, message: String, data: Map<String, String>? = null) {
+        // Create pending intent for notification click
+        // Use the app's launch intent instead of hardcoding MainActivity
+        val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            ?: Intent().setPackage(context.packageName)
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+        // Add all data as extras
+        data?.forEach { (key, value) ->
+            intent.putExtra(key, value)
+        }
+        intent.putExtra("comnyx_type", "notification_clicked")
+        intent.putExtra("notification_title", title)
+        intent.putExtra("notification_message", message)
+
+        val pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(message)
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setNumber(100)
+            .setAutoCancel(true)
+            .setContentIntent(pendingIntent)
+
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.notify(NOTIFICATION_ID, builder.build())
+
+        val writableMap: WritableMap = Arguments.createMap()
+        writableMap.putString("comnyx_type", "notification_shown")
+        writableMap.putString("notification_title", title)
+        writableMap.putString("notification_message", message)
+        data?.forEach { (key, value) ->
+            writableMap.putString(key, value)
+        }
+        ComnyxModule.__self?.onNotificationShown(writableMap)
+    }
+}

package/android/src/main/java/com/comnyx/src/messaging/permissions/Permissions.kt

@@ -0,0 +1,64 @@
+package com.comnyx.src.messaging.permissions
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+
+class NotificationPermission(private val context: Context) {
+    companion object {
+        private const val PERMISSION_REQUEST_CODE = 100
+        private var pendingPromise: ((isGranted: Boolean) -> Unit?)? = null
+    }
+
+
+    public fun isPermissionGranted(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+        } else {
+            // On Android 12 and below, notification permission is granted by default
+            true
+        }
+    }
+
+    public fun requestPermission(onSuccess: (isGranted: Boolean) -> Unit, onError: (exception: Exception) -> Unit) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            if (!isPermissionGranted()) {
+                val activity = context as? Activity
+                if (activity == null) {
+                    onError(Exception("Could not find valid activity"))
+                    return
+                }
+
+                pendingPromise = onSuccess
+
+                ActivityCompat.requestPermissions(
+                    activity,
+                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+                    PERMISSION_REQUEST_CODE
+                )
+                return
+            }
+        }
+
+        onSuccess(true)
+    }
+
+
+    public fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        if (requestCode == PERMISSION_REQUEST_CODE) {
+            val isGranted = grantResults.isNotEmpty() &&
+                   grantResults[0] == PackageManager.PERMISSION_GRANTED
+
+            pendingPromise?.invoke(isGranted)
+            pendingPromise = null
+        }
+    }
+}

package/ios/APNService.swift

@@ -0,0 +1,74 @@
+//
+//  APN.swift
+//  Pods
+//
+//  Created by Hasbi Sefa Demir on 15.05.2025.
+//
+
+import Foundation
+import UserNotifications
+import UIKit
+import ObjectiveC.runtime
+
+class APNService {
+    public var called = false
+    public var token: String?
+    
+    private var tokenCompletion: ((String, String?) -> Void)?
+    
+    init() {
+        self.token = UserDefaults.standard.string(forKey: "APN_TOKEN")
+    }
+    
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    func setAPNTokenListener(completion: @escaping (String, String?) -> Void) {
+        self.tokenCompletion = completion
+      if(self.token != nil){
+        completion("cache", self.token!)
+        }
+        
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+            guard granted else {
+                return
+            }
+            
+            DispatchQueue.main.async {
+                UIApplication.shared.registerForRemoteNotifications()
+              // Register for token notifications
+              NotificationCenter.default.addObserver(
+                  self,
+                  selector: #selector(self.didRegisterForRemoteNotifications),
+                  name: NSNotification.Name("RCTRemoteNotificationRegistered"),
+                  object: nil
+              )
+              
+              NotificationCenter.default.addObserver(
+                  self,
+                  selector: #selector(self.didFailToRegisterForRemoteNotifications),
+                  name: NSNotification.Name("RCTRemoteNotificationRegistrationFailed"),
+                  object: nil
+              )
+              }
+        }
+    }
+    
+    @objc private func didRegisterForRemoteNotifications(notification: Notification) {
+        guard let deviceToken = notification.userInfo?["deviceToken"] as? String else {
+            return
+        }
+        if(self.token != deviceToken){
+            UserDefaults.standard.set(deviceToken, forKey: "APN_TOKEN")
+            self.token = deviceToken
+            tokenCompletion?("received", deviceToken)
+        }
+    }
+    
+    @objc private func didFailToRegisterForRemoteNotifications(notification: Notification) {
+        tokenCompletion?("failed", nil)
+    }
+    
+}
+

package/ios/Comnyx-Bridging-Header.h

@@ -0,0 +1,17 @@
+//
+//  header.swift
+//  Pods
+//
+//  Created by Hasbi Sefa Demir on 17.05.2025.
+//
+
+
+#import <React/RCTViewManager.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React/RCTRootView.h>
+#import <React/RCTComponent.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTDevLoadingView.h>
+#import "React/RCTEventEmitter.h"
+#import <React/RCTUIManager.h>

package/ios/Comnyx.m

@@ -0,0 +1,15 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(Comnyx, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(checkOptIn:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(optIn:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(initialize:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end 

package/ios/Comnyx.swift

@@ -0,0 +1,77 @@
+//
+//  Comnyx.swift
+//  Pods
+//
+//  Created by Hasbi Sefa Demir on 17.05.2025.
+//
+
+import Foundation
+import UserNotifications
+
+@objc(Comnyx)
+class Comnyx: RCTEventEmitter {
+    private var hasListeners: Bool = false
+    var comnyxMessaging: ComnyxMessaging?
+  
+    override init() {
+        super.init()
+        self.comnyxMessaging = ComnyxMessaging(onNotificationReceived: { notification in
+            self.sendEvent(withName: "NOTIFICATION_RECEIVED", body: ["notification": notification])
+        }, onNotificationClicked: { response in
+            self.sendEvent(withName: "NOTIFICATION_CLICKED", body: ["response": response])
+        })
+    }
+    
+    deinit {
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    override func supportedEvents() -> [String] {
+        return ["TOKEN_INIT", "TOKEN_FAILED", "NOTIFICATION_RECEIVED", "NOTIFICATION_CLICKED"]
+    }
+    
+    override func startObserving() {
+      hasListeners = true
+     
+    }
+    
+    override func stopObserving() {
+        hasListeners = false
+    }
+    
+
+    
+
+    // MARK: - JavaScript Methods
+    
+    @objc
+    func checkOptIn(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+      self.comnyxMessaging!.checkOptIn { isAuthorized in
+            resolve(isAuthorized)
+        }
+    }
+    
+    @objc
+    func optIn(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+      self.comnyxMessaging!.optIn { granted, initializedAfterOptIn in
+            resolve(granted)
+        }
+    }
+    
+    @objc
+    func initialize(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+      self.comnyxMessaging!.initialize(onInitialized: { initialized in
+            resolve(initialized)
+        }, onApnTokenReceived: { type, token in
+            if(type == "failed"){
+              self.sendEvent(withName: "TOKEN_FAILED", body: ["type": type, "token": nil])
+            }else{
+              self.sendEvent(withName: "TOKEN_INIT", body: ["type": type, "token": token])
+            }
+        })
+    }
+}
+