react-native-empower-mobile-ads 1.0.0

package/README.md

@@ -0,0 +1,149 @@
+# react-native-empower-mobile-ads
+
+React Native bridge for EmpowerMobileAds SDK. Supports banner, sticky, interstitial, rewarded and app open ad formats.
+
+## Installation
+
+```bash
+npm install react-native-empower-mobile-ads
+```
+
+### iOS Setup
+
+**1.** Add the Empower private spec repo to your `Podfile`:
+
+```ruby
+source 'https://github.com/empowernet/specs.git'
+source 'https://cdn.cocoapods.org/'
+```
+
+**2.** Install pods:
+
+```bash
+cd ios && pod install
+```
+
+## Usage
+
+### Initialize SDK
+
+Call this once on app startup, before loading any ads:
+
+```tsx
+import { EmpowerAds } from 'react-native-empower-mobile-ads';
+
+await EmpowerAds.initialize('YOUR_APP_IDENTIFIER', {
+  testMode: false,
+  logLevel: 'all',
+});
+```
+
+### Banner Ad
+
+```tsx
+import { BannerAd } from 'react-native-empower-mobile-ads';
+
+<BannerAd
+  zoneId="your_zone_id"
+  style={{ width: 320, height: 50 }}
+  onAdLoaded={() => console.log('Ad loaded')}
+  onAdFailed={(error) => console.log('Ad failed:', error)}
+  onAdClicked={() => console.log('Ad clicked')}
+  onSizeChanged={({ width, height }) => console.log('New size:', width, height)}
+/>
+```
+
+### Sticky Ad
+
+```tsx
+import { StickyAd } from 'react-native-empower-mobile-ads';
+
+<StickyAd
+  zoneId="your_zone_id"
+  style={{ width: 320, height: 50 }}
+  onAdLoaded={() => console.log('Sticky loaded')}
+/>
+```
+
+### Interstitial Ad
+
+```tsx
+import { InterstitialAd } from 'react-native-empower-mobile-ads';
+
+// Load
+await InterstitialAd.load('your_zone_id');
+
+// Show when ready
+if (await InterstitialAd.isReady()) {
+  await InterstitialAd.show();
+}
+
+// Listen for status changes
+const remove = InterstitialAd.addEventListener('statusChanged', (event) => {
+  console.log('Interstitial status:', event.status);
+});
+
+// Cleanup
+remove();
+```
+
+### Rewarded Ad
+
+```tsx
+import { RewardedAd } from 'react-native-empower-mobile-ads';
+
+// Listen for reward
+const remove = RewardedAd.addEventListener('statusChanged', (event) => {
+  if (event.status === 'rewarded') {
+    // Grant the reward
+  }
+});
+
+// Load & show
+await RewardedAd.load('your_zone_id');
+if (await RewardedAd.isReady()) {
+  await RewardedAd.show();
+}
+```
+
+### App Open Ad
+
+```tsx
+import { AppOpenAd } from 'react-native-empower-mobile-ads';
+
+await AppOpenAd.load('your_zone_id');
+if (await AppOpenAd.isReady()) {
+  await AppOpenAd.show();
+}
+```
+
+## Configuration
+
+```tsx
+// Content page for ad targeting
+EmpowerAds.setContentPage('https://example.com/article/123');
+
+// Global targeting parameters
+EmpowerAds.setGlobalTargeting({
+  category: ['sports', 'news'],
+  section: ['homepage'],
+});
+
+// User segments
+EmpowerAds.setSegments(['premium_user']);
+
+// GDPR - non-personalized ads
+EmpowerAds.setNonPersonalized(true);
+
+// Disable all ads
+EmpowerAds.setAdsDisabled(true);
+
+// Show remove ads button
+EmpowerAds.setShowRemoveAdsButton(true);
+```
+
+## Requirements
+
+- React Native >= 0.71
+- iOS >= 13.0
+- EmpowerMobileAds SDK (via CocoaPods private spec repo)

package/ios/EmpowerAdsModule.m

@@ -0,0 +1,21 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(EmpowerAdsModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSString *)appId
+                  options:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(setContentPage:(NSString *)url)
+RCT_EXTERN_METHOD(setGlobalTargeting:(NSDictionary *)targeting)
+RCT_EXTERN_METHOD(setSegments:(NSArray *)segments)
+RCT_EXTERN_METHOD(setNonPersonalized:(BOOL)value)
+RCT_EXTERN_METHOD(setAdsDisabled:(BOOL)value)
+RCT_EXTERN_METHOD(setShowRemoveAdsButton:(BOOL)value)
+
+RCT_EXTERN_METHOD(getNoktaId:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

package/ios/EmpowerAdsModule.swift

@@ -0,0 +1,111 @@
+import Foundation
+import React
+import EmpowerMobileAds
+
+@objc(EmpowerAdsModule)
+class EmpowerAdsModule: RCTEventEmitter {
+
+    override static func moduleName() -> String! { "EmpowerAdsModule" }
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func supportedEvents() -> [String]! {
+        ["onAdsReady", "onAdsFailed"]
+    }
+
+    @objc func initialize(_ appId: String, options: NSDictionary, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            let testMode = options["testMode"] as? Bool ?? false
+            let appVersion = options["appVersion"] as? String ?? "1"
+            let vParam = options["vParam"] as? String
+
+            if let logLevel = options["logLevel"] as? String {
+                switch logLevel {
+                case "none":  EMASettings.shared.logLevel = .none
+                case "error": EMASettings.shared.logLevel = .error
+                default:      EMASettings.shared.logLevel = .all
+                }
+            }
+
+            if let nonPersonalized = options["nonPersonalized"] as? Bool {
+                EMASettings.shared.isAdsNonPersonalized = nonPersonalized
+            }
+
+            // Set root view controller
+            EMASettings.shared.rootViewController = RCTPresentedViewController()
+
+            EMAManager.shared.initAd(appId, appVersion, testMode, vParam)
+
+            // Listen for config ready
+            EMAManager.shared.appViewDelegates.append(AppViewBridge(onComplete: { [weak self] in
+                self?.sendEvent(withName: "onAdsReady", body: nil)
+                resolver(nil)
+            }, onFail: { [weak self] in
+                self?.sendEvent(withName: "onAdsFailed", body: nil)
+                rejecter("ADS_INIT_FAILED", "EmpowerMobileAds initialization failed", nil)
+            }))
+        }
+    }
+
+    @objc func setContentPage(_ url: String) {
+        DispatchQueue.main.async {
+            EMAManager.shared.contentPage = url
+        }
+    }
+
+    @objc func setGlobalTargeting(_ targeting: NSDictionary) {
+        DispatchQueue.main.async {
+            var result: [String: [String]] = [:]
+            for (key, value) in targeting {
+                if let k = key as? String, let v = value as? [String] {
+                    result[k] = v
+                }
+            }
+            EMAManager.shared.globalTargeting = result
+        }
+    }
+
+    @objc func setSegments(_ segments: NSArray) {
+        DispatchQueue.main.async {
+            EMAManager.shared.segments = segments as? [String] ?? []
+        }
+    }
+
+    @objc func setNonPersonalized(_ value: Bool) {
+        DispatchQueue.main.async {
+            EMASettings.shared.isAdsNonPersonalized = value
+        }
+    }
+
+    @objc func setAdsDisabled(_ value: Bool) {
+        DispatchQueue.main.async {
+            EMASettings.shared.isAdsDisabled = value
+        }
+    }
+
+    @objc func setShowRemoveAdsButton(_ value: Bool) {
+        DispatchQueue.main.async {
+            EMASettings.shared.showRemoveAdsButton = value
+        }
+    }
+
+    @objc func getNoktaId(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            let noktaId = EMAManager.shared.getNoktaId()
+            resolver(noktaId)
+        }
+    }
+}
+
+// MARK: - AppViewDelegate Bridge
+private class AppViewBridge: NSObject, AppViewDelegate {
+    let onComplete: () -> Void
+    let onFail: () -> Void
+
+    init(onComplete: @escaping () -> Void, onFail: @escaping () -> Void) {
+        self.onComplete = onComplete
+        self.onFail = onFail
+    }
+
+    func appViewCompleted() { onComplete() }
+    func appViewFailed() { onFail() }
+}

package/ios/EmpowerAppOpenModule.m

@@ -0,0 +1,16 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(EmpowerAppOpenModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(load:(NSString *)zoneId
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(isReady:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(show:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

package/ios/EmpowerAppOpenModule.swift

@@ -0,0 +1,55 @@
+import Foundation
+import React
+import EmpowerMobileAds
+
+@objc(EmpowerAppOpenModule)
+class EmpowerAppOpenModule: RCTEventEmitter, AdStatusDelegate {
+
+    override static func moduleName() -> String! { "EmpowerAppOpenModule" }
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func supportedEvents() -> [String]! {
+        ["onAppOpenStatusChanged"]
+    }
+
+    @objc func load(_ zoneId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            EMAManager.shared.loadAppOpen(zoneId: zoneId)
+            resolver(nil)
+        }
+    }
+
+    @objc func isReady(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            resolver(EMAManager.shared.isAppOpenReady())
+        }
+    }
+
+    @objc func show(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let rootVC = EMASettings.shared.rootViewController ?? RCTPresentedViewController() else {
+                rejecter("NO_VC", "No root view controller available", nil)
+                return
+            }
+            EMAManager.shared.showAppOpen(from: rootVC)
+            resolver(nil)
+        }
+    }
+
+    // MARK: - AdStatusDelegate
+
+    func empowerAppOpenStatusChanged(_ manager: EmpowerAppOpenManager) {
+        let statusString: String
+        switch manager.status {
+        case .ready:       statusString = "ready"
+        case .failed:      statusString = "failed"
+        case .used:        statusString = "used"
+        case .willPresent: statusString = "willPresent"
+        default:           statusString = "unknown"
+        }
+
+        sendEvent(withName: "onAppOpenStatusChanged", body: [
+            "status": statusString,
+        ])
+    }
+}

package/ios/EmpowerBannerViewManager.m

@@ -0,0 +1,14 @@
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(EmpowerBannerViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(zoneId, NSString)
+RCT_EXPORT_VIEW_PROPERTY(adType, NSString)
+RCT_EXPORT_VIEW_PROPERTY(keywords, NSString)
+RCT_EXPORT_VIEW_PROPERTY(customParameters, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(onAdLoaded, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdFailed, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdClicked, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onSizeChanged, RCTDirectEventBlock)
+
+@end

package/ios/EmpowerBannerViewManager.swift

@@ -0,0 +1,121 @@
+import Foundation
+import UIKit
+import React
+import EmpowerMobileAds
+
+@objc(EmpowerBannerViewManager)
+class EmpowerBannerViewManager: RCTViewManager {
+
+    override static func moduleName() -> String! { "EmpowerBannerView" }
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func view() -> UIView! {
+        return EmpowerBannerView(bridge: self.bridge)
+    }
+}
+
+// MARK: - EmpowerBannerView
+class EmpowerBannerView: UIView, AdStatusDelegate {
+
+    private var bridge: RCTBridge?
+    private var zoneManager: EmpowerZoneManager?
+    private var containerView: UIView!
+    private var isAdLoaded = false
+
+    // React props
+    @objc var zoneId: String = "" { didSet { loadAdIfReady() } }
+    @objc var adType: String = "banner"
+    @objc var keywords: String?
+    @objc var customParameters: NSDictionary?
+
+    // React event callbacks
+    @objc var onAdLoaded: RCTDirectEventBlock?
+    @objc var onAdFailed: RCTDirectEventBlock?
+    @objc var onAdClicked: RCTDirectEventBlock?
+    @objc var onSizeChanged: RCTDirectEventBlock?
+
+    init(bridge: RCTBridge?) {
+        self.bridge = bridge
+        super.init(frame: .zero)
+
+        containerView = UIView()
+        containerView.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(containerView)
+
+        NSLayoutConstraint.activate([
+            containerView.topAnchor.constraint(equalTo: topAnchor),
+            containerView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            containerView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            containerView.bottomAnchor.constraint(equalTo: bottomAnchor),
+        ])
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) not supported") }
+
+    // MARK: - Load
+
+    private func loadAdIfReady() {
+        guard !zoneId.isEmpty, !isAdLoaded else { return }
+        guard let rootVC = EMASettings.shared.rootViewController ?? RCTPresentedViewController() else { return }
+
+        isAdLoaded = true
+
+        var customParams: [String: [String]]? = nil
+        if let cp = customParameters as? [String: [String]] {
+            customParams = cp
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            self.zoneManager = EMAManager.shared.loadBannerAd(
+                viewController: rootVC,
+                zoneId: self.zoneId,
+                bannerContainer: self.containerView,
+                delegate: self,
+                adConfiguration: nil,
+                customParameters: customParams,
+                category: nil,
+                keywords: self.keywords
+            )
+        }
+    }
+
+    // MARK: - AdStatusDelegate
+
+    func bannerStatusChanged(_ manager: EmpowerBannerManager) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            switch manager.status {
+            case .ready:
+                self.onAdLoaded?([:])
+
+                // Report actual size back to RN so the JS side can adjust layout
+                let adWidth = manager.bannerModel.width
+                let adHeight = manager.bannerModel.height
+                if adWidth > 0, adHeight > 0 {
+                    self.onSizeChanged?([
+                        "width": adWidth,
+                        "height": adHeight,
+                    ])
+                }
+
+            case .failed:
+                self.onAdFailed?(["error": "Ad failed to load"])
+
+            case .willPresent, .willLeave:
+                self.onAdClicked?([:])
+
+            default:
+                break
+            }
+        }
+    }
+
+    // MARK: - Cleanup
+
+    deinit {
+        zoneManager?.destroy()
+    }
+}

package/ios/EmpowerInterstitialModule.m

@@ -0,0 +1,18 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(EmpowerInterstitialModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(load:(NSString *)zoneId
+                  keywords:(NSString *)keywords
+                  customParameters:(NSDictionary *)customParameters
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(isReady:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(show:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

package/ios/EmpowerInterstitialModule.swift

@@ -0,0 +1,62 @@
+import Foundation
+import React
+import EmpowerMobileAds
+
+@objc(EmpowerInterstitialModule)
+class EmpowerInterstitialModule: RCTEventEmitter, AdStatusDelegate {
+
+    private var zoneManager: EmpowerZoneManager?
+
+    override static func moduleName() -> String! { "EmpowerInterstitialModule" }
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func supportedEvents() -> [String]! {
+        ["onInterstitialStatusChanged"]
+    }
+
+    @objc func load(_ zoneId: String?, keywords: String?, customParameters: NSDictionary?,
+                    resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            var customParams: [String: [String]]? = nil
+            if let cp = customParameters as? [String: [String]] {
+                customParams = cp
+            }
+
+            EMAManager.shared.loadInterstitial(
+                zoneId: zoneId,
+                delegate: self,
+                customParameters: customParams,
+                keywords: keywords
+            )
+
+            resolver(nil)
+        }
+    }
+
+    @objc func isReady(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            resolver(EMAManager.shared.isInterstitialReady())
+        }
+    }
+
+    @objc func show(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let rootVC = EMASettings.shared.rootViewController ?? RCTPresentedViewController() else {
+                rejecter("NO_VC", "No root view controller available", nil)
+                return
+            }
+            EMAManager.shared.showInterstitial(from: rootVC)
+            resolver(nil)
+        }
+    }
+
+    // MARK: - AdStatusDelegate
+
+    func interstitialStatusChanged(_ manager: EmpowerInterstitialManager) {
+        sendEvent(withName: "onInterstitialStatusChanged", body: [
+            "status": manager.status.rawValue,
+        ])
+    }
+}

package/ios/EmpowerRewardedModule.m

@@ -0,0 +1,18 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(EmpowerRewardedModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(load:(NSString *)zoneId
+                  keywords:(NSString *)keywords
+                  customParameters:(NSDictionary *)customParameters
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(isReady:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(show:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

package/ios/EmpowerRewardedModule.swift

@@ -0,0 +1,70 @@
+import Foundation
+import React
+import EmpowerMobileAds
+
+@objc(EmpowerRewardedModule)
+class EmpowerRewardedModule: RCTEventEmitter, AdStatusDelegate {
+
+    override static func moduleName() -> String! { "EmpowerRewardedModule" }
+    override static func requiresMainQueueSetup() -> Bool { true }
+
+    override func supportedEvents() -> [String]! {
+        ["onRewardedStatusChanged"]
+    }
+
+    @objc func load(_ zoneId: String?, keywords: String?, customParameters: NSDictionary?,
+                    resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            var customParams: [String: [String]]? = nil
+            if let cp = customParameters as? [String: [String]] {
+                customParams = cp
+            }
+
+            EMAManager.shared.loadRewarded(
+                zoneId: zoneId,
+                delegate: self,
+                customParameters: customParams,
+                keywords: keywords
+            )
+
+            resolver(nil)
+        }
+    }
+
+    @objc func isReady(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            resolver(EMAManager.shared.isRewardedReady())
+        }
+    }
+
+    @objc func show(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let rootVC = EMASettings.shared.rootViewController ?? RCTPresentedViewController() else {
+                rejecter("NO_VC", "No root view controller available", nil)
+                return
+            }
+            EMAManager.shared.showRewarded(from: rootVC)
+            resolver(nil)
+        }
+    }
+
+    // MARK: - AdStatusDelegate
+
+    func rewardedStatusChanged(_ manager: EmpowerRewardedManager) {
+        let statusString: String
+        switch manager.status {
+        case .rewarded:       statusString = "rewarded"
+        case .ready:          statusString = "ready"
+        case .failed:         statusString = "failed"
+        case .used:           statusString = "used"
+        case .willPresent:    statusString = "willPresent"
+        default:              statusString = "unknown"
+        }
+
+        sendEvent(withName: "onRewardedStatusChanged", body: [
+            "status": statusString,
+        ])
+    }
+}