@javascriptcommon/react-native-google-mobile-ads 16.3.3

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsMediaViewManager.java

@@ -0,0 +1,79 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Migrated to the GMA Next-Gen SDK (Android). Wraps the Next-Gen MediaView and binds the media
+// content of the loaded NativeAd (looked up by responseId in the shared registry).
+
+import android.widget.ImageView;
+import androidx.annotation.Nullable;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.google.android.libraries.ads.mobile.sdk.nativead.MediaView;
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAd;
+import javax.annotation.Nonnull;
+
+public class ReactNativeGoogleMobileAdsMediaViewManager extends SimpleViewManager<MediaView> {
+  private static final String REACT_CLASS = "RNGoogleMobileAdsMediaView";
+
+  @Nonnull
+  @Override
+  public String getName() {
+    return REACT_CLASS;
+  }
+
+  @Nonnull
+  @Override
+  public MediaView createViewInstance(@Nonnull ThemedReactContext themedReactContext) {
+    return new MediaView(themedReactContext);
+  }
+
+  @ReactProp(name = "responseId")
+  public void setResponseId(MediaView view, @Nullable String responseId) {
+    if (responseId == null) {
+      return;
+    }
+    NativeAd nativeAd = ReactNativeGoogleMobileAdsNativeModule.getNativeAds().get(responseId);
+    if (nativeAd != null && nativeAd.getMediaContent() != null) {
+      view.setMediaContent(nativeAd.getMediaContent());
+    }
+  }
+
+  @ReactProp(name = "resizeMode")
+  public void setResizeMode(MediaView view, @Nullable String resizeMode) {
+    view.setImageScaleType(scaleType(resizeMode));
+  }
+
+  private ImageView.ScaleType scaleType(@Nullable String resizeMode) {
+    if (resizeMode == null) {
+      return ImageView.ScaleType.FIT_CENTER;
+    }
+    switch (resizeMode) {
+      case "cover":
+        return ImageView.ScaleType.CENTER_CROP;
+      case "stretch":
+        return ImageView.ScaleType.FIT_XY;
+      case "center":
+        return ImageView.ScaleType.CENTER;
+      case "contain":
+      default:
+        return ImageView.ScaleType.FIT_CENTER;
+    }
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsModule.kt

@@ -0,0 +1,178 @@
+package io.invertase.googlemobileads
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Migrated to the GMA Next-Gen SDK (Android). The Next-Gen SDK requires the AdMob App ID to be
+// passed explicitly to InitializationConfig (it is no longer read automatically from the manifest),
+// so we read it from the manifest meta-data ourselves and forward it. iOS is unchanged.
+
+import android.content.pm.PackageManager
+import com.facebook.react.bridge.*
+import com.google.android.libraries.ads.mobile.sdk.MobileAds
+import com.google.android.libraries.ads.mobile.sdk.common.OnAdInspectorClosedListener
+import com.google.android.libraries.ads.mobile.sdk.common.RequestConfiguration
+import com.google.android.libraries.ads.mobile.sdk.initialization.InitializationConfig
+import com.google.android.libraries.ads.mobile.sdk.initialization.OnAdapterInitializationCompleteListener
+
+class ReactNativeGoogleMobileAdsModule(
+  reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName() = NAME
+
+  private fun getAppIdFromManifest(): String? {
+    return try {
+      val context = reactApplicationContext
+      val ai =
+        context.packageManager.getApplicationInfo(
+          context.packageName, PackageManager.GET_META_DATA)
+      ai.metaData?.getString("com.google.android.gms.ads.APPLICATION_ID")
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  private fun buildRequestConfiguration(
+    requestConfiguration: ReadableMap
+  ): RequestConfiguration {
+    val builder = RequestConfiguration.Builder()
+
+    if (requestConfiguration.hasKey("testDeviceIdentifiers")) {
+      val devices =
+        checkNotNull(requestConfiguration.getArray("testDeviceIdentifiers")).toArrayList()
+      // Next-Gen auto-registers emulators as test devices; drop the legacy "EMULATOR" sentinel.
+      val testDeviceIds = devices.map { it as String }.filter { it != "EMULATOR" }
+      builder.setTestDeviceIds(testDeviceIds)
+    }
+
+    if (requestConfiguration.hasKey("maxAdContentRating")) {
+      when (requestConfiguration.getString("maxAdContentRating")) {
+        "G" ->
+          builder.setMaxAdContentRating(
+            RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_G)
+        "PG" ->
+          builder.setMaxAdContentRating(
+            RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_PG)
+        "T" ->
+          builder.setMaxAdContentRating(
+            RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_T)
+        "MA" ->
+          builder.setMaxAdContentRating(
+            RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_MA)
+      }
+    }
+
+    if (requestConfiguration.hasKey("tagForChildDirectedTreatment")) {
+      builder.setTagForChildDirectedTreatment(
+        if (requestConfiguration.getBoolean("tagForChildDirectedTreatment"))
+          RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE
+        else
+          RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE)
+    } else {
+      builder.setTagForChildDirectedTreatment(
+        RequestConfiguration.TagForChildDirectedTreatment
+          .TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED)
+    }
+
+    if (requestConfiguration.hasKey("tagForUnderAgeOfConsent")) {
+      builder.setTagForUnderAgeOfConsent(
+        if (requestConfiguration.getBoolean("tagForUnderAgeOfConsent"))
+          RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE
+        else RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE)
+    } else {
+      builder.setTagForUnderAgeOfConsent(
+        RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED)
+    }
+
+    return builder.build()
+  }
+
+  @ReactMethod
+  fun initialize(promise: Promise) {
+    val appId = getAppIdFromManifest()
+    if (appId == null) {
+      promise.reject(
+        "null-app-id",
+        "GMA Next-Gen SDK could not find the AdMob App ID. Set" +
+          " com.google.android.gms.ads.APPLICATION_ID in AndroidManifest.xml.")
+      return
+    }
+    val config = InitializationConfig.Builder(appId).build()
+    MobileAds.initialize(
+      reactApplicationContext,
+      config,
+      OnAdapterInitializationCompleteListener { initializationStatus ->
+        val result = Arguments.createArray()
+        for ((key, value) in initializationStatus.adapterStatusMap) {
+          val info = Arguments.createMap()
+          info.putString("name", key)
+          info.putInt("state", value.initializationState.ordinal)
+          info.putString("description", value.description)
+          result.pushMap(info)
+        }
+        promise.resolve(result)
+      })
+  }
+
+  @ReactMethod
+  fun setRequestConfiguration(requestConfiguration: ReadableMap, promise: Promise) {
+    MobileAds.setRequestConfiguration(buildRequestConfiguration(requestConfiguration))
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun openAdInspector(promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject(
+        "null-activity", "Ad Inspector attempted to open but the current Activity was null.")
+      return
+    }
+    activity.runOnUiThread {
+      MobileAds.openAdInspector(
+        OnAdInspectorClosedListener { adInspectorError ->
+          if (adInspectorError != null) {
+            promise.reject(adInspectorError.code.name, adInspectorError.message)
+          } else {
+            promise.resolve(null)
+          }
+        })
+    }
+  }
+
+  @ReactMethod
+  fun openDebugMenu(adUnit: String) {
+    reactApplicationContext.currentActivity?.let { activity ->
+      activity.runOnUiThread { MobileAds.openDebugMenu(activity, adUnit) }
+    }
+  }
+
+  @ReactMethod
+  fun setAppVolume(volume: Float) {
+    MobileAds.setUserControlledAppVolume(volume)
+  }
+
+  @ReactMethod
+  fun setAppMuted(muted: Boolean) {
+    MobileAds.setUserMutedApp(muted)
+  }
+
+  companion object {
+    const val NAME = "RNGoogleMobileAdsModule"
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsNativeAdViewManager.java

@@ -0,0 +1,164 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Migrated to the GMA Next-Gen SDK (Android). Wraps the Next-Gen NativeAdView container, binds the
+// asset child views supplied by JS via the registerAsset command, and registers the loaded NativeAd
+// (looked up by responseId in the shared registry) together with any MediaView descendant.
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.google.android.libraries.ads.mobile.sdk.nativead.MediaView;
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAd;
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdView;
+import java.util.WeakHashMap;
+import javax.annotation.Nonnull;
+
+public class ReactNativeGoogleMobileAdsNativeAdViewManager
+    extends SimpleViewManager<NativeAdView> {
+  private static final String REACT_CLASS = "RNGoogleMobileAdsNativeView";
+  private static final String COMMAND_REGISTER_ASSET = "registerAsset";
+
+  private final WeakHashMap<NativeAdView, String> responseIds = new WeakHashMap<>();
+
+  @Nonnull
+  @Override
+  public String getName() {
+    return REACT_CLASS;
+  }
+
+  @Nonnull
+  @Override
+  public NativeAdView createViewInstance(@Nonnull ThemedReactContext themedReactContext) {
+    return new NativeAdView(themedReactContext);
+  }
+
+  @ReactProp(name = "responseId")
+  public void setResponseId(NativeAdView view, @Nullable String responseId) {
+    responseIds.put(view, responseId);
+    registerNativeAd(view);
+  }
+
+  @Override
+  public void receiveCommand(
+      @NonNull NativeAdView view, String commandId, @Nullable ReadableArray args) {
+    if (COMMAND_REGISTER_ASSET.equals(commandId) && args != null) {
+      String assetKey = args.getString(0);
+      int reactTag = args.getInt(1);
+      registerAsset(view, assetKey, reactTag);
+    }
+  }
+
+  private void registerAsset(NativeAdView view, String assetKey, int reactTag) {
+    View assetView = findViewByReactTag(view, reactTag);
+    if (assetView == null || assetKey == null) {
+      return;
+    }
+    switch (assetKey) {
+      case "headline":
+        view.setHeadlineView(assetView);
+        break;
+      case "body":
+        view.setBodyView(assetView);
+        break;
+      case "callToAction":
+        view.setCallToActionView(assetView);
+        break;
+      case "advertiser":
+        view.setAdvertiserView(assetView);
+        break;
+      case "price":
+        view.setPriceView(assetView);
+        break;
+      case "store":
+        view.setStoreView(assetView);
+        break;
+      case "starRating":
+        view.setStarRatingView(assetView);
+        break;
+      case "icon":
+        view.setIconView(assetView);
+        break;
+      default:
+        // "image" / "media" assets are presented through the MediaView descendant.
+        break;
+    }
+    registerNativeAd(view);
+  }
+
+  /** Bind the loaded NativeAd to the container once we have a responseId for it. */
+  private void registerNativeAd(NativeAdView view) {
+    String responseId = responseIds.get(view);
+    if (responseId == null) {
+      return;
+    }
+    NativeAd nativeAd = ReactNativeGoogleMobileAdsNativeModule.getNativeAds().get(responseId);
+    if (nativeAd == null) {
+      return;
+    }
+    MediaView mediaView = findMediaView(view);
+    view.registerNativeAd(nativeAd, mediaView);
+  }
+
+  @Nullable
+  private View findViewByReactTag(View root, int reactTag) {
+    if (root.getId() == reactTag) {
+      return root;
+    }
+    if (root instanceof ViewGroup) {
+      ViewGroup group = (ViewGroup) root;
+      for (int i = 0; i < group.getChildCount(); i++) {
+        View found = findViewByReactTag(group.getChildAt(i), reactTag);
+        if (found != null) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  private MediaView findMediaView(View root) {
+    if (root instanceof MediaView) {
+      return (MediaView) root;
+    }
+    if (root instanceof ViewGroup) {
+      ViewGroup group = (ViewGroup) root;
+      for (int i = 0; i < group.getChildCount(); i++) {
+        MediaView found = findMediaView(group.getChildAt(i));
+        if (found != null) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public void onDropViewInstance(@NonNull NativeAdView view) {
+    responseIds.remove(view);
+    view.destroy();
+    super.onDropViewInstance(view);
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsNativeModule.kt

@@ -0,0 +1,172 @@
+package io.invertase.googlemobileads
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Migrated to the GMA Next-Gen SDK (Android). Loads native ads via NativeAdLoader, serializes the
+// asset payload to JS, and keeps the loaded NativeAd in a shared registry so the NativeAdView /
+// MediaView managers can bind it by responseId. Events are emitted on the RNGMANativeAdEvent
+// device-event channel that the JS NativeAd subscribes to on Android.
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.libraries.ads.mobile.sdk.common.AdValue
+import com.google.android.libraries.ads.mobile.sdk.common.Image
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError
+import com.google.android.libraries.ads.mobile.sdk.nativead.MediaContent
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAd
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdEventCallback
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdLoader
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdLoaderCallback
+import com.google.android.libraries.ads.mobile.sdk.nativead.NativeAdRequest
+import io.invertase.googlemobileads.common.ReactNativeModule
+import java.util.concurrent.ConcurrentHashMap
+
+class ReactNativeGoogleMobileAdsNativeModule(reactContext: ReactApplicationContext?) :
+  ReactNativeModule(reactContext, NAME) {
+
+  @ReactMethod
+  fun load(adUnitId: String, requestOptions: ReadableMap, promise: Promise) {
+    val builder = NativeAdRequest.Builder(adUnitId, listOf(NativeAd.NativeAdType.NATIVE))
+    ReactNativeGoogleMobileAdsCommon.applyRequestOptions(builder, requestOptions)
+    val request = builder.build()
+
+    val activity = reactApplicationContext.currentActivity
+    val runnable = Runnable {
+      NativeAdLoader.load(
+        request,
+        object : NativeAdLoaderCallback {
+          override fun onNativeAdLoaded(nativeAd: NativeAd) {
+            val responseId = nativeAd.responseInfo?.responseId ?: ""
+            nativeAds[responseId] = nativeAd
+            attachEventCallback(nativeAd, responseId)
+            promise.resolve(serializeNativeAd(nativeAd, responseId))
+          }
+
+          override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+            val codeAndMessage =
+              ReactNativeGoogleMobileAdsCommon.getCodeAndMessageFromAdError(loadAdError)
+            rejectPromiseWithCodeAndMessage(promise, codeAndMessage[0], codeAndMessage[1])
+          }
+        })
+    }
+    if (activity != null) activity.runOnUiThread(runnable) else runnable.run()
+  }
+
+  @ReactMethod
+  fun destroy(responseId: String) {
+    nativeAds.remove(responseId)?.destroy()
+  }
+
+  // NativeEventEmitter bookkeeping (no-ops on Android; required by the TurboModule surface).
+  @ReactMethod fun addListener(eventName: String) {}
+
+  @ReactMethod fun removeListeners(count: Double) {}
+
+  private fun attachEventCallback(nativeAd: NativeAd, responseId: String) {
+    nativeAd.adEventCallback =
+      object : NativeAdEventCallback {
+        override fun onAdImpression() = emit(responseId, "impression", null)
+
+        override fun onAdClicked() = emit(responseId, "clicked", null)
+
+        override fun onAdShowedFullScreenContent() = emit(responseId, "opened", null)
+
+        override fun onAdDismissedFullScreenContent() = emit(responseId, "closed", null)
+
+        override fun onAdPaid(adValue: AdValue) {
+          val payload = Arguments.createMap()
+          payload.putDouble("value", 1e-6 * adValue.valueMicros)
+          payload.putDouble("precision", adValue.precisionType.ordinal.toDouble())
+          payload.putString("currencyCode", adValue.currencyCode)
+          emit(responseId, "paid", payload)
+        }
+      }
+  }
+
+  private fun emit(responseId: String, type: String, extra: WritableMap?) {
+    val event = Arguments.createMap()
+    event.putString("responseId", responseId)
+    event.putString("type", type)
+    if (extra != null) event.merge(extra)
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("RNGMANativeAdEvent", event)
+  }
+
+  private fun serializeNativeAd(nativeAd: NativeAd, responseId: String): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("responseId", responseId)
+    map.putString("headline", nativeAd.headline)
+    map.putString("body", nativeAd.body)
+    map.putString("callToAction", nativeAd.callToAction)
+    putStringOrNull(map, "advertiser", nativeAd.advertiser)
+    putStringOrNull(map, "price", nativeAd.price)
+    putStringOrNull(map, "store", nativeAd.store)
+
+    val starRating = nativeAd.starRating
+    if (starRating != null) map.putDouble("starRating", starRating) else map.putNull("starRating")
+
+    map.putMap("icon", serializeImage(nativeAd.icon))
+
+    val mainImage = serializeImage(nativeAd.image)
+    if (mainImage != null) {
+      val images = Arguments.createArray()
+      images.pushMap(mainImage)
+      map.putArray("images", images)
+    } else {
+      map.putNull("images")
+    }
+
+    map.putMap("mediaContent", serializeMediaContent(nativeAd.mediaContent))
+    map.putNull("extras")
+    return map
+  }
+
+  private fun serializeImage(image: Image?): WritableMap? {
+    if (image == null) return null
+    val uri = image.uri ?: return null
+    val map = Arguments.createMap()
+    map.putString("url", uri.toString())
+    map.putDouble("scale", image.scale)
+    return map
+  }
+
+  private fun serializeMediaContent(mediaContent: MediaContent?): WritableMap {
+    val map = Arguments.createMap()
+    map.putDouble("aspectRatio", (mediaContent?.aspectRatio ?: 1.0f).toDouble())
+    map.putBoolean("hasVideoContent", mediaContent?.hasVideoContent ?: false)
+    map.putDouble("duration", (mediaContent?.duration ?: 0.0f).toDouble())
+    return map
+  }
+
+  private fun putStringOrNull(map: WritableMap, key: String, value: String?) {
+    if (value != null) map.putString(key, value) else map.putNull(key)
+  }
+
+  companion object {
+    const val NAME = "RNGoogleMobileAdsNativeModule"
+
+    /** Shared registry of loaded native ads, keyed by responseId; read by the view managers. */
+    @JvmStatic val nativeAds = ConcurrentHashMap<String, NativeAd>()
+  }
+}