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

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;
+  }
+}

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

@@ -0,0 +1,92 @@
+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.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+public class ReactNativeMeta {
+  private static final String TAG = "MetaProvider";
+  private static final String META_PREFIX = "rngooglemobileads";
+  private static ReactNativeMeta sharedInstance = new ReactNativeMeta();
+
+  public static ReactNativeMeta getSharedInstance() {
+    return sharedInstance;
+  }
+
+  private Bundle getMetaData() {
+    try {
+      Context context = ReactNativeApp.getApplicationContext();
+      PackageManager packageManager = context.getPackageManager();
+
+      if (packageManager == null) return null;
+
+      ApplicationInfo applicationInfo =
+          packageManager.getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
+
+      if (applicationInfo != null) return applicationInfo.metaData;
+    } catch (PackageManager.NameNotFoundException exception) {
+      // do nothing
+    }
+
+    return null;
+  }
+
+  public boolean contains(String key) {
+    Bundle metaData = getMetaData();
+    if (metaData == null) return false;
+    return metaData.containsKey(META_PREFIX + key);
+  }
+
+  public boolean getBooleanValue(String key, boolean defaultValue) {
+    Bundle metaData = getMetaData();
+    if (metaData == null) return defaultValue;
+    return metaData.getBoolean(META_PREFIX + key, defaultValue);
+  }
+
+  public String getStringValue(String key, String defaultValue) {
+    Bundle metaData = getMetaData();
+    if (metaData == null) return defaultValue;
+    return metaData.getString(META_PREFIX + key, defaultValue);
+  }
+
+  public WritableMap getAll() {
+    Bundle metaData = getMetaData();
+    WritableMap map = Arguments.createMap();
+    if (metaData == null) return map;
+
+    for (String key : metaData.keySet()) {
+      if (key.startsWith(META_PREFIX)) {
+        Object value = metaData.get(key);
+        if (value == null) {
+          map.putNull(key);
+        } else if (value instanceof String) {
+          map.putString(key, (String) value);
+        } else if (value instanceof Boolean) {
+          map.putBoolean(key, (Boolean) value);
+        }
+      }
+    }
+
+    return map;
+  }
+}

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

@@ -0,0 +1,96 @@
+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.app.Activity;
+import android.content.Context;
+import com.facebook.react.bridge.*;
+import io.invertase.googlemobileads.interfaces.ContextProvider;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import javax.annotation.Nonnull;
+
+public class ReactNativeModule extends ReactContextBaseJavaModule implements ContextProvider {
+  private final TaskExecutorService executorService;
+
+  private String moduleName;
+
+  public ReactNativeModule(ReactApplicationContext reactContext, String moduleName) {
+    super(reactContext);
+    this.moduleName = moduleName;
+    this.executorService = new TaskExecutorService(getName());
+  }
+
+  public static void rejectPromiseWithCodeAndMessage(Promise promise, String code, String message) {
+    WritableMap userInfoMap = Arguments.createMap();
+    userInfoMap.putString("code", code);
+    userInfoMap.putString("message", message);
+    promise.reject(code, message, userInfoMap);
+  }
+
+  @Override
+  public void initialize() {
+    super.initialize();
+  }
+
+  public ReactContext getContext() {
+    return getReactApplicationContext();
+  }
+
+  public ExecutorService getExecutor() {
+    return executorService.getExecutor();
+  }
+
+  public ExecutorService getTransactionalExecutor() {
+    return executorService.getTransactionalExecutor();
+  }
+
+  public ExecutorService getTransactionalExecutor(String identifier) {
+    return executorService.getTransactionalExecutor(identifier);
+  }
+
+  @Override
+  public void invalidate() {
+    executorService.shutdown();
+  }
+
+  public void removeEventListeningExecutor(String identifier) {
+    String executorName = executorService.getExecutorName(true, identifier);
+    executorService.removeExecutor(executorName);
+  }
+
+  public Context getApplicationContext() {
+    return getReactApplicationContext().getApplicationContext();
+  }
+
+  public Activity getActivity() {
+    return getCurrentActivity();
+  }
+
+  @Nonnull
+  @Override
+  public String getName() {
+    return moduleName;
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    return new HashMap<>();
+  }
+}

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

@@ -0,0 +1,86 @@
+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.content.SharedPreferences;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import java.util.Map;
+
+public class ReactNativePreferences {
+  private static final String PREFERENCES_FILE = "io.invertase.googlemobileads";
+  private static ReactNativePreferences sharedInstance = new ReactNativePreferences();
+  private SharedPreferences preferences;
+
+  public static ReactNativePreferences getSharedInstance() {
+    return sharedInstance;
+  }
+
+  public boolean contains(String key) {
+    return getPreferences().contains(key);
+  }
+
+  public void setBooleanValue(String key, boolean value) {
+    getPreferences().edit().putBoolean(key, value).apply();
+  }
+
+  public boolean getBooleanValue(String key, boolean defaultValue) {
+    return getPreferences().getBoolean(key, defaultValue);
+  }
+
+  public void setLongValue(String key, long value) {
+    getPreferences().edit().putLong(key, value).apply();
+  }
+
+  public long getLongValue(String key, long defaultValue) {
+    return getPreferences().getLong(key, defaultValue);
+  }
+
+  public void setStringValue(String key, String value) {
+    getPreferences().edit().putString(key, value).apply();
+  }
+
+  public String getStringValue(String key, String defaultValue) {
+    return getPreferences().getString(key, defaultValue);
+  }
+
+  public WritableMap getAll() {
+    WritableMap writableMap = Arguments.createMap();
+    Map<String, ?> prefMap = getPreferences().getAll();
+
+    for (Map.Entry<String, ?> entry : prefMap.entrySet()) {
+      SharedUtils.mapPutValue(entry.getKey(), entry.getValue(), writableMap);
+    }
+
+    return writableMap;
+  }
+
+  public void clearAll() {
+    getPreferences().edit().clear().apply();
+  }
+
+  private SharedPreferences getPreferences() {
+    if (preferences == null) {
+      preferences =
+          ReactNativeApp.getApplicationContext()
+              .getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE);
+    }
+    return preferences;
+  }
+}