react-native-daro 1.0.15 → 1.0.16

package/ios/Shared/DaroMNativeAdView.swift

@@ -0,0 +1,575 @@
+import React
+import UIKit
+
+@objc(RNDaroMNativeAdView)
+final class RNDaroMNativeAdView: UIView, DaroMNativeAdRenderDelegate {
+
+  private static let assetLoadRetryDelay: TimeInterval = 0.05
+  private static let maxAssetLoadRetryCount = 40
+
+  var _internalAdView: DaroMBridgeNativeAdView?
+  private var pinnedConstraints: [ObjectIdentifier: [NSLayoutConstraint]] = [:]
+  private var pendingLoadWorkItem: DispatchWorkItem?
+  private let loadCoordinator = DaroMNativeAdLoadCoordinator()
+  private var defaultAssetResolver: DaroMNativeAssetResolving?
+  private var assetResolver: DaroMNativeAssetResolving?
+  private let eventSink = DaroMAdEventSink()
+  var adUnit: DaroAdUnit
+
+  @objc var adUnitId: String?
+  @objc var loadOnMount: Bool = true
+  @objc var titleViewStyleProps: NSDictionary? {
+    didSet {
+      _internalTitleLabel.applyStyle(titleViewStyleProps)
+    }
+  }
+  private var _titleView: NSNumber?
+  @objc var titleView: NSNumber? {
+    get { _titleView }
+    set { _titleView = Self.normalizedAssetTag(newValue) }
+  }
+  @objc var bodyViewStyleProps: NSDictionary? {
+    didSet {
+      _internalBodyLabel.applyStyle(bodyViewStyleProps)
+    }
+  }
+  private var _bodyView: NSNumber?
+  @objc var bodyView: NSNumber? {
+    get { _bodyView }
+    set { _bodyView = Self.normalizedAssetTag(newValue) }
+  }
+  @objc var callToActionViewStyleProps: NSDictionary? {
+    didSet {
+      _internalFakeCTAButton.applyStyle(callToActionViewStyleProps)
+    }
+  }
+  private var _callToActionView: NSNumber?
+  @objc var callToActionView: NSNumber? {
+    get { _callToActionView }
+    set { _callToActionView = Self.normalizedAssetTag(newValue) }
+  }
+  @objc var iconViewStyleProps: NSDictionary? {
+    didSet {
+      _internalIconImageView.applyStyle(iconViewStyleProps)
+    }
+  }
+  private var _iconView: NSNumber?
+  @objc var iconView: NSNumber? {
+    get { _iconView }
+    set { _iconView = Self.normalizedAssetTag(newValue) }
+  }
+  @objc var mediaViewStyleProps: NSDictionary? {
+    didSet {
+      _internalMediaView.baseApplyStyle(mediaViewStyleProps)
+    }
+  }
+  private var _mediaView: NSNumber?
+  @objc var mediaView: NSNumber? {
+    get { _mediaView }
+    set { _mediaView = Self.normalizedAssetTag(newValue) }
+  }
+  @objc var adChoicesPosition: String?
+
+  var _internalTitleLabel: UILabel = RNDaroMNativeAdView.makeTitleLabel()
+  var _internalBodyLabel: UILabel = RNDaroMNativeAdView.makeBodyLabel()
+  var _internalMediaView: UIView = RNDaroMNativeAdView.makeMediaView()
+  var _internalIconImageView: UIImageView = RNDaroMNativeAdView.makeIconImageView()
+  var _internalFakeCTAButton: UIButton = RNDaroMNativeAdView.makeFakeCTAButton()
+
+  private static func makeTitleLabel() -> UILabel {
+    let label = UILabel()
+    label.isUserInteractionEnabled = false
+    label.clipsToBounds = true
+    label.font = .systemFont(ofSize: 15, weight: .bold)
+    label.textColor = UIColor.black
+    return label
+  }
+
+  private static func makeBodyLabel() -> UILabel {
+    let label = UILabel()
+    label.isUserInteractionEnabled = false
+    label.clipsToBounds = true
+    label.font = .systemFont(ofSize: 15, weight: .regular)
+    label.textColor = UIColor.black
+    return label
+  }
+
+  private static func makeMediaView() -> UIView {
+    UIView()
+  }
+
+  private static func makeIconImageView() -> UIImageView {
+    let view = UIImageView()
+    view.contentMode = .scaleAspectFill
+    return view
+  }
+
+  private static func makeFakeCTAButton() -> UIButton {
+    let button = UIButton()
+    button.translatesAutoresizingMaskIntoConstraints = false
+    button.isUserInteractionEnabled = false
+    button.setTitleColor(.white, for: .normal)
+    return button
+  }
+
+  @objc var onAdLoadedEvent: RCTDirectEventBlock? {
+    get { eventSink.onAdLoadedEvent }
+    set { eventSink.onAdLoadedEvent = newValue }
+  }
+  @objc var onAdLoadFailedEvent: RCTDirectEventBlock? {
+    get { eventSink.onAdLoadFailedEvent }
+    set { eventSink.onAdLoadFailedEvent = newValue }
+  }
+  @objc var onAdClickedEvent: RCTDirectEventBlock? {
+    get { eventSink.onAdClickedEvent }
+    set { eventSink.onAdClickedEvent = newValue }
+  }
+  @objc var onAdImpressionRecordedEvent: RCTDirectEventBlock? {
+    get { eventSink.onAdImpressionRecordedEvent }
+    set { eventSink.onAdImpressionRecordedEvent = newValue }
+  }
+
+  @Atomic private var isAdUnitIdSet: Bool = false
+  @Atomic private var isBindBridge: Bool = false
+  @Atomic private var isDisposed: Bool = false
+
+  private static func normalizedAssetTag(_ tag: NSNumber?) -> NSNumber? {
+    guard let tag, tag.intValue != 0 else { return nil }
+    return tag
+  }
+
+  convenience init(assetResolver: DaroMNativeAssetResolving?) {
+    self.init()
+    self.defaultAssetResolver = assetResolver
+    self.assetResolver = assetResolver
+  }
+
+  required init() {
+    self.adUnit = DaroAdUnit(unitId: "")
+    super.init(frame: .zero)
+  }
+
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  deinit {
+    disposeNativeAdView()
+  }
+
+  override func didSetProps(_ changedProps: [String]) {
+    applyReactProps(changedProps)
+  }
+
+  @objc(applyReactProps:)
+  func applyReactProps(_ changedProps: [String]) {
+    guard !isDisposed else { return }
+    guard changedProps.isEmpty == false else { return }
+    guard let adUnitId, adUnitId.isEmpty == false else {
+      if changedProps.contains("adUnitId") {
+        DaroMModule.logger.warning("[native-ad] AdUnitId is required")
+      }
+      return
+    }
+    loadCoordinator.cancelAutomaticLoadIfNeeded(loadOnMount: loadOnMount)
+    DaroMModule.logger.info("[native-ad] \(#function): \(changedProps)")
+    if !isAdUnitIdSet {
+      isAdUnitIdSet = true
+      makeAdViews(unitId: adUnitId)
+      requestInitialLoadIfNeeded()
+    }
+
+    if hasBridgeViewChange(changedProps) {
+      DispatchQueue.main.async { [weak self] in
+        self?.refreshAssetBindingsAndProcessPendingLoad()
+      }
+    }
+
+    requestInitialLoadIfNeeded()
+  }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+
+    guard !isDisposed, window != nil else { return }
+
+    DispatchQueue.main.async { [weak self] in
+      self?.refreshAssetBindingsAndProcessPendingLoad()
+    }
+  }
+
+  override func removeFromSuperview() {
+    disposeNativeAdView()
+    super.removeFromSuperview()
+  }
+
+  @objc(prepareForReuse)
+  func prepareForReuse() {
+    resetNativeAdState(clearAssetResolver: false, recreateAssetViews: true)
+    resetReactProps()
+    isDisposed = false
+  }
+
+  func loadAd() {
+    guard !isDisposed else { return }
+    loadCoordinator.requestExplicitLoad()
+    processPendingLoad(retryCount: 0)
+  }
+
+  private func requestInitialLoadIfNeeded() {
+    guard loadOnMount, !isDisposed, _internalAdView != nil, hasRegisteredAssetView else { return }
+    loadCoordinator.requestAutomaticLoad(loadOnMount: loadOnMount)
+    processPendingLoad(retryCount: 0)
+  }
+
+  private func processPendingLoad(retryCount: Int) {
+    guard !isDisposed, loadCoordinator.hasPendingLoad else { return }
+
+    guard isReadyToLoadAd else {
+      retryPendingLoad(retryCount: retryCount)
+      return
+    }
+
+    guard let internalAdView = _internalAdView,
+          loadCoordinator.consumePendingLoad(loadOnMount: loadOnMount) != nil else {
+      return
+    }
+
+    pendingLoadWorkItem?.cancel()
+    pendingLoadWorkItem = nil
+    isBindBridge = false
+    bindAssetViews()
+    internalAdView.loadAd()
+  }
+
+  private func retryPendingLoad(retryCount: Int) {
+    guard retryCount < Self.maxAssetLoadRetryCount else {
+      DaroMModule.logger.warning("[native-ad] Asset views were not ready before load request")
+      pendingLoadWorkItem = nil
+      return
+    }
+
+    pendingLoadWorkItem?.cancel()
+    let workItem = DispatchWorkItem { [weak self] in
+      self?.processPendingLoad(retryCount: retryCount + 1)
+    }
+
+    pendingLoadWorkItem = workItem
+    DispatchQueue.main.asyncAfter(deadline: .now() + Self.assetLoadRetryDelay, execute: workItem)
+  }
+
+  private var isReadyToLoadAd: Bool {
+    _internalAdView != nil && hasRegisteredAssetView && registeredAssetViewsReady
+  }
+
+  private var hasRegisteredAssetView: Bool {
+    registeredAssetTags.isEmpty == false
+  }
+
+  private var registeredAssetViewsReady: Bool {
+    let tags = registeredAssetTags
+    guard tags.isEmpty == false else { return false }
+    return tags.allSatisfy { resolveAssetView(tag: $0) != nil }
+  }
+
+  private var registeredAssetTags: [NSNumber] {
+    [
+      titleView,
+      bodyView,
+      callToActionView,
+      iconView,
+      mediaView,
+    ].compactMap { $0 }
+  }
+
+  private func makeAdViews(unitId: String) {
+    self.adUnit = DaroAdUnit(unitId: unitId)
+    let native = DaroMBridgeNativeAdView(
+      unit: adUnit,
+      preferredAdChoicesPosition: preferredAdChoicesPosition
+    )
+    native.delegate = self
+    self._internalAdView = native
+    super.addSubview(native)
+    subviews
+      .filter { $0 !== native }
+      .enumerated()
+      .forEach { index, subview in
+        insertAdSubview(subview, at: index)
+      }
+    pin(native, to: self)
+
+    self._internalAdView?.listener.onAdLoadSuccess = { [weak self] _, adInfo in
+      self?.eventSink.emitAdLoaded(adInfo?.toBody)
+    }
+    self._internalAdView?.listener.onAdLoadFail = { [weak self] error in
+      self?.eventSink.emitAdLoadFailed(error.toBody)
+    }
+    self._internalAdView?.listener.onAdImpression = { [weak self] adInfo in
+      self?.eventSink.emitAdImpressionRecorded(adInfo?.toBody)
+    }
+    self._internalAdView?.listener.onAdClicked = { [weak self] adInfo in
+      self?.eventSink.emitAdClicked(adInfo?.toBody)
+    }
+  }
+
+  private func resolveAssetView(tag: NSNumber?) -> UIView? {
+    guard let tag else { return nil }
+    return assetResolver?.view(forReactTag: tag)
+  }
+
+  private func bindAssetViews() {
+    guard !isDisposed else { return }
+    guard _internalAdView != nil else { return }
+    guard !isBindBridge else { return }
+    isBindBridge = true
+    var bindTitleLabel: UILabel?
+    if let bridgeTitleView = resolveAssetView(tag: titleView) {
+      pin(_internalTitleLabel, to: bridgeTitleView)
+      bindTitleLabel = _internalTitleLabel
+    }
+
+    var bindBodyLabel: UILabel?
+    if let bridgeBodyView = resolveAssetView(tag: bodyView) {
+      pin(_internalBodyLabel, to: bridgeBodyView)
+      bindBodyLabel = _internalBodyLabel
+    }
+
+    var bindCallToActionButton: UIButton?
+    if let bridgeCallToActionView = resolveAssetView(tag: callToActionView) {
+      pin(_internalFakeCTAButton, to: bridgeCallToActionView)
+      bindCallToActionButton = _internalFakeCTAButton
+    }
+
+    var bindIconImageView: UIImageView?
+    if let bridgeIconView = resolveAssetView(tag: iconView) {
+      pin(_internalIconImageView, to: bridgeIconView)
+      bindIconImageView = _internalIconImageView
+    }
+
+    var bindMediaView: UIView?
+    if let bridgeMediaView = resolveAssetView(tag: mediaView) {
+      pin(_internalMediaView, to: bridgeMediaView)
+      bindMediaView = _internalMediaView
+    }
+
+    _internalAdView?.bindViews(
+      titleLabel: bindTitleLabel,
+      bodyLabel: bindBodyLabel,
+      iconImageView: bindIconImageView,
+      mediaContentView: bindMediaView,
+      callToActionButton: bindCallToActionButton
+    )
+  }
+
+  func renderAd(for nativeAd: DaroAdNative) {
+    guard !isDisposed else { return }
+    _internalFakeCTAButton.isUserInteractionEnabled = false
+  }
+
+  override func addSubview(_ view: UIView) {
+    guard !isDisposed else { return }
+    insertAdSubview(view, at: nil)
+  }
+
+  @objc(setAssetSearchRootView:)
+  func setAssetSearchRootView(_ rootView: UIView?) {
+    if let rootView {
+      assetResolver = DaroMDescendantNativeAssetResolver(rootView: rootView)
+    } else {
+      assetResolver = defaultAssetResolver
+    }
+    refreshAssetBindingsAndProcessPendingLoad()
+  }
+
+  @objc(insertMountedSubview:atIndex:)
+  func insertMountedSubview(_ view: UIView, atIndex index: NSNumber) {
+    guard !isDisposed else { return }
+    insertAdSubview(view, at: index.intValue)
+    refreshAssetBindingsAndProcessPendingLoad()
+  }
+
+  @objc(refreshMountedAssetViews)
+  func refreshMountedAssetViews() {
+    guard !isDisposed else { return }
+    refreshAssetBindingsAndProcessPendingLoad()
+  }
+
+  private func insertAdSubview(_ view: UIView, at index: Int?) {
+    guard let targetView = _internalAdView else {
+      let insertionIndex = min(max(index ?? subviews.count, 0), subviews.count)
+      super.insertSubview(view, at: insertionIndex)
+      return
+    }
+
+    targetView.addSubview(view)
+
+    guard let actualSuperview = view.superview else { return }
+    let maxInsertionIndex = max(actualSuperview.subviews.count - 1, 0)
+    let insertionIndex = min(max(index ?? maxInsertionIndex, 0), maxInsertionIndex)
+    if actualSuperview.subviews.firstIndex(where: { $0 === view }) != insertionIndex {
+      actualSuperview.insertSubview(view, at: insertionIndex)
+    }
+  }
+
+  private func refreshAssetBindingsAndProcessPendingLoad() {
+    guard !isDisposed else { return }
+    isBindBridge = false
+    bindAssetViews()
+    requestInitialLoadIfNeeded()
+    processPendingLoad(retryCount: 0)
+  }
+
+  private func hasBridgeViewChange(_ changedProps: [String]) -> Bool {
+    let bridgeProps: Set<String> = [
+      "titleView",
+      "bodyView",
+      "callToActionView",
+      "iconView",
+      "mediaView",
+    ]
+    return changedProps.contains { bridgeProps.contains($0) }
+  }
+
+  private var preferredAdChoicesPosition: DaroAdChoicesPosition {
+    switch adChoicesPosition {
+    case "topLeft":
+      return .topLeft
+    case "topRight":
+      return .topRight
+    case "bottomLeft":
+      return .bottomLeft
+    default:
+      return .bottomRight
+    }
+  }
+
+  private func pin(_ view: UIView, to targetView: UIView) {
+    let identifier = ObjectIdentifier(view)
+    if let constraints = pinnedConstraints[identifier] {
+      NSLayoutConstraint.deactivate(constraints)
+      pinnedConstraints[identifier] = nil
+    }
+
+    view.translatesAutoresizingMaskIntoConstraints = false
+    if view.superview != targetView {
+      view.removeFromSuperview()
+      targetView.addSubview(view)
+    }
+
+    let constraints = [
+      view.topAnchor.constraint(equalTo: targetView.topAnchor),
+      view.bottomAnchor.constraint(equalTo: targetView.bottomAnchor),
+      view.leftAnchor.constraint(equalTo: targetView.leftAnchor),
+      view.rightAnchor.constraint(equalTo: targetView.rightAnchor),
+    ]
+    NSLayoutConstraint.activate(constraints)
+    pinnedConstraints[identifier] = constraints
+  }
+
+  private func disposeNativeAdView() {
+    guard !isDisposed else { return }
+    isDisposed = true
+    resetNativeAdState(clearAssetResolver: true, recreateAssetViews: false)
+  }
+
+  private func resetReactProps() {
+    adUnitId = nil
+    loadOnMount = true
+    titleViewStyleProps = nil
+    titleView = nil
+    bodyViewStyleProps = nil
+    bodyView = nil
+    callToActionViewStyleProps = nil
+    callToActionView = nil
+    iconViewStyleProps = nil
+    iconView = nil
+    mediaViewStyleProps = nil
+    mediaView = nil
+    adChoicesPosition = nil
+    adUnit = DaroAdUnit(unitId: "")
+  }
+
+  private func resetNativeAdState(clearAssetResolver: Bool, recreateAssetViews: Bool) {
+    isBindBridge = false
+    isAdUnitIdSet = false
+    loadCoordinator.reset()
+    pendingLoadWorkItem?.cancel()
+    pendingLoadWorkItem = nil
+    if clearAssetResolver {
+      defaultAssetResolver = nil
+      assetResolver = nil
+    }
+
+    pinnedConstraints.values.forEach { NSLayoutConstraint.deactivate($0) }
+    pinnedConstraints.removeAll()
+
+    _internalAdView?.listener.onAdLoadSuccess = nil
+    _internalAdView?.listener.onAdLoadFail = nil
+    _internalAdView?.listener.onAdImpression = nil
+    _internalAdView?.listener.onAdClicked = nil
+    _internalAdView?.delegate = nil
+    _internalAdView?.clearNativeAd()
+    _internalAdView?.removeFromSuperview()
+    _internalAdView = nil
+
+    _internalTitleLabel.removeFromSuperview()
+    _internalBodyLabel.removeFromSuperview()
+    _internalFakeCTAButton.removeFromSuperview()
+    _internalIconImageView.removeFromSuperview()
+    _internalMediaView.removeFromSuperview()
+
+    _internalTitleLabel.text = nil
+    _internalTitleLabel.attributedText = nil
+    _internalBodyLabel.text = nil
+    _internalBodyLabel.attributedText = nil
+    _internalFakeCTAButton.setTitle(nil, for: .normal)
+    _internalFakeCTAButton.setAttributedTitle(nil, for: .normal)
+    _internalIconImageView.image = nil
+    _internalMediaView.subviews.forEach { $0.removeFromSuperview() }
+
+    guard recreateAssetViews else { return }
+
+    _internalTitleLabel = Self.makeTitleLabel()
+    _internalBodyLabel = Self.makeBodyLabel()
+    _internalMediaView = Self.makeMediaView()
+    _internalIconImageView = Self.makeIconImageView()
+    _internalFakeCTAButton = Self.makeFakeCTAButton()
+  }
+}
+
+protocol DaroMNativeAdRenderDelegate: AnyObject {
+  func renderAd(for nativeAd: DaroAdNative)
+}
+
+class DaroMBridgeNativeAdView: DaroAdNativeView {
+  weak var delegate: DaroMNativeAdRenderDelegate?
+
+  override func renderAd(for nativeAd: DaroAdNative, loader: any AdNativeLoadable) {
+    super.renderAd(for: nativeAd, loader: loader)
+    self.delegate?.renderAd(for: nativeAd)
+  }
+}
+
+@propertyWrapper
+private struct Atomic<Value> {
+  private var value: Value
+  private let lock = NSLock()
+
+  init(wrappedValue value: Value) {
+    self.value = value
+  }
+
+  var wrappedValue: Value {
+    get {
+      lock.lock()
+      defer { lock.unlock() }
+      return value
+    }
+    set {
+      lock.lock()
+      value = newValue
+      lock.unlock()
+    }
+  }
+}

package/ios/Shared/DaroMNativeAssetResolver.swift

@@ -0,0 +1,53 @@
+import React
+import UIKit
+
+protocol DaroMNativeAssetResolving: AnyObject {
+  func view(forReactTag tag: NSNumber) -> UIView?
+}
+
+final class DaroMBridgeNativeAssetResolver: DaroMNativeAssetResolving {
+  private weak var bridge: RCTBridge?
+
+  init(bridge: RCTBridge?) {
+    self.bridge = bridge
+  }
+
+  func view(forReactTag tag: NSNumber) -> UIView? {
+    bridge?.uiManager.view(forReactTag: tag)
+  }
+}
+
+final class DaroMDescendantNativeAssetResolver: DaroMNativeAssetResolving {
+  private weak var rootView: UIView?
+
+  init(rootView: UIView) {
+    self.rootView = rootView
+  }
+
+  func view(forReactTag tag: NSNumber) -> UIView? {
+    rootView?.daroMFindReactSubview(tag: tag)
+  }
+}
+
+private extension UIView {
+  func daroMFindReactSubview(tag: NSNumber) -> UIView? {
+    if self.tag == tag.intValue {
+      return self
+    }
+
+    let reactTagSelector = Selector(("reactTag"))
+    if responds(to: reactTagSelector),
+       let reactTag = value(forKey: "reactTag") as? NSNumber,
+       reactTag == tag {
+      return self
+    }
+
+    for subview in subviews {
+      if let found = subview.daroMFindReactSubview(tag: tag) {
+        return found
+      }
+    }
+
+    return nil
+  }
+}

package/ios/mediation/admob/DaroMediationTypes.swift

@@ -6,6 +6,7 @@ internal typealias DaroAdFormat = Daro.DaroAdFormat
 internal typealias DaroAdInfo = Daro.DaroAdInfo
 internal typealias DaroAdNative = Daro.DaroAdNative
 internal typealias DaroAdNativeView = Daro.DaroAdNativeView
+internal typealias DaroAdChoicesPosition = Daro.DaroAdChoicesPosition
 internal typealias DaroAdUnit = Daro.DaroAdUnit
 internal typealias DaroAds = Daro.DaroAds
 internal typealias DaroAppOpenAd = Daro.DaroAppOpenAd