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

package/android/src/oldarch/com/facebook/react/viewmanagers/RNGoogleMobileAdsNativeViewManagerDelegate.java

@@ -0,0 +1,36 @@
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class RNGoogleMobileAdsNativeViewManagerDelegate<
+        T extends View,
+        U extends
+            BaseViewManager<T, ? extends LayoutShadowNode>
+                & RNGoogleMobileAdsNativeViewManagerInterface<T>>
+    extends BaseViewManagerDelegate<T, U> {
+  public RNGoogleMobileAdsNativeViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+
+  @Override
+  public void setProperty(@NonNull T view, String propName, @Nullable Object value) {
+    assert propName != null;
+    if (propName.equals("responseId")) {
+      mViewManager.setResponseId(view, value == null ? null : (String) value);
+    }
+  }
+
+  @Override
+  public void receiveCommand(@NonNull T view, String commandName, ReadableArray args) {
+    assert commandName != null;
+    if (commandName.equals("registerAsset")) {
+      mViewManager.registerAsset(view, args.getString(0), args.getInt(1));
+    }
+  }
+}

package/android/src/oldarch/com/facebook/react/viewmanagers/RNGoogleMobileAdsNativeViewManagerInterface.java

@@ -0,0 +1,10 @@
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+
+public interface RNGoogleMobileAdsNativeViewManagerInterface<T extends View> {
+  void setResponseId(T view, @Nullable String responseId);
+
+  void registerAsset(T view, String assetKey, int reactTag);
+}

package/android/src/oldarch/io/invertase/googlemobileads/NativeGoogleMobileAdsNativeModuleSpec.kt

@@ -0,0 +1,18 @@
+package io.invertase.googlemobileads
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+abstract class NativeGoogleMobileAdsNativeModuleSpec(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+  abstract fun load(adUnitId: String, requestOptions: ReadableMap, promise: Promise)
+  abstract fun destroy(responseId: String)
+
+  fun emitOnAdEvent(params: ReadableMap) {
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("RNGMANativeAdEvent", params)
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build');

package/babel.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  env: {
+    test: {
+      presets: ['module:@react-native/babel-preset'],
+    },
+  },
+  plugins: [['@babel/plugin-proposal-private-property-in-object', { loose: true }]],
+};

package/docs/ad-inspector.mdx

@@ -0,0 +1,47 @@
+# Debug-menu
+
+The debug menu is a tool that allows you to test and debug your app's ad experience. It can be used to:
+
+```js
+await mobileAds().openDebugMenu(AD_UNIT_ID);
+````
+
+# Ad Inspector
+
+Ad inspector is an in-app overlay that enables authorized devices to perform real-time analysis of test ad requests directly within a mobile app.
+
+Using ad inspector, you can:
+
+- Inspect your ad units
+- Check whether your ads are filling as expected
+- Identify errors and view details about how to resolve them
+- View the details for each Open Bidding ad network per request
+- View the mediation details for each ad network per request
+- Test individual third-party Open Bidding or waterfall mediation ad sources
+- Verify that you've correctly configured each ad unit for Open Bidding and waterfall mediation
+
+To see more information about ad inspector, see the [official documentation](https://developers.google.com/admob/android/ad-inspector).
+
+## Launch ad inspector
+
+Ad inspector can be launched from anywhere in your app. There are three different ways to launch ad inspector.
+
+1. Use the launch button from the debug menu.
+2. Use the gesture that you selected in the ad inspector settings.
+3. Programmatically using the provided API.
+
+More information about laucnhing ad inspector is available in [official documentation](https://developers.google.com/admob/android/ad-inspector#launch_ad_inspector).
+
+### Launch programmatically
+
+Ad inspector can be launched programmatically with the `openAdInspector` method in the `MobileAds` instance.
+
+```js
+try {
+  await MobileAds().openAdInspector();
+  // The promise will resolve when the inspector is closed.
+} catch (error) {
+  // The promise will reject if ad inspector is closed due to an error.
+  console.log(error);
+}
+```

package/docs/common-reasons-for-ads-not-showing.mdx

@@ -0,0 +1,111 @@
+# Common reasons for ads not showing
+
+Use the following guide to understand common reasons why apps show few or no ads.
+
+## Did you recently create your AdMob account?
+
+Your account must be approved before ad requests will succeed.
+When you first sign up for AdMob, your account is reviewed before it’s approved.
+This typically takes less than 24 hours, but in rare cases can take up to 2 weeks.
+You'll be notified of approval or rejection via email after review.
+
+## Is your app or ad unit new?
+
+New apps and ad units take some time to activate.
+Here are common reasons you may not see live impressions immediately:
+
+- It usually takes at least an hour after you create an app or ad unit
+- Sometimes it can take a few days for ads to appear in new apps or ad units
+- New iOS apps will not show Google ads until they’re listed in the Apple App Store
+
+## Test ads not showing up
+
+If you set up an app-ads.txt file for your app, you need to also include this line in your app-ads.txt file in order to load ads using the demo ad units:
+`google.com, pub-3940256099942544, DIRECT, f08c47fec0942fa0`
+
+- Set up app-ads.txt [iOS](https://developers.google.com/admob/ios/app-ads), [Android](https://developers.google.com/admob/android/app-ads)
+- Enabling test ads [iOS](https://developers.google.com/admob/ios/test-ads), [Android](https://developers.google.com/admob/android/test-ads)
+
+Alternatively, you can enable test devices and use your own ad unit IDs instead.
+
+### Check Your ApplicationId
+
+If you initiated your project with `react-native init`, the auto-generated `applicationId` might not fulfill the required structure or uniqueness needed for AdMob integration. This can lead to issues where the request was succesfull but no ads are shown. Here are common reasons and fixes related to `applicationId` issues:
+
+- **Non-unique ApplicationId**: The default `applicationId` may clash with existing apps, especially if you haven't customized it. AdMob requires a unique identifier for each app to correctly manage ad requests and revenue.
+
+- **Improperly Structured ApplicationId**: The `applicationId` should generally follow Java package name conventions, such as `com.companyname.appname`. It must start with a letter, and can only include letters (a-z, A-Z), numbers (0-9), and underscores (_). 
+
+Google documentation: [Configure the app module](https://developer.android.com/build/configure-app-module?hl=de)
+
+**Important**:  If you change the application ID of an already published app, Google Play Store treats the upload as a completely different app!
+
+
+### Enable test devices
+
+If you want to do more rigorous testing with production-looking ads, configure your device as a test device and use your own ad unit IDs that you've created in the AdMob UI.
+Test devices can either be added in the AdMob UI or programmatically using the Google Mobile Ads SDK.
+
+Follow the steps below to add your device as a test device.
+
+#### Add your test device in the AdMob UI
+
+For a simple, non-programmatic way to add a test device and test new or existing app builds, use the AdMob UI.
+[Learn how](https://support.google.com/admob/answer/9691433).
+
+#### Add your test device programmatically
+
+If you want to test ads in your app as you're developing, follow the steps below to programmatically register your test device.
+
+1. Load your ads-integrated app and make an ad request.
+
+2. For **iOS** follow step 3, for **Android** skip to step 4.
+
+3. Check the console for a message that looks like this:
+
+   ```
+   GADMobileAds.sharedInstance.requestConfiguration.testDeviceIdentifiers =
+     @[ @"2077ef9a63d2b398840261c8221a0c9b"  ]; // Sample device ID
+   ```
+
+   Copy your test device ID to your clipboard.
+
+4. Check the logcat output for a message that looks like the one below, which shows you your device ID and how to add it as a test device:
+
+   ```
+   I/Ads: Use RequestConfiguration.Builder.setTestDeviceIds(Arrays.asList("33BE2250B43518CCDA7DE426D04EE231"))
+   to get test ads on this device."
+   ```
+
+   Copy your test device ID to your clipboard.
+
+5. Modify your code to set the test device ID through testDeviceIdentifiers
+
+   ```js
+   import mobileAds from 'react-native-google-mobile-ads';
+
+   mobileAds()
+     .setRequestConfiguration({
+       // An array of test device IDs to add to the allow list.
+       testDeviceIdentifiers: ['2077ef9a63d2b398840261c8221a0c9b', 'EMULATOR'],
+     })
+     .then(() => {
+       // Request config successfully set!
+     });
+   ```
+
+6. Re-run your app. If the ad is a Google ad, you'll see a Test Ad label centered at the top of the ad.
+   Ads with this Test Ad label are safe to click. Requests, impressions, and clicks on test ads will not show up in your account's reports.
+
+## Emulator vs real device
+
+In some cases ads won't show up on an emulator but will show up while testing on a real device.
+
+## Are you using a private DNS provider?
+
+Some private DNS providers can block ads from displaying. If your device or emulator is using a private DNS, switch it to Automatic in the settings to ensure it is not blocking ads.
+
+## Extra links
+
+- Mobile Ads SDK [iOS](https://developers.google.com/admob/ios/quick-start), [Android](https://developers.google.com/admob/android/quick-start)
+- [Common reasons for ads not showing](https://support.google.com/admob/answer/9469204)

package/docs/displaying-ads-hook.mdx

@@ -0,0 +1,103 @@
+# Hooks
+
+The AdMob package provides hooks to help you to display ads in a functional component with tiny code. The supported ad formats are full-screen ads: App open, Interstitial, Rewarded, and Rewarded Interstitial.
+
+## Load an ad
+
+You can create a new ad by adding a corresponding ad type's hook to your component.
+
+The first argument of the hook is the "Ad Unit ID".
+For testing, we can use a Test ID, however for production the ID from the
+Google AdMob dashboard under "Ad units" should be used:
+
+```tsx {4-8}
+import { useInterstitialAd, TestIds } from 'react-native-google-mobile-ads';
+
+export default function App() {
+  const interstitialAd = useInterstitialAd(TestIds.Interstitial);
+
+  return <View>{/* ... */}</View>;
+}
+```
+
+<Info>
+The `adUnitid` parameter can also be used to manage creation and destruction of an ad instance.
+If `adUnitid` is set or changed, new ad instance will be created and previous ad instance will be destroyed if exists.
+If `adUnitid` is set to `null`, no ad instance will be created and previous ad instance will be destroyed if exists.
+</Info>
+
+The second argument is an additional optional request options object to be sent whilst loading an advert, such as keywords & location.
+Setting additional request options helps AdMob choose better tailored ads from the network.
+View the [`RequestOptions`](https://github.com/invertase/react-native-google-mobile-ads/blob/main/src/types/RequestOptions.ts) source code to see the full range of options available.
+
+## Show the ad
+
+The hook returns several states and functions to control ad.
+
+```tsx
+import { useInterstitialAd, TestIds } from 'react-native-google-mobile-ads';
+
+export default function App({ navigation }) {
+  const { isLoaded, isClosed, load, show } = useInterstitialAd(TestIds.INTERSTITIAL);
+
+  useEffect(() => {
+    // Start loading the interstitial straight away
+    load();
+  }, [load]);
+
+  useEffect(() => {
+    if (isClosed) {
+      // Action after the ad is closed
+      navigation.navigate('NextScreen');
+    }
+  }, [isClosed, navigation]);
+
+  return (
+    <View>
+      <Button
+        title="Navigate to next screen"
+        onPress={() => {
+          if (isLoaded) {
+            show();
+          } else {
+            // No advert ready to show yet
+            navigation.navigate('NextScreen');
+          }
+        }}
+      />
+    </View>
+  );
+}
+```
+
+The code above immediately starts to load a new advert from the network (via `load()`).
+When user presses button, it checks if the ad is loaded via `isLoaded` value,
+then the `show` function is called and the advert is shown over-the-top of your application.
+Otherwise, if the ad is not loaded, the `navigation.navigate` method is called to navigate to the next screen without showing the ad.
+After the ad is closed, the `isClosed` value is set to `true` and the `navigation.navigate` method is called to navigate to the next screen.
+
+If needed, you can reuse the existing hook to load more adverts and show them when required. The states are initialized when the `load` function is called.
+
+Return values of the hook are:
+
+| Name           | Type                               | Description                                                                                                        |
+| :------------- | :--------------------------------- | :----------------------------------------------------------------------------------------------------------------- |
+| isLoaded       | boolean                            | Whether the ad is loaded and ready to to be shown to the user. Automatically set to false when the ad was shown.   |
+| isOpened       | boolean                            | Whether the ad is opened. The value is remained `true` even after the ad is closed unless **new ad is requested**. |
+| isClicked      | boolean                            | Whether the ad is clicked.                                                                                         |
+| isClosed       | boolean                            | Whether your ad is dismissed.                                                                                      |
+| isShowing      | boolean                            | Whether your ad is showing. The value is equal with `isOpened && !isClosed`.                                       |
+| error          | Error \| undefined                 | `Error` object throwed during ad load.                                                                             |
+| revenue        | PaidEvent                          | See [Impression-level ad revenue] |
+| reward         | [RewardedAdReward](#) \| undefined | Loaded reward item of the Rewarded Ad. Available only in RewardedAd.                                               |
+| isEarnedReward | boolean                            | Whether the user earned the reward by Rewarded Ad.                                                                 |
+| load           | Function                           | Start loading the advert with the provided RequestOptions.                                                         |
+| show           | Function                           | Show the loaded advert to the user.                                                                                |
+
+<Info>
+Note that `isOpened` value remains `true` even after the ad is closed.
+The value changes to `false` when ad is initialized via calling `load()`.
+To determine whether the ad is currently showing, use `isShowing` value.
+</Info>
+
+[Impression-level ad revenue]: /impression-level-ad-revenue