Integrate the Genuin SDK with React Native apps

npm install genuin-react-native   # or: yarn add genuin-react-native
cd ios && pod install

android {
    defaultConfig {
        minSdk = 24
    }
}

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url "https://jitpack.io" }
        maven { url "https://artifact.bytedance.com/repository/pangle" }
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <uses-permission android:name="android.permission.INTERNET" />
    <application
        android:name=".MainApplication"
        android:allowBackup="false"
        android:theme="@style/AppTheme"
        tools:remove="android:taskAffinity">
        <activity
            android:name=".MainActivity"
            android:launchMode="singleTask"
            android:windowSoftInputMode="adjustPan"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

<resources>
    <style name="AppTheme" parent="Theme.MaterialComponents.Light.NoActionBar.Bridge">
        <item name="android:windowBackground">@drawable/launch_background</item>
    </style>
</resources>

-keep class com.bumptech.glide.** { *; }
-keep class com.begenuin.core.data.model.** { <fields>; }
-keepattributes Signature, InnerClasses, EnclosingMethod, *Annotation*
-keepattributes RuntimeVisibleAnnotations, RuntimeVisibleParameterAnnotations
-keepclassmembers,allowshrinking,allowobfuscation interface * { @retrofit2.http.* <methods>; }
-if interface * { @retrofit2.http.* <methods>; }
-keep,allowobfuscation interface <1>
-keep public class * implements java.lang.reflect.Type
-dontwarn javax.annotation.**
-dontwarn retrofit2.KotlinExtensions
-dontwarn com.google.android.play.core.**

import android.content.Intent
import android.os.Bundle
import com.facebook.react.ReactActivity
import com.genuinsdk.GenuinSDKPluginModule

class MainActivity : ReactActivity() {
  override fun getMainComponentName(): String = "YourApp"

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    GenuinSDKPluginModule.initSDK(application, "<<YOUR_API_KEY>>")   // isQAEnv = true for a QA key
    if (intent?.data != null) GenuinSDKPluginModule.handleDeepLink(this, intent)
  }

  override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    if (intent.data != null) GenuinSDKPluginModule.handleDeepLink(this, intent)
  }
}

<activity android:name=".MainActivity" ...>
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:host="{{YOUR_DOMAIN}}" android:scheme="https" />
    </intent-filter>
</activity>

buildscript {
    dependencies {
        classpath("com.google.gms:google-services:4.4.2")
    }
}

ENV['USE_FRAMEWORKS'] = 'dynamic'
platform :ios, min_ios_version_supported
use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym

target 'YourApp' do
  config = use_native_modules!
  use_react_native!(:path => config[:reactNativePath], :app_path => "#{Pod::Config.instance.installation_root}/..")

  pre_install do |installer|
    installer.pod_targets.each do |pod|
      if pod.name.eql?('RNReanimated')
        def pod.build_type; Pod::BuildType.static_library; end
      end
    end
  end

  post_install do |installer|
    react_native_post_install(installer, config[:reactNativePath], :mac_catalyst_enabled => false)
    installer.pods_project.targets.each do |target|
      target.build_configurations.each do |config|
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '15.1'
        config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
      end
    end
  end
end

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
NS_ASSUME_NONNULL_BEGIN
@interface GenuinModuleObjCWrapper : NSObject
+ (void)initSDK:(NSString *_Nullable)apiKey isQAEnv:(BOOL)isQAEnv loaderName:(NSString *_Nullable)loaderName showNavigationBar:(BOOL *_Nullable)showNavigationBar;
+ (BOOL)willHandleDeepLinkWithUrl:(NSURL *_Nonnull)url;
+ (BOOL)handleDeepLink:(NSURL *_Nullable)dlURL controller:(UIViewController *_Nullable)controller;
+ (void)handleForegroundNotification:(NSDictionary *)notificationData;
+ (UINavigationController *_Nullable)getGenuinNavigationController:(UIViewController *)viewController;
@end
NS_ASSUME_NONNULL_END

#import "GenuinModuleObjCWrapper.h"
#import "GenuinSDKPlugin.h"
@implementation GenuinModuleObjCWrapper
+ (void)initSDK:(NSString *)apiKey isQAEnv:(BOOL)isQAEnv loaderName:(NSString *)loaderName showNavigationBar:(BOOL *)showNavigationBar {
  [GenuinSDKPlugin initSDK:apiKey isQAEnv:isQAEnv loaderName:loaderName showNavigationBar:showNavigationBar];
}
+ (BOOL)willHandleDeepLinkWithUrl:(NSURL *)url { return [GenuinSDKPlugin willHandleDeepLinkWithUrl:url]; }
+ (BOOL)handleDeepLink:(NSURL *)dlURL controller:(UIViewController *)controller {
  return [GenuinSDKPlugin handleDeepLink:dlURL controller:controller];
}
+ (void)handleForegroundNotification:(NSDictionary *)notificationData {
  [GenuinSDKPlugin handleForegroundNotification:notificationData];
}
+ (UINavigationController *)getGenuinNavigationController:(UIViewController *)viewController {
  return [GenuinSDKPlugin getGenuinNavigationController:viewController];
}
@end

#import "GenuinModuleObjCWrapper.h"

import UIKit
import React
import React_RCTAppDelegate
import Firebase

@main
class AppDelegate: RCTAppDelegate, UNUserNotificationCenterDelegate {
  override func application(_ application: UIApplication,
                            didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
    self.moduleName = "YourApp"
    if FirebaseApp.app() == nil { FirebaseApp.configure() }
    UNUserNotificationCenter.current().delegate = self
    UIApplication.shared.registerForRemoteNotifications()
    GenuinModuleObjCWrapper.initSDK("<<YOUR_API_KEY>>", isQAEnv: false,
                                    loaderName: "{{LOTTIE_LOADER_NAME}}", showNavigationBar: nil)
    addNavVC()
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }

  func addNavVC() {
    DispatchQueue.main.async {
      guard let rootVC = self.window.rootViewController else { return }
      self.window.rootViewController = nil
      let navVC = GenuinModuleObjCWrapper.getGenuinNavigationController(rootVC)
      navVC?.setNavigationBarHidden(true, animated: true)
      self.window.rootViewController = navVC
      self.window.makeKeyAndVisible()
    }
  }
}

override func application(_ application: UIApplication, continue userActivity: NSUserActivity,
                          restorationHandler: @escaping ([any UIUserActivityRestoring]?) -> Void) -> Bool {
  if let url = userActivity.webpageURL,
     GenuinModuleObjCWrapper.willHandleDeepLink(with: url),
     GenuinModuleObjCWrapper.handleDeepLink(url, controller: window.rootViewController) {
    return true
  }
  return false
}

import FirebaseMessaging
import GenuinCore

override func application(_ application: UIApplication,
                          didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  Messaging.messaging().apnsToken = deviceToken
}

extension AppDelegate: MessagingDelegate {
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    if let fcmToken { GenuinSDK.shared.registerFCMToken(token: fcmToken) }
  }

  func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification,
                              withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    completionHandler([.list, .banner, .badge, .sound])
  }

  func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse,
                              withCompletionHandler completionHandler: @escaping () -> Void) {
    GenuinModuleObjCWrapper.handleForegroundNotification(["data": response.notification.request.content.userInfo])
    completionHandler()
  }
}

import React, { useRef } from 'react';
import { Carousel, type PlayPauseRef } from 'genuin-react-native';

export default function CarouselScreen() {
  const carouselRef = useRef<PlayPauseRef>(null);
  return (
    <Carousel
      ref={carouselRef}
      style={{ height: 400, width: '100%' }}
      embedId="{{EMBED_ID}}"
      uniqueId="home-carousel"
      ssoToken="{{SSO_TOKEN}}"
      isShowProfileEnabled={false}
      isDirectDeepLinkEnabled={false}
    />
  );
}

import React from 'react';
import { useFocusEffect } from '@react-navigation/native';

useFocusEffect(
  React.useCallback(() => {
    carouselRef.current?.resume();
    return () => carouselRef.current?.pause();
  }, [])
);

import { ssoLogin, ssoLogout } from 'genuin-react-native';

// After your app authenticates the user
ssoLogin('{{SSO_TOKEN}}', { name: 'John Doe', email: 'john.doe@example.com' });

// When the user signs out of your app
ssoLogout();

import { DeviceEventEmitter, NativeEventEmitter, Platform } from 'react-native';
import { GenuinSDKPlugin, registerCallback, registerLinkOutCallback, ssoLogin } from 'genuin-react-native';

registerCallback();                              // 'NavigateToScreen' with 'Login' when sign-in is needed
registerLinkOutCallback(['shop.example.com']);   // 'LinkOutRedirection' with the URL for these domains

const emitter = Platform.OS === 'ios' ? new NativeEventEmitter(GenuinSDKPlugin) : DeviceEventEmitter;
emitter.addListener('NavigateToScreen', (screen: string) => {
  if (screen === 'Login') {
    // Run your sign-in flow, then: ssoLogin('{{SSO_TOKEN}}')
  }
});
emitter.addListener('LinkOutRedirection', (url: string) => {
  // Route the product URL inside your app
});

import { useEffect } from 'react';
import { PermissionsAndroid, Platform } from 'react-native';
import messaging, { type FirebaseMessagingTypes } from '@react-native-firebase/messaging';
import { GenuinSDKPlugin } from 'genuin-react-native';

const open = (m: FirebaseMessagingTypes.RemoteMessage | null) => {
  if (m && GenuinSDKPlugin.willHandleBackgroundNotifications(m)) GenuinSDKPlugin.handleBackgroundNotifications(m);
};

export default function NotificationController() {
  useEffect(() => {
    if (Platform.OS !== 'android') return; // iOS: AppDelegate, Step 5
    PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
    messaging().getToken().then((token) => GenuinSDKPlugin.registerFCMToken(token));
    const offRefresh = messaging().onTokenRefresh((token) => GenuinSDKPlugin.registerFCMToken(token));
    const offMessage = messaging().onMessage(async (m) => {
      const payload = { data: m.data, body: m.notification?.body ?? '', title: m.notification?.title, icon: 'drawable/ic_notification' };
      if (GenuinSDKPlugin.willHandleForegroundNotifications(payload)) GenuinSDKPlugin.handleForegroundNotifications(payload);
    });
    const offOpened = messaging().onNotificationOpenedApp(open);
    messaging().getInitialNotification().then(open);
    return () => { offRefresh(); offMessage(); offOpened(); };
  }, []);
  return null;
}