@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/src/rn73OrMore/HydraLibPackage.kt

@@ -0,0 +1,53 @@
+package com.hydralib
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.hydralib.gamification.GamificationBannerViewManager
+import com.hydralib.gamification.GamificationEmbedViewManager
+import com.hydralib.gamification.GamificationLoyaltyViewManager
+import java.util.HashMap
+
+class HydraLibPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == HydraLibModule.NAME) {
+      HydraLibModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> = listOf(
+    GamificationBannerViewManager(),
+    GamificationEmbedViewManager(),
+    GamificationLoyaltyViewManager(),
+  )
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      val name = HydraLibModule.NAME
+      val className = HydraLibModule.NAME
+      val canOverrideExistingModule = false
+      val needsEagerInit = false
+      val isCxxModule= false
+
+
+      moduleInfos[HydraLibModule.NAME] = ReactModuleInfo(
+        name,
+        className,
+        canOverrideExistingModule,
+        needsEagerInit,
+        isCxxModule,
+        isTurboModule // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/Delegates/HydraApplicationDelegate.swift

@@ -0,0 +1,196 @@
+//
+//  HydraApplicationDelegate.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 01/01/25.
+//
+
+import Foundation
+import FirebaseCore
+import FirebaseMessaging
+import FirebaseRemoteConfig
+#if HYDRA_USE_SPM
+// GoogleUtilities has no single SPM product matching the CocoaPods umbrella
+// module - only granular GUL* products exist. The GULAppDelegateSwizzler
+// product wraps a target literally named "GoogleUtilities-AppDelegateSwizzler"
+// (see GoogleUtilities/Package.swift) - Swift mangles the hyphen to an
+// underscore for the actual importable module name, which differs from the
+// product name used for linking.
+import GoogleUtilities_AppDelegateSwizzler
+#else
+import GoogleUtilities
+#endif
+import React
+import HydraCore
+
+@objc public final class HydraApplicationDelegate: NSObject, UIApplicationDelegate{
+  @objc public static let shared = HydraApplicationDelegate()
+  
+  
+  private override init() {
+    
+  }
+  
+  fileprivate func setupNavigationController(_ application: UIApplication) {
+    //Create and set NavigationController as rootController, will be required to show NotificationCenter
+    let storyboard = UIStoryboard(name: Bundle.main.infoDictionary?["UILaunchStoryboardName"] as? String ?? "LaunchScreen", bundle: nil)
+    let viewController = storyboard.instantiateInitialViewController()
+    let navigationController = UINavigationController(rootViewController: viewController!)
+    let rootController = application.delegate!.window!!.rootViewController!
+    
+    application.delegate?.window??.rootViewController = navigationController
+    navigationController.setViewControllers([rootController], animated: true)
+    navigationController.delegate = self
+    HydraInboxUI.shared.setNavigationController(navController: navigationController)
+  }
+  
+  fileprivate func setupAppDelegateProxy() {
+    var appDelegateProxyEnabled = true
+    if let hydraProxyEnabledPlistValue = Bundle.main.infoDictionary?["HydraAppDelegateProxyEnabled"], hydraProxyEnabledPlistValue is Bool{
+      appDelegateProxyEnabled = hydraProxyEnabledPlistValue as! Bool
+    }
+    if appDelegateProxyEnabled{
+      if HydraSDKCore.isPushNotificationEnabled(){
+        if FirebaseApp.app() == nil{
+          FirebaseApp.configure()
+        }
+        Messaging.messaging().delegate = HydraFirebaseMessagingDelegate.shared
+      }
+      UNUserNotificationCenter.current().delegate = HydraUNUserNotificationCenterDelegate.shared
+
+      GULAppDelegateSwizzler.proxyOriginalDelegate()
+      GULAppDelegateSwizzler.proxyOriginalDelegateIncludingAPNSMethods()
+      GULAppDelegateSwizzler.registerAppDelegateInterceptor(self)
+    }
+    Logger.info("HydraApplicationDelegate: setupAppDelegateProxy: appDelegateProxyEnabled = \(appDelegateProxyEnabled)")
+  }
+  
+  @objc public func initApplication(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?,
+    hydraRemoteConfig : HydraNativeRemoteConfig
+  ){
+    //SetUp NavigationController
+    setupNavigationController(application)
+    
+    //Use AppDelegate swizzling to get the callbacks inside the library
+    setupAppDelegateProxy()
+    
+    application.registerForRemoteNotifications()
+    
+    Task{
+      let isInitialized = await initializeUsingPersistedData()
+      if !isInitialized{
+        Logger.debug("HydraApplicationDelegate: application: didFinishLaunchingWithOptions: initiliazing hydra using passed remote config")
+        HydraSDKCore.shared.initializeHydra(hydraRemoteConfig)
+      }
+      if HydraSDKCore.shared.hydra != nil {
+        HydraPushNotification.shared.application(application, didFinishLaunchingWithOptions: launchOptions)
+        Logger.info("HydraApplicationDelegate: application: didFinishLaunchingWithOptions: hydraRemoteConfig")
+      }
+    }
+  }
+  
+  @objc public func initApplicationWithFirebaseRemoteConfig(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+    initApplicationWithFirebaseRemoteConfigKeys(application, didFinishLaunchingWithOptions: launchOptions, firebaseRemoteConfigKeys: HydraNativeFirebaseRemoteConfigKeys(keyForAccountId: "hydra_account_id", keyForBaseUrl: "hydra_base_url", keyForSsl: "hydra_ssl_public_key", keyForRemoteLogLevel: "hydra_remote_log_level", keyForOrgId: "hydra_org_id", keyForGamificationKey: "hydra_gamification_key", keyForGamificationRegion: "hydra_gamification_region", keyForGamificationBaseUrl: "hydra_gamification_base_url"))
+  }
+  
+  @objc public func initApplicationWithFirebaseRemoteConfigKeys(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?, firebaseRemoteConfigKeys : HydraNativeFirebaseRemoteConfigKeys) {
+    //SetUp NavigationController
+    setupNavigationController(application)
+    
+    //Use AppDelegate swizzling to get the callbacks inside the library
+    setupAppDelegateProxy()
+    
+    application.registerForRemoteNotifications()
+
+    Task {
+      let isInitialized = await initializeUsingPersistedData()
+      if !isInitialized {
+        Logger.debug("HydraApplicationDelegate: application: didFinishLaunchingWithOptions: remoteConfig: using passed firebase remote config keys")
+        await fetchAndActivateRemoteConfigAndInitializeHydra(firebaseRemoteConfigKeys: firebaseRemoteConfigKeys)
+      }
+      
+      if HydraSDKCore.shared.hydra != nil {
+        HydraPushNotification.shared.application(application, didFinishLaunchingWithOptions: launchOptions)
+        Logger.info("HydraApplicationDelegate: application: didFinishLaunchingWithOptions: remoteConfig: Completed")
+      }
+    }
+  }
+  
+  func loadPresistedHydraRemoteConfig() -> HydraNativeRemoteConfig? {
+    let configDict = Hydra.getSharedUserDefaults()?.dictionary(forKey: HydraRNConstants.hydraRemoreConfig)
+    if let configDict = configDict{
+      return HydraNativeRemoteConfig.fromDictionary(configDict)
+    }else{
+      return nil
+    }
+  }
+  
+  func loadPersistedFirebaseRemoteConfigKeys() -> HydraNativeFirebaseRemoteConfigKeys? {
+    let configDict = Hydra.getSharedUserDefaults()?.dictionary(forKey: HydraRNConstants.hydraFirebaseRemoteConfigKeys)
+    if let configDict = configDict{
+      return HydraNativeFirebaseRemoteConfigKeys.fromDictionary(configDict)
+    }else{
+      return nil
+    }
+  }
+  
+  private func initializeUsingPersistedData() async -> Bool{
+    if let persistedHydraRemoteConfig = loadPresistedHydraRemoteConfig() {
+      Logger.debug("HydraApplicationDelegate: initializeUsingPersistedData: Found persisted config, initializing Hydra")
+      HydraSDKCore.shared.initializeHydra(persistedHydraRemoteConfig)
+      return true
+    }
+    
+    if let persistedFirebaseRemoteConfigKeys = loadPersistedFirebaseRemoteConfigKeys() {
+        Logger.debug("HydraApplicationDelegate: initializeUsingPersistedData: Found persisted firebase config keys, fetching and activating remote config")
+        await fetchAndActivateRemoteConfigAndInitializeHydra(firebaseRemoteConfigKeys: persistedFirebaseRemoteConfigKeys)
+        return true
+    }
+    return false
+  }
+  
+  private func fetchAndActivateRemoteConfigAndInitializeHydra(firebaseRemoteConfigKeys: HydraNativeFirebaseRemoteConfigKeys)
+  async {
+    let remoteConfig = RemoteConfig.remoteConfig()
+    remoteConfig.configSettings.minimumFetchInterval = 0
+    
+    do {
+      try await remoteConfig.fetchAndActivate()
+      let hydraRemoteConfig = HydraSDKCore.shared.processFirebaseRemoteConfig(firebaseRemoteConfigKeys)
+      
+      if let hydraRemoteConfig = hydraRemoteConfig {
+        HydraSDKCore.shared.initializeHydra(hydraRemoteConfig)
+      }
+      else {
+        Logger.error("HydraApplicationDelegate: fetchAndActivateRemoteConfigAndInitializeHydra accountId or baseUrl or sslPublicKey doesnot have valid values")
+        HydraSDKCore.shared.sendHydraSdkInitializationResultEvent(false, "accountId or baseUrl or sslPublicKey doesnot have valid values")
+      }
+    } catch {
+      let errorMessage = "Failed to fetch remote config error = \(error)"
+      Logger.error("HydraApplicationDelegate: fetchAndActivateRemoteConfigAndInitializeHydra: \(errorMessage)")
+      HydraSDKCore.shared.sendHydraSdkInitializationResultEvent(false, errorMessage)
+    }
+  }
+  
+  
+  
+  public func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+    HydraPushNotification.shared.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken)
+  }
+  
+  public func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {
+    HydraPushNotification.shared.application(application, didFailToRegisterForRemoteNotificationsWithError: error)
+  }
+  
+  public func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    HydraPushNotification.shared.application(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: completionHandler)
+  }
+}
+
+extension HydraApplicationDelegate: UINavigationControllerDelegate{
+  public func navigationController(_ navigationController: UINavigationController, willShow viewController: UIViewController, animated: Bool) {
+    HydraInboxUI.shared.navigationControllerViewWillChange(viewController)
+  }
+}

package/ios/Delegates/HydraFirebaseMessagingDelegate.swift

@@ -0,0 +1,20 @@
+//
+//  FirebaseMessagingDelegate.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 24/12/24.
+//
+
+import Foundation
+import FirebaseMessaging
+final class HydraFirebaseMessagingDelegate : NSObject,  MessagingDelegate{
+  public static let shared = HydraFirebaseMessagingDelegate()
+  
+  private override init() {
+    
+  }
+  
+  public func messaging(_ messaging: Messaging, didReceiveRegistrationToken token: String?) {
+    HydraPushNotification.shared.messaging(messaging, didReceiveRegistrationToken: token)
+  }
+}

package/ios/Delegates/HydraUNUserNotificationCenterDelegate.swift

@@ -0,0 +1,26 @@
+//
+//  HydraUNUserNotificationCenterDelegate.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 24/12/24.
+//
+
+import Foundation
+import FirebaseMessaging
+
+final class HydraUNUserNotificationCenterDelegate : NSObject, UNUserNotificationCenterDelegate{
+  
+  public static let shared = HydraUNUserNotificationCenterDelegate()
+  
+  private override init() {
+    
+  }
+  
+  public func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
+    HydraPushNotification.shared.userNotificationCenter(center, willPresent: notification, withCompletionHandler: completionHandler)
+  }
+  
+  public func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void){
+    HydraPushNotification.shared.userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
+  }
+}

package/ios/EventEmitter/HydraEventEmitter.swift

@@ -0,0 +1,98 @@
+//
+//  HydraEventEmitter.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 06/01/25.
+//
+
+import Foundation
+import HydraCore
+import React
+
+// Callback protocol for event completion
+@objc public protocol EventResponse {
+  func onEventResponse(_ response: Any)
+}
+
+// Struct to hold pending event data
+private struct PendingEvent {
+  let body: Any?
+  let callback: EventResponse?
+}
+
+@objc public final class HydraEventEmitter : NSObject{
+  
+  private var activeEventTypes : [String] = []
+  private var emitterInitialized : Bool = false
+  private var pendingEvents : [String : [PendingEvent]] = [:]
+  private var eventsWithPendingCallback: [PendingEvent] = []
+  @objc public static let shared = HydraEventEmitter()
+  
+  
+  private override init(){
+    super.init()
+  }
+  
+  @objc public func setEmitterInitialized(){
+    emitterInitialized = true
+  }
+  
+  @objc public func sendEvent(_ eventType: String, body: Any?, callback: EventResponse? = nil){
+    if emitterInitialized && activeEventTypes.contains(eventType) {
+      Logger.info("HydraEventEmitter: sendEvent: eventType = \(eventType), body = \(body ?? "")")
+      HydraNativeEmitterBrigde.sharedInstance().sendEvent(withName: eventType, body: body)
+
+      // Store callback if provided
+      if let callback = callback {
+        eventsWithPendingCallback.append(PendingEvent(body: body, callback: callback))
+      }
+    } else {
+      // Queue event — either emitter not yet initialized, or listener not yet registered
+      var pendingEventsForType = pendingEvents[eventType] ?? []
+      pendingEventsForType.append(PendingEvent(body: body, callback: callback))
+      pendingEvents[eventType] = pendingEventsForType
+    }
+  }
+  
+  @objc public func supportedEvents() -> [String]{
+    HydraEventType.allCases.map { $0.rawValue }
+  }
+  
+  private func sendPendingEventsOfType(_ eventType : String){
+    pendingEvents[eventType]?.forEach{ pendingEvent in
+      sendEvent(eventType, body: pendingEvent.body, callback: pendingEvent.callback)
+    }
+    pendingEvents[eventType] = nil
+  }
+  
+  @objc public func addListener(eventName : String) {
+    if !activeEventTypes.contains(eventName){
+      Logger.debug("HydraEventEmitter: addListener: adding event = \(eventName)")
+      activeEventTypes.append(eventName)
+      sendPendingEventsOfType(eventName)
+    }
+  }
+  
+  @objc public func removeListener(eventName : String) {
+    if activeEventTypes.contains(eventName) {
+      Logger.debug("HydraEventEmitter: removeListener: removing event = \(eventName)")
+      activeEventTypes.removeAll(where: {$0 == eventName})
+    }
+  }
+  
+  @objc public func onSelfHandledInAppResponse(message: [String: Any]?, handled: Bool, resolve : RCTPromiseResolveBlock?, reject : RCTPromiseRejectBlock?)  -> Void{
+    Logger.info("HydraEventEmitter: onSelfHandledInAppResponse: message details - type = \(message?["templateType"] ?? ""), title = \(message?["title"] ?? ""), message = \(message?["message"] ?? "")")
+    
+    let scope = message?["scope"] as? String ?? "default"
+    
+    // Find and execute callback for matching scope
+    for (index, event) in eventsWithPendingCallback.enumerated() {
+      if let eventBody = event.body as? [String: Any], eventBody["scope"] as? String == scope {
+        event.callback?.onEventResponse(handled)
+        eventsWithPendingCallback.remove(at: index)
+        break
+      }
+    }
+    resolve?(true)
+  }
+}

package/ios/EventEmitter/HydraEventType.swift

@@ -0,0 +1,28 @@
+//
+//  HydraEventType.swift
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 06/01/25.
+//
+
+import Foundation
+
+enum HydraEventType : String, CaseIterable{
+  case ON_TOKEN_AVAILABLE = "onTokenAvailable"
+  case ON_NON_HYDRA_NOTIFICATION_RECEIVED = "onNonHydraNotificationReceived"
+  case ON_NON_HYDRA_NOTIFICATION_CLICKED = "onNonHydraNotificationClicked"
+  case ON_HYDRA_NOTIFICATION_RECEIVED = "onHydraNotificationReceived"
+  case ON_HYDRA_NOTIFICATION_CLICKED = "onHydraNotificationClicked"
+  case ON_HYDRA_NOTIFICATION_SHOWN = "onHydraNotificationShown"
+  case ON_HYDRA_NOTIFICATION_DISMISSED = "onHydraNotificationDismissed"
+  case ON_INBOX_UPDATED = "onInboxUpdated"
+  case ON_NOTIFICATION_CENTER_DISMISSED = "onNotificationCenterDismissed"
+  case ON_NOTIFICATION_CENTER_SHOWN = "onNotificationCenterShown"
+  case ON_HYDRA_SDK_INITIALIZATION_RESULT = "onHydraSdkInitializationResult"
+  case ON_HYDRA_IN_APP_MESSAGE = "onHydraInAppMessage"
+  case ON_CONFIG_FETCHED_CALLBACK = "onConfigFetchedCallback"
+  case ON_LEGACY_FLOW_READY = "onLegacyFlowReady"
+  case ON_VISITOR_SESSION_READY = "onVisitorSessionReady"
+  case ON_USER_STATE_CHANGED = "onUserStateChanged"
+  case ON_GAMIFICATION_VIEW_HEIGHT_CHANGED = "onGamificationViewHeightChanged"
+}

package/ios/EventEmitter/HydraNativeEmitterBrigde.h

@@ -0,0 +1,15 @@
+//
+//  HydraNativeEmitterBrigde.h
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 06/01/25.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface HydraNativeEmitterBrigde : NSObject
++ (instancetype)sharedInstance;
+-(void)setHydraLib:(id)hydraLibIns;
+- (NSArray<NSString *> *)supportedEvents;
+- (void)sendEventWithName:(NSString *)eventName body:(id)body;
+@end

package/ios/EventEmitter/HydraNativeEmitterBrigde.mm

@@ -0,0 +1,48 @@
+//
+//  HydraNativeEmitterBrigde.m
+//  react-native-hydra-lib
+//
+//  Created by Sandesh Kumar Jain on 06/01/25.
+//
+
+#import "HydraNativeEmitterBrigde.h"
+#import <React/RCTBridgeModule.h>
+#import <UserNotifications/UserNotifications.h>
+
+#if __has_include("react_native_hydra_lib-Swift.h")
+#import "react_native_hydra_lib-Swift.h"
+#elif __has_include(<react_native_hydra_lib/react_native_hydra_lib-Swift.h>)
+#import <react_native_hydra_lib/react_native_hydra_lib-Swift.h>
+#endif
+
+#import "HydraLib.h"
+
+@implementation HydraNativeEmitterBrigde
+
+HydraLib* hydraLib;
+
++ (instancetype)sharedInstance {
+  static HydraNativeEmitterBrigde *shared = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    shared = [[self alloc] init];
+  });
+  return shared;
+}
+
+-(void)setHydraLib:(id)hydraLibIns{
+  if(hydraLibIns != nil){
+    NSAssert([hydraLibIns isKindOfClass:[HydraLib class]], @"hydraLibIns %@ is not kind of class %@", hydraLibIns, NSStringFromClass([HydraLib class]));
+  }
+  hydraLib = hydraLibIns;
+  [[HydraEventEmitter shared] setEmitterInitialized];
+}
+
+- (void)sendEventWithName:(NSString *)eventName body:(id)body;{
+  [hydraLib sendEventWithName:eventName body:body];
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return [[HydraEventEmitter shared] supportedEvents];
+}
+@end

package/ios/GamificationViews/GamificationBannerViewComponentView.h

@@ -0,0 +1,14 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GamificationBannerViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/GamificationViews/GamificationBannerViewComponentView.mm

@@ -0,0 +1,125 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "GamificationBannerViewComponentView.h"
+
+#import "../generated/RNHydraLibSpec/ComponentDescriptors.h"
+#import "../generated/RNHydraLibSpec/EventEmitters.h"
+#import "../generated/RNHydraLibSpec/Props.h"
+#import "../generated/RNHydraLibSpec/RCTComponentViewHelpers.h"
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTBridgeModule.h>
+#import <React/RCTComponentViewFactory.h>
+#import <UserNotifications/UserNotifications.h>
+#if __has_include("react_native_hydra_lib-Swift.h")
+#import "react_native_hydra_lib-Swift.h"
+#elif __has_include(<react_native_hydra_lib/react_native_hydra_lib-Swift.h>)
+#import <react_native_hydra_lib/react_native_hydra_lib-Swift.h>
+#endif
+
+using namespace facebook::react;
+
+@interface GamificationBannerViewComponentView () <RCTGamificationBannerViewViewProtocol>
+@end
+
+@implementation GamificationBannerViewComponentView {
+    NSString *_bannerId;
+    BOOL _needsBannerView;
+    BOOL _retryPending;
+}
+
++ (void)load {
+    [[RCTComponentViewFactory currentComponentViewFactory] registerComponentViewClass:self];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+    return concreteComponentDescriptorProvider<GamificationBannerViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const GamificationBannerViewProps>();
+        _props = defaultProps;
+
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(gamificationDataReloaded)
+                                                     name:[[HydraSDKCore shared] getNotificationName]
+                                                   object:nil];
+    }
+    return self;
+}
+
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)gamificationDataReloaded {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self->_needsBannerView = YES;
+        [self attachBannerViewIfPossible];
+    });
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps {
+    const auto &newProps = *std::static_pointer_cast<const GamificationBannerViewProps>(props);
+
+    const auto defaultProps = GamificationBannerViewProps();
+    const auto &prevProps = oldProps
+        ? *std::static_pointer_cast<const GamificationBannerViewProps>(oldProps)
+        : defaultProps;
+
+    BOOL bannerIdChanged = prevProps.bannerId != newProps.bannerId;
+
+    if (self.contentView == nil || bannerIdChanged) {
+        _bannerId = [NSString stringWithUTF8String:newProps.bannerId.c_str()];
+        _needsBannerView = YES;
+        [self attachBannerViewIfPossible];
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    [self attachBannerViewIfPossible];
+}
+
+- (void)attachBannerViewIfPossible {
+    if (!_needsBannerView || _bannerId.length == 0) {
+        return;
+    }
+    if (CGRectIsEmpty(self.bounds)) {
+        return;
+    }
+
+    NSLog(@"[GamificationBanner] trying createGamificationBannerView(bannerId=%@)", _bannerId);
+    UIView *bannerView = [[HydraSDKCore shared] createGamificationBannerViewWithBannerId:_bannerId];
+    if (bannerView) {
+        NSLog(@"[GamificationBanner] banner view created OK");
+        self.contentView = bannerView;
+        _needsBannerView = NO;
+        _retryPending = NO;
+    } else {
+        NSLog(@"[GamificationBanner] SDK returned nil — scheduling long fallback");
+        [self scheduleFallbackRetry];
+    }
+}
+
+- (void)scheduleFallbackRetry {
+    if (_retryPending) return;
+    _retryPending = YES;
+    __weak __typeof__(self) weakSelf = self;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        __typeof__(self) strongSelf = weakSelf;
+        if (!strongSelf) return;
+        strongSelf->_retryPending = NO;
+        [strongSelf attachBannerViewIfPossible];
+    });
+}
+
+@end
+
+Class<RCTComponentViewProtocol> GamificationBannerViewCls(void) {
+    return GamificationBannerViewComponentView.class;
+}
+
+#endif

package/ios/GamificationViews/GamificationEmbedViewComponentView.h

@@ -0,0 +1,14 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GamificationEmbedViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif