react-native-google-mobile-ads 4.1.0

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

@@ -0,0 +1,177 @@
+package io.invertase.googlemobileads;
+
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.getCodeAndMessageFromAdError;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.sendAdEvent;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLOSED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_OPENED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_REWARDED_EARNED_REWARD;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_REWARDED_LOADED;
+
+import android.app.Activity;
+import android.util.SparseArray;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.FullScreenContentCallback;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.OnUserEarnedRewardListener;
+import com.google.android.gms.ads.rewarded.RewardItem;
+import com.google.android.gms.ads.rewarded.RewardedAd;
+import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback;
+import com.google.android.gms.ads.rewarded.ServerSideVerificationOptions;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+
+public class ReactNativeGoogleMobileAdsRewardedModule extends ReactNativeModule {
+  private static final String SERVICE = "RNGoogleMobileAdsRewardedModule";
+  private static SparseArray<RewardedAd> rewardedAdArray = new SparseArray<>();
+
+  public ReactNativeGoogleMobileAdsRewardedModule(ReactApplicationContext reactContext) {
+    super(reactContext, SERVICE);
+  }
+
+  private void sendRewardedEvent(
+      String type,
+      int requestId,
+      String adUnitId,
+      @Nullable WritableMap error,
+      @Nullable WritableMap data) {
+    sendAdEvent(
+        ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_REWARDED,
+        requestId,
+        type,
+        adUnitId,
+        error,
+        data);
+  }
+
+  @ReactMethod
+  public void rewardedLoad(int requestId, String adUnitId, ReadableMap adRequestOptions) {
+    Activity activity = getCurrentActivity();
+    if (activity == null) {
+      WritableMap error = Arguments.createMap();
+      error.putString("code", "null-activity");
+      error.putString(
+          "message", "Rewarded ad attempted to load but the current Activity was null.");
+      sendRewardedEvent(GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error, null);
+      return;
+    }
+    activity.runOnUiThread(
+        () -> {
+          AdRequest adRequest = new AdRequest.Builder().build();
+
+          RewardedAdLoadCallback rewardedAdLoadCallback =
+              new RewardedAdLoadCallback() {
+                @Override
+                public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                  WritableMap error = Arguments.createMap();
+                  String[] codeAndMessage = getCodeAndMessageFromAdError(loadAdError);
+                  error.putString("code", codeAndMessage[0]);
+                  error.putString("message", codeAndMessage[1]);
+                  sendRewardedEvent(
+                      GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error, null);
+                }
+
+                @Override
+                public void onAdLoaded(@NonNull RewardedAd rewardedAd) {
+                  RewardItem rewardItem = rewardedAd.getRewardItem();
+                  WritableMap data = Arguments.createMap();
+                  data.putString("type", rewardItem.getType());
+                  data.putInt("amount", rewardItem.getAmount());
+
+                  if (adRequestOptions.hasKey("serverSideVerificationOptions")) {
+                    ReadableMap serverSideVerificationOptions =
+                        adRequestOptions.getMap("serverSideVerificationOptions");
+
+                    if (serverSideVerificationOptions != null) {
+                      ServerSideVerificationOptions.Builder options =
+                          new ServerSideVerificationOptions.Builder();
+
+                      if (serverSideVerificationOptions.hasKey("userId")) {
+                        options.setUserId(serverSideVerificationOptions.getString("userId"));
+                      }
+
+                      if (serverSideVerificationOptions.hasKey("customData")) {
+                        options.setCustomData(
+                            serverSideVerificationOptions.getString("customData"));
+                      }
+
+                      rewardedAd.setServerSideVerificationOptions(options.build());
+                    }
+                  }
+
+                  FullScreenContentCallback fullScreenContentCallback =
+                      new FullScreenContentCallback() {
+                        @Override
+                        public void onAdShowedFullScreenContent() {
+                          sendRewardedEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_OPENED, requestId, adUnitId, null, null);
+                        }
+
+                        @Override
+                        public void onAdDismissedFullScreenContent() {
+                          sendRewardedEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_CLOSED, requestId, adUnitId, null, null);
+                        }
+                      };
+
+                  rewardedAd.setFullScreenContentCallback(fullScreenContentCallback);
+
+                  rewardedAdArray.put(requestId, rewardedAd);
+                  sendRewardedEvent(
+                      GOOGLE_MOBILE_ADS_EVENT_REWARDED_LOADED, requestId, adUnitId, null, data);
+                }
+              };
+
+          RewardedAd.load(activity, adUnitId, adRequest, rewardedAdLoadCallback);
+        });
+  }
+
+  @ReactMethod
+  public void rewardedShow(
+      int requestId, String adUnitId, ReadableMap showOptions, Promise promise) {
+    if (getCurrentActivity() == null) {
+      rejectPromiseWithCodeAndMessage(
+          promise,
+          "null-activity",
+          "Rewarded ad attempted to show but the current Activity was null.");
+      return;
+    }
+    getCurrentActivity()
+        .runOnUiThread(
+            () -> {
+              RewardedAd rewardedAd = rewardedAdArray.get(requestId);
+
+              boolean immersiveModeEnabled = false;
+              if (showOptions.hasKey("immersiveModeEnabled")) {
+                immersiveModeEnabled = showOptions.getBoolean("immersiveModeEnabled");
+              }
+              rewardedAd.setImmersiveMode(immersiveModeEnabled);
+
+              OnUserEarnedRewardListener onUserEarnedRewardListener =
+                  new OnUserEarnedRewardListener() {
+                    @Override
+                    public void onUserEarnedReward(@NonNull RewardItem rewardItem) {
+                      WritableMap data = Arguments.createMap();
+                      data.putString("type", rewardItem.getType());
+                      data.putInt("amount", rewardItem.getAmount());
+                      sendRewardedEvent(
+                          GOOGLE_MOBILE_ADS_EVENT_REWARDED_EARNED_REWARD,
+                          requestId,
+                          adUnitId,
+                          null,
+                          data);
+                    }
+                  };
+
+              rewardedAd.show(getCurrentActivity(), onUserEarnedRewardListener);
+              promise.resolve(null);
+            });
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/RCTConvert.java

@@ -0,0 +1,111 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import android.util.Log;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Utilities to convert to and from React Native bridge formats. */
+public class RCTConvert {
+  private static String TAG = "RCTConvert";
+
+  /**
+   * Takes a value and calls the appropriate setter for its type on the target map + key
+   *
+   * @param key String key to set on target map
+   * @param value Object value to set on target map
+   * @param map WritableMap target map to write the value to
+   */
+  @SuppressWarnings("unchecked")
+  public static WritableMap mapPutValue(String key, @Nullable Object value, WritableMap map) {
+    if (value == null) {
+      map.putNull(key);
+      return map;
+    }
+
+    String type = value.getClass().getName();
+
+    switch (type) {
+      case "java.lang.Boolean":
+        map.putBoolean(key, (Boolean) value);
+        break;
+      case "java.lang.Long":
+        Long longVal = (Long) value;
+        map.putDouble(key, (double) longVal);
+        break;
+      case "java.lang.Float":
+        float floatVal = (float) value;
+        map.putDouble(key, (double) floatVal);
+        break;
+      case "java.lang.Double":
+        map.putDouble(key, (Double) value);
+        break;
+      case "java.lang.Integer":
+        map.putInt(key, (int) value);
+        break;
+      case "java.lang.String":
+        map.putString(key, (String) value);
+        break;
+      case "org.json.JSONObject$1":
+        map.putString(key, value.toString());
+        break;
+      default:
+        if (List.class.isAssignableFrom(value.getClass())) {
+          map.putArray(key, Arguments.makeNativeArray((List<Object>) value));
+        } else if (Map.class.isAssignableFrom(value.getClass())) {
+          WritableMap childMap = Arguments.createMap();
+          Map<String, Object> valueMap = (Map<String, Object>) value;
+
+          for (Map.Entry<String, Object> entry : valueMap.entrySet()) {
+            mapPutValue(entry.getKey(), entry.getValue(), childMap);
+          }
+
+          map.putMap(key, childMap);
+        } else {
+          Log.d(TAG, "utils:mapPutValue:unknownType:" + type);
+          map.putNull(key);
+        }
+    }
+
+    return map;
+  }
+
+  // TODO Remove me - also in SharedUtils
+  public static WritableMap readableMapToWritableMap(ReadableMap map) {
+    WritableMap writableMap = Arguments.createMap();
+    // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/WritableNativeMap.java#L58
+    writableMap.merge(map);
+    return writableMap;
+  }
+
+  public static Map<String, Object> toHashMap(ReadableMap readableMap) {
+    // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeMap.java#L263
+    return readableMap.toHashMap();
+  }
+
+  public static List<Object> toArrayList(ReadableArray readableArray) {
+    // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeArray.java#L140
+    return readableArray.toArrayList();
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/ReactNativeApp.java

@@ -0,0 +1,34 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import android.content.Context;
+import android.util.Log;
+
+public class ReactNativeApp {
+  private static Context applicationContext;
+
+  public static Context getApplicationContext() {
+    return applicationContext;
+  }
+
+  public static void setApplicationContext(Context applicationContext) {
+    Log.d("ReactNativeApp", "received application context.");
+    ReactNativeApp.applicationContext = applicationContext;
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/ReactNativeEvent.java

@@ -0,0 +1,41 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import com.facebook.react.bridge.WritableMap;
+import io.invertase.googlemobileads.interfaces.NativeEvent;
+
+public class ReactNativeEvent implements NativeEvent {
+  private String eventName;
+  private WritableMap eventBody;
+
+  public ReactNativeEvent(String eventName, WritableMap eventBody) {
+    this.eventName = eventName;
+    this.eventBody = eventBody;
+  }
+
+  @Override
+  public String getEventName() {
+    return eventName;
+  }
+
+  @Override
+  public WritableMap getEventBody() {
+    return eventBody;
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/ReactNativeEventEmitter.java

@@ -0,0 +1,150 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.MainThread;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import io.invertase.googlemobileads.interfaces.NativeEvent;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReactNativeEventEmitter {
+  private static ReactNativeEventEmitter sharedInstance = new ReactNativeEventEmitter();
+  private final List<NativeEvent> queuedEvents = new ArrayList<>();
+  private final Handler handler = new Handler(Looper.getMainLooper());
+  private final HashMap<String, Integer> jsListeners = new HashMap<>();
+  private ReactContext reactContext;
+  private Boolean jsReady = false;
+  private int jsListenerCount;
+
+  public static ReactNativeEventEmitter getSharedInstance() {
+    return sharedInstance;
+  }
+
+  public void attachReactContext(final ReactContext reactContext) {
+    handler.post(
+        () -> {
+          ReactNativeEventEmitter.this.reactContext = reactContext;
+          sendQueuedEvents();
+        });
+  }
+
+  public void notifyJsReady(Boolean ready) {
+    handler.post(
+        () -> {
+          jsReady = ready;
+          sendQueuedEvents();
+        });
+  }
+
+  public void sendEvent(final NativeEvent event) {
+    handler.post(
+        () -> {
+          synchronized (jsListeners) {
+            if (!jsListeners.containsKey(event.getEventName()) || !emit(event)) {
+              queuedEvents.add(event);
+            }
+          }
+        });
+  }
+
+  public void addListener(String eventName) {
+    synchronized (jsListeners) {
+      jsListenerCount++;
+      if (!jsListeners.containsKey(eventName)) {
+        jsListeners.put(eventName, 1);
+      } else {
+        int listenersForEvent = jsListeners.get(eventName);
+        jsListeners.put(eventName, listenersForEvent + 1);
+      }
+    }
+
+    handler.post(this::sendQueuedEvents);
+  }
+
+  public void removeListener(String eventName, Boolean all) {
+    synchronized (jsListeners) {
+      if (jsListeners.containsKey(eventName)) {
+        int listenersForEvent = jsListeners.get(eventName);
+
+        if (listenersForEvent <= 1 || all) {
+          jsListeners.remove(eventName);
+        } else {
+          jsListeners.put(eventName, listenersForEvent - 1);
+        }
+
+        jsListenerCount -= all ? listenersForEvent : 1;
+      }
+    }
+  }
+
+  public WritableMap getListenersMap() {
+    WritableMap writableMap = Arguments.createMap();
+    WritableMap events = Arguments.createMap();
+
+    writableMap.putInt("listeners", jsListenerCount);
+    writableMap.putInt("queued", queuedEvents.size());
+
+    synchronized (jsListeners) {
+      for (HashMap.Entry<String, Integer> entry : jsListeners.entrySet()) {
+        events.putInt(entry.getKey(), entry.getValue());
+      }
+    }
+
+    writableMap.putMap("events", events);
+
+    return writableMap;
+  }
+
+  @MainThread
+  private void sendQueuedEvents() {
+    synchronized (jsListeners) {
+      for (NativeEvent event : new ArrayList<>(queuedEvents)) {
+        if (jsListeners.containsKey(event.getEventName())) {
+          queuedEvents.remove(event);
+          sendEvent(event);
+        }
+      }
+    }
+  }
+
+  @MainThread
+  private boolean emit(final NativeEvent event) {
+    if (!jsReady || reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+      return false;
+    }
+
+    try {
+      reactContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+          .emit("rnapp_" + event.getEventName(), event.getEventBody());
+    } catch (Exception e) {
+      Log.wtf("RN_EVENT_EMITTER", "Error sending Event " + event.getEventName(), e);
+      return false;
+    }
+
+    return true;
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/ReactNativeInitProvider.java

@@ -0,0 +1,77 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ProviderInfo;
+import android.database.Cursor;
+import android.net.Uri;
+import androidx.annotation.Nullable;
+import javax.annotation.OverridingMethodsMustInvokeSuper;
+
+public class ReactNativeInitProvider extends ContentProvider {
+  @Override
+  public void attachInfo(Context context, ProviderInfo info) {
+    super.attachInfo(context, info);
+  }
+
+  @Override
+  @OverridingMethodsMustInvokeSuper
+  public boolean onCreate() {
+    if (ReactNativeApp.getApplicationContext() == null) {
+      Context applicationContext = getContext();
+      if (applicationContext != null && applicationContext.getApplicationContext() != null) {
+        applicationContext = applicationContext.getApplicationContext();
+      }
+      ReactNativeApp.setApplicationContext(applicationContext);
+    }
+
+    return false;
+  }
+
+  @Nullable
+  @Override
+  public Cursor query(
+      Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public String getType(Uri uri) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public Uri insert(Uri uri, ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public int delete(Uri uri, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    return 0;
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/common/ReactNativeJSON.java

@@ -0,0 +1,107 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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.
+ *
+ */
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import io.invertase.googlemobileads.BuildConfig;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class ReactNativeJSON {
+  private static ReactNativeJSON sharedInstance = new ReactNativeJSON();
+
+  private JSONObject jsonObject;
+
+  private ReactNativeJSON() {
+    try {
+      jsonObject = new JSONObject(BuildConfig.GOOGLE_MOBILE_ADS_JSON_RAW);
+    } catch (JSONException e) {
+      // JSON is validated as part of gradle build - should never error
+    }
+  }
+
+  public static ReactNativeJSON getSharedInstance() {
+    return sharedInstance;
+  }
+
+  public boolean contains(String key) {
+    if (jsonObject == null) return false;
+    return jsonObject.has(key);
+  }
+
+  public boolean getBooleanValue(String key, boolean defaultValue) {
+    if (jsonObject == null) return defaultValue;
+    return jsonObject.optBoolean(key, defaultValue);
+  }
+
+  public int getIntValue(String key, int defaultValue) {
+    if (jsonObject == null) return defaultValue;
+    return jsonObject.optInt(key, defaultValue);
+  }
+
+  public long getLongValue(String key, long defaultValue) {
+    if (jsonObject == null) return defaultValue;
+    return jsonObject.optLong(key, defaultValue);
+  }
+
+  public String getStringValue(String key, String defaultValue) {
+    if (jsonObject == null) return defaultValue;
+    return jsonObject.optString(key, defaultValue);
+  }
+
+  public ArrayList<String> getArrayValue(String key) {
+    ArrayList<String> result = new ArrayList<String>();
+    if (jsonObject == null) return result;
+
+    try {
+      JSONArray array = jsonObject.optJSONArray(key);
+      if (array != null) {
+        for (int i = 0; i < array.length(); i++) {
+          result.add(array.getString(i));
+        }
+      }
+    } catch (JSONException e) {
+      // do nothing
+    }
+
+    return result;
+  }
+
+  public String getRawJSON() {
+    return BuildConfig.GOOGLE_MOBILE_ADS_JSON_RAW;
+  }
+
+  public WritableMap getAll() {
+    WritableMap writableMap = Arguments.createMap();
+
+    JSONArray keys = jsonObject.names();
+    for (int i = 0; i < keys.length(); ++i) {
+      try {
+        String key = keys.getString(i);
+        SharedUtils.mapPutValue(key, jsonObject.get(key), writableMap);
+      } catch (JSONException e) {
+        // ignore
+      }
+    }
+
+    return writableMap;
+  }
+}