@developer_tribe/react-native-comnyx 0.6.2 → 0.7.1

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

@@ -1,23 +1,231 @@
 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
+import com.facebook.react.modules.core.PermissionListener
+import android.util.Log
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import androidx.core.app.ActivityCompat
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
 
 @ReactModule(name = ComnyxModule.NAME)
 class ComnyxModule(reactContext: ReactApplicationContext) :
-  NativeComnyxSpec(reactContext) {
+  ReactContextBaseJavaModule(reactContext), PermissionListener {
+  private val comnyxMessaging : ComnyxMessaging
+  private var pendingPromise: Promise? = null
+  private val PERMISSION_REQUEST_CODE = 100
+
+  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) {
+    Log.d(NAME, "Checking opt-in status")
+    try {
+      // Check system notification settings
+      val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      val areNotificationsEnabled = notificationManager.areNotificationsEnabled()
+
+      // Check runtime permission for Android 13+
+      val permissionStatus = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        when (ContextCompat.checkSelfPermission(
+          reactApplicationContext,
+          Manifest.permission.POST_NOTIFICATIONS
+        )) {
+          PackageManager.PERMISSION_GRANTED -> "granted"
+          PackageManager.PERMISSION_DENIED -> {
+            // Check if user has selected "Don't ask again"
+            val activity = currentActivity
+            if (activity != null &&
+                !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.POST_NOTIFICATIONS)) {
+              "blocked"
+            } else {
+              "denied"
+            }
+          }
+          else -> "denied"
+        }
+      } else {
+        // On Android 12 and below, check only system settings
+        if (areNotificationsEnabled) "granted" else "blocked"
+      }
+
+      Log.d(NAME, "Notification status: $permissionStatus")
+      promise.resolve(permissionStatus)
+    } catch (e: Exception) {
+      Log.e(NAME, "Error checking opt-in status: ${e.message}", e)
+      promise.reject("ERROR_CHECK_OPT_IN", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun optIn(promise: Promise) {
+    Log.d(NAME, "Requesting opt-in permission")
+    try {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        val activity = currentActivity
+        if (activity == null) {
+          throw Exception("Activity is not available")
+        }
+
+        if (ContextCompat.checkSelfPermission(
+            reactApplicationContext,
+            Manifest.permission.POST_NOTIFICATIONS
+          ) == PackageManager.PERMISSION_GRANTED
+        ) {
+          Log.d(NAME, "Permission already granted")
+          promise.resolve("granted")
+          return
+        }
+
+        pendingPromise = promise
+        ActivityCompat.requestPermissions(
+          activity,
+          arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+          PERMISSION_REQUEST_CODE
+        )
+      } else {
+        // On Android 12 and below, check system settings
+        val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val areNotificationsEnabled = notificationManager.areNotificationsEnabled()
+        promise.resolve(if (areNotificationsEnabled) "granted" else "blocked")
+      }
+    } catch (e: Exception) {
+      Log.e(NAME, "Error requesting opt-in permission: ${e.message}", e)
+      promise.reject("ERROR_OPT_IN", e.message, e)
+    }
+  }
+
+  override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray): Boolean {
+    Log.d(NAME, "Permission result received - Request code: $requestCode")
+    if (requestCode == PERMISSION_REQUEST_CODE) {
+      val status = when {
+        grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED -> "granted"
+        currentActivity?.let {
+          !ActivityCompat.shouldShowRequestPermissionRationale(it, Manifest.permission.POST_NOTIFICATIONS)
+        } == true -> "blocked"
+        else -> "denied"
+      }
+      Log.d(NAME, "Permission status: $status")
+
+      pendingPromise?.resolve(status)
+      pendingPromise = null
+      return true
+    }
+    return false
+  }
+
+  fun onNotificationShown(params: WritableMap) {
+    sendEvent(reactApplicationContext, "NOTIFICATION_RECEIVED", params)
+  }
+
+  fun onNotificationClicked(params: WritableMap) {
+    sendEvent(reactApplicationContext, "NOTIFICATION_CLICKED", params)
+  }
+
+  @ReactMethod
+  fun linkToSettings(promise: Promise) {
+    try {
+      val intent = Intent()
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, reactApplicationContext.packageName)
+      } else {
+        intent.action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+        intent.data = Uri.parse("package:" + reactApplicationContext.packageName)
+      }
+      intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+      reactApplicationContext.startActivity(intent)
+      promise.resolve(true)
+    } catch (e: Exception) {
+      Log.e(NAME, "Failed to open settings: ${e.message}", e)
+      promise.reject("SETTINGS_ERROR", "Could not open notification settings", e)
+    }
+
+
   }
 
   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,25 @@
+package com.comnyx.messaging
+
+import com.facebook.react.bridge.ReactApplicationContext
+import android.util.Log
+
+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)
+          }
+        )
+    }
+}

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,99 @@
+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 android.util.Log
+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
+        private const val TAG = "ComnyxNotifications"
+    }
+
+    init {
+        Log.d(TAG, "Initializing NotificationsHelper")
+        createNotificationChannel()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Log.d(TAG, "Creating notification channel for Android O and above")
+            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)
+            Log.d(TAG, "Notification channel created successfully")
+        } else {
+            Log.d(TAG, "Skipping notification channel creation - running on Android N or below")
+        }
+    }
+
+    fun showNotification(title: String, message: String, data: Map<String, String>? = null) {
+        Log.d(TAG, "Showing notification - Title: $title, Message: $message")
+        
+        // Create pending intent for notification click
+        val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            ?: Intent().setPackage(context.packageName)
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+
+        // Add all data as extras
+        data?.let {
+            Log.d(TAG, "Adding extra data to notification: $it")
+        }
+        data?.forEach { (key, value) ->
+            intent.putExtra(key, value)
+        }
+        intent.putExtra("comnyx_type", "notification_clicked")
+        intent.putExtra("notification_title", title)
+        intent.putExtra("notification_message", message)
+
+        try {
+            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())
+            Log.d(TAG, "Notification displayed successfully")
+
+            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)
+            Log.d(TAG, "Notification event sent to JS")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error showing notification: ${e.message}", e)
+        }
+    }
+}

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,18 @@
+#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)
+
+RCT_EXTERN_METHOD(linkToSettings:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end