react-native-google-mobile-ads 4.1.0

package/src/ads/RewardedAd.ts

@@ -0,0 +1,161 @@
+/*
+ * 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 { isFunction, isString } from '../common';
+import { MobileAds } from '../MobileAds';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { validateAdShowOptions } from '../validateAdShowOptions';
+import { MobileAd } from './MobileAd';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdShowOptions } from '../types/AdShowOptions';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
+
+let _rewardedRequest = 0;
+
+/**
+ * A class for interacting and showing Rewarded Ads.
+ *
+ * An Rewarded advert can be pre-loaded and shown at a suitable point in your apps flow, such as at the end of a level
+ * in a game. The content of a rewarded advert can be controlled via your Google Mobile Ads dashboard. Typically users are rewarded
+ * after completing a specific advert action (e.g. watching a video or submitting an option via an interactive form).
+ * Events (such as the user earning a reward or closing a rewarded advert early) are sent back for you to handle accordingly
+ * within your application.
+ *
+ * #### Example
+ *
+ * First create a new Rewarded instance, passing in your Ad Unit ID from the Google Mobile Ads configuration console, and any additional
+ * request options. The example below will present a test advert, and only request a non-personalized ad.
+ *
+ * ```js
+ * import { RewardedAd, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * const rewarded = RewardedAd.createForAdRequest(TestIds.REWARDED, {
+ *     requestNonPersonalizedAdsOnly: true,
+ * });
+ *  ```
+ *
+ * Each advert needs to be loaded from Google Mobile Ads before being shown. It is recommended this is performed before the user
+ * reaches the checkpoint to show the advert, so it's ready to go. Before loading the advert, we need to setup
+ * event listeners to listen for updates from Google Mobile Ads, such as advert loaded or failed to load.
+ *
+ * Event types match the `AdEventType` or `RewardedAdEventType` interface. The potential user reward for rewarded
+ * adverts are passed back to the event handler on advert load and when the user earns the reward.
+ *
+ * ```js
+ * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
+ *
+ * rewarded.onAdEvent((type, error, reward) => {
+ *   if (type === RewardedAdEventType.LOADED) {
+ *     rewarded.show();
+ *   }
+ *   if (type === RewardedAdEventType.EARNED_REWARD) {
+ *     console.log('User earned reward of ', reward);
+ *   }
+ * });
+ *
+ * rewarded.load();
+ *  ```
+ *
+ * The rewarded advert will be presented to the user, and several more events can be triggered such as the user clicking the
+ * advert, closing it or completing the action.
+ */
+export class RewardedAd extends MobileAd implements MobileAdInterface {
+  /**
+   * Creates a new RewardedAd instance.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { RewardedAd, RewardedAdEventType, TestIds } from 'react-native-google-mobile-ads';
+   *
+   * const rewardedAd = await RewardedAd.createForAdRequest(TestIds.REWARDED, {
+   *   requestAgent: 'CoolAds',
+   * });
+   *
+   * rewardedAd.onAdEvent((type, error, data) => {
+   *   console.log('New event: ', type, error);
+   *
+   *   if (type === RewardedAdEventType.LOADED) {
+   *     rewardedAd.show();
+   *   }
+   * });
+   *
+   * rewardedAd.load();
+   * ```
+   *
+   * @param adUnitId The Ad Unit ID for the Rewarded Ad. You can find this on your Google Mobile Ads dashboard.
+   * @param requestOptions Optional RequestOptions used to load the ad.
+   */
+  static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions): RewardedAd {
+    if (!isString(adUnitId)) {
+      throw new Error("RewardedAd.createForAdRequest(*) 'adUnitId' expected an string value.");
+    }
+
+    let options = {};
+    try {
+      options = validateAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`RewardedAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const requestId = _rewardedRequest++;
+    return new RewardedAd('rewarded', MobileAds(), requestId, adUnitId, options);
+  }
+
+  load() {
+    // Prevent multiple load calls
+    if (this._loaded || this._isLoadCalled) {
+      return;
+    }
+
+    this._isLoadCalled = true;
+    this._googleMobileAds.native.rewardedLoad(
+      this._requestId,
+      this._adUnitId,
+      this._requestOptions,
+    );
+  }
+
+  onAdEvent(handler: AdEventListener) {
+    if (!isFunction(handler)) {
+      throw new Error("RewardedAd.onAdEvent(*) 'handler' expected a function.");
+    }
+
+    return this._setAdEventHandler(handler);
+  }
+
+  show(showOptions?: AdShowOptions) {
+    if (!this._loaded) {
+      throw new Error(
+        'RewardedAd.show() The requested RewardedAd has not loaded and could not be shown.',
+      );
+    }
+
+    let options;
+    try {
+      options = validateAdShowOptions(showOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`RewardedAd.show(*) ${e.message}.`);
+      }
+    }
+    return this._googleMobileAds.native.rewardedShow(this._requestId, this._adUnitId, options);
+  }
+}

package/src/common/Base64.ts

@@ -0,0 +1,114 @@
+/* eslint-disable no-bitwise */
+/* global Blob, FileReader */
+/*
+ * 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 binaryToBase64 from 'react-native/Libraries/Utilities/binaryToBase64';
+import { promiseDefer } from './promise';
+
+const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+/**
+ * window.btoa
+ */
+export function btoa(input: string) {
+  let map;
+  let i = 0;
+  let block = 0;
+  let output = '';
+
+  for (
+    block = 0, i = 0, map = CHARS;
+    input.charAt(i | 0) || ((map = '='), i % 1);
+    output += map.charAt(63 & (block >> (8 - (i % 1) * 8)))
+  ) {
+    const charCode = input.charCodeAt((i += 3 / 4));
+
+    if (charCode > 0xff) {
+      throw new Error(
+        "'RNFirebase.Base64.btoa' failed: The string to be encoded contains characters outside of the Latin1 range.",
+      );
+    }
+
+    block = (block << 8) | charCode;
+  }
+
+  return output;
+}
+
+/**
+ * window.atob
+ */
+export function atob(input: string) {
+  let i = 0;
+  let bc = 0;
+  let bs = 0;
+  let buffer;
+  let output = '';
+
+  const str = input.replace(/[=]+$/, '');
+
+  if (str.length % 4 === 1) {
+    throw new Error(
+      "'RNFirebase.Base64.atob' failed: The string to be decoded is not correctly encoded.",
+    );
+  }
+
+  for (
+    bc = 0, bs = 0, i = 0;
+    (buffer = str.charAt(i++));
+    ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4)
+      ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
+      : 0
+  ) {
+    buffer = CHARS.indexOf(buffer);
+  }
+
+  return output;
+}
+
+/**
+ * Converts a Blob, ArrayBuffer or Uint8Array to a base64 string.
+ */
+export function fromData(data: Blob | ArrayBuffer | Uint8Array) {
+  if (data instanceof Blob) {
+    const fileReader = new FileReader();
+    const { resolve, reject, promise } = promiseDefer();
+
+    fileReader.readAsDataURL(data);
+
+    fileReader.onloadend = function onloadend() {
+      resolve({ string: fileReader.result, format: 'data_url' });
+    };
+
+    fileReader.onerror = function onerror(event) {
+      fileReader.abort();
+      reject(event);
+    };
+
+    return promise;
+  }
+
+  if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+    return Promise.resolve({
+      string: binaryToBase64(data),
+      format: 'base64',
+    });
+  }
+
+  throw new Error("'RNFirebase.Base64.fromData' failed: Unknown data type.");
+}

package/src/common/MutatableParams.ts

@@ -0,0 +1,50 @@
+/*
+ * 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 { deepGet, deepSet } from './deeps';
+
+export class MutatableParams {
+  _mutatableParams: Record<string, unknown>;
+  _parentInstance: MutatableParams;
+
+  constructor(parentInstance: MutatableParams) {
+    if (parentInstance) {
+      this._mutatableParams = parentInstance._mutatableParams;
+      this._parentInstance = parentInstance;
+    } else {
+      this._mutatableParams = {};
+      this._parentInstance = this;
+    }
+  }
+
+  set(param: string, value: unknown) {
+    deepSet(this._mutatableParams, param, value);
+    return this._parentInstance;
+  }
+
+  get(param: string) {
+    return deepGet(this._mutatableParams, param, '.');
+  }
+
+  toJSON() {
+    return Object.assign({}, this._mutatableParams);
+  }
+
+  validate() {
+    // do nothing
+  }
+}

package/src/common/ReferenceBase.ts

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ *
+ */
+
+export class ReferenceBase {
+  path: string;
+
+  constructor(_path: string) {
+    let path = _path;
+
+    if (path) {
+      path = path.length > 1 && path.endsWith('/') ? path.substring(0, path.length - 1) : path;
+      if (path.startsWith('/') && path.length > 1) {
+        path = path.substring(1, path.length);
+      }
+    } else {
+      path = '/';
+    }
+
+    this.path = path;
+  }
+
+  /**
+   * The last part of a Reference's path (after the last '/')
+   * The key of a root Reference is null.
+   * @type {String}
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#key}
+   */
+  get key() {
+    return this.path === '/' ? null : this.path.substring(this.path.lastIndexOf('/') + 1);
+  }
+}

package/src/common/deeps.ts

@@ -0,0 +1,88 @@
+/*
+ * 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 { isArray, isObject } from './validate';
+
+/**
+ * Deep get a value from an object.
+ * @website https://github.com/Salakar/deeps
+ * @param object
+ * @param path
+ * @param joiner
+ * @returns {*}
+ */
+export function deepGet(object: Record<string, unknown>, path: string, joiner = '/') {
+  if (!isObject(object) && !Array.isArray(object)) {
+    return undefined;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let value;
+  const len = keys.length;
+
+  while (i < len) {
+    const key = keys[i++];
+    if (!object || !Object.hasOwnProperty.call(object, key)) {
+      return undefined;
+    }
+    value = object[key];
+  }
+
+  return value;
+}
+
+/**
+ * Deep set a value
+ * @param object
+ * @param path
+ * @param value
+ * @param initPaths
+ * @param joiner
+ */
+export function deepSet(
+  object: Record<string, unknown>,
+  path: string,
+  value: unknown,
+  initPaths = true,
+  joiner = '.',
+) {
+  if (!isObject(object)) {
+    return false;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let _object = object;
+  const len = keys.length - 1;
+
+  while (i < len) {
+    const key = keys[i++];
+    if (initPaths && !Object.hasOwnProperty.call(object, key)) {
+      _object[key] = {};
+    }
+    _object = _object[key] as Record<string, unknown>;
+  }
+
+  if (isObject(_object) || (isArray(_object) && !Number.isNaN(keys[i]))) {
+    _object[keys[i]] = value;
+  } else {
+    return false;
+  }
+
+  return true;
+}

package/src/common/id.ts

@@ -0,0 +1,74 @@
+const PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+
+const AUTO_ID_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+// timestamp of last push, used to prevent local collisions if you push twice in one ms.
+let lastPushTime = 0;
+
+// we generate 72-bits of randomness which get turned into 12 characters and appended to the
+// timestamp to prevent collisions with other clients.  We store the last characters we
+// generated because in the event of a collision, we'll use those same characters except
+// "incremented" by one.
+const lastRandChars: number[] = [];
+
+/**
+ * Generate a firebase id - for use with ref().push(val, cb) - e.g. -KXMr7k2tXUFQqiaZRY4'
+ * @param serverTimeOffset - pass in server time offset from native side
+ * @returns {string}
+ */
+export function generateDatabaseId(serverTimeOffset = 0) {
+  const timeStampChars = new Array(8);
+  let now = new Date().getTime() + serverTimeOffset;
+  const duplicateTime = now === lastPushTime;
+
+  lastPushTime = now;
+
+  for (let i = 7; i >= 0; i -= 1) {
+    timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
+    now = Math.floor(now / 64);
+  }
+
+  if (now !== 0) {
+    throw new Error('We should have converted the entire timestamp.');
+  }
+
+  let id = timeStampChars.join('');
+
+  if (!duplicateTime) {
+    for (let i = 0; i < 12; i += 1) {
+      lastRandChars[i] = Math.floor(Math.random() * 64);
+    }
+  } else {
+    // if the timestamp hasn't changed since last push,
+    // use the same random number, but increment it by 1.
+    let i;
+    for (i = 11; i >= 0 && lastRandChars[i] === 63; i -= 1) {
+      lastRandChars[i] = 0;
+    }
+
+    lastRandChars[i] += 1;
+  }
+
+  for (let i = 0; i < 12; i++) {
+    id += PUSH_CHARS.charAt(lastRandChars[i]);
+  }
+
+  if (id.length !== 20) {
+    throw new Error('Length should be 20.');
+  }
+
+  return id;
+}
+
+/**
+ * Generate a firestore auto id for use with collection/document .add()
+ * @return {string}
+ */
+export function generateFirestoreId() {
+  let autoId = '';
+
+  for (let i = 0; i < 20; i++) {
+    autoId += AUTO_ID_CHARS.charAt(Math.floor(Math.random() * AUTO_ID_CHARS.length));
+  }
+  return autoId;
+}

package/src/common/index.ts

@@ -0,0 +1,103 @@
+/*
+ * 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 { Platform } from 'react-native';
+import * as Base64 from './Base64';
+import { isString } from './validate';
+
+export * from './id';
+export * from './path';
+export * from './promise';
+export * from './validate';
+
+export { Base64 };
+export { ReferenceBase } from './ReferenceBase';
+
+export function getDataUrlParts(dataUrlString: string) {
+  const isBase64 = dataUrlString.includes(';base64');
+  let [mediaType, base64String] = dataUrlString.split(',');
+  if (!mediaType || !base64String) {
+    return { base64String: undefined, mediaType: undefined };
+  }
+  mediaType = mediaType.replace('data:', '').replace(';base64', '');
+  if (base64String && base64String.includes('%')) {
+    base64String = decodeURIComponent(base64String);
+  }
+  if (!isBase64) {
+    base64String = Base64.btoa(base64String);
+  }
+  return { base64String, mediaType };
+}
+
+export function once<T>(fn: () => void, context: unknown): (this: T, ...args: []) => void {
+  let onceResult: unknown;
+  let ranOnce = false;
+
+  return function onceInner(...args: []) {
+    if (!ranOnce) {
+      ranOnce = true;
+      onceResult = fn.apply(context || this, args);
+    }
+
+    return onceResult;
+  };
+}
+
+export function isError(value: unknown) {
+  if (Object.prototype.toString.call(value) === '[object Error]') {
+    return true;
+  }
+
+  return value instanceof Error;
+}
+
+export function hasOwnProperty(target: unknown, property: PropertyKey) {
+  return Object.hasOwnProperty.call(target, property);
+}
+
+/**
+ * Remove a trailing forward slash from a string if it exists
+ *
+ * @param string
+ * @returns {*}
+ */
+export function stripTrailingSlash(string: string) {
+  if (!isString(string)) {
+    return string;
+  }
+  return string.endsWith('/') ? string.slice(0, -1) : string;
+}
+
+export const isIOS = Platform.OS === 'ios';
+
+export const isAndroid = Platform.OS === 'android';
+
+export function tryJSONParse(string: string) {
+  try {
+    return string && JSON.parse(string);
+  } catch (jsonError) {
+    return string;
+  }
+}
+
+export function tryJSONStringify(data: unknown) {
+  try {
+    return JSON.stringify(data);
+  } catch (jsonError) {
+    return null;
+  }
+}