cordova-admob-tomitank 1.0.0

package/src/ios/AMBRewarded.swift

@@ -0,0 +1,72 @@
+import GoogleMobileAds
+
+class AMBRewarded: AMBAdBase, GADFullScreenContentDelegate {
+    var mAd: GADRewardedAd?
+
+    deinit {
+        clear()
+    }
+
+    override func isLoaded() -> Bool {
+        return self.mAd != nil
+    }
+
+    override func load(_ ctx: AMBContext) {
+        clear()
+
+        GADRewardedAd.load(withAdUnitID: adUnitId, request: adRequest, completionHandler: { ad, error in
+            if error != nil {
+                self.emit(AMBEvents.adLoadFail, error!)
+                self.emit(AMBEvents.rewardedLoadFail, error!)
+
+                ctx.reject(error!)
+                return
+            }
+
+            self.mAd = ad
+            ad?.fullScreenContentDelegate = self
+            ad?.serverSideVerificationOptions = ctx.optGADServerSideVerificationOptions()
+
+            self.emit(AMBEvents.adLoad)
+            self.emit(AMBEvents.rewardedLoad)
+
+            ctx.resolve()
+        })
+    }
+
+    override func show(_ ctx: AMBContext) {
+        mAd?.present(fromRootViewController: plugin.viewController, userDidEarnRewardHandler: {
+            let reward = self.mAd!.adReward
+            self.emit(AMBEvents.adReward, reward)
+            self.emit(AMBEvents.rewardedReward, reward)
+        })
+        ctx.resolve()
+    }
+
+    func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adImpression)
+        self.emit(AMBEvents.rewardedImpression)
+    }
+
+    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        clear()
+        self.emit(AMBEvents.adShowFail, error)
+        self.emit(AMBEvents.rewardedShowFail, error)
+    }
+
+    func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adShow)
+        self.emit(AMBEvents.rewardedShow)
+    }
+
+    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        clear()
+        self.emit(AMBEvents.adDismiss)
+        self.emit(AMBEvents.rewardedDismiss)
+    }
+
+    private func clear() {
+        mAd?.fullScreenContentDelegate = nil
+        mAd = nil
+    }
+}

package/src/ios/AMBRewardedInterstitial.swift

@@ -0,0 +1,72 @@
+import GoogleMobileAds
+
+class AMBRewardedInterstitial: AMBAdBase, GADFullScreenContentDelegate {
+    var mAd: GADRewardedInterstitialAd?
+
+    deinit {
+        clear()
+    }
+
+    override func isLoaded() -> Bool {
+        return self.mAd != nil
+    }
+
+    override func load(_ ctx: AMBContext) {
+        clear()
+
+        GADRewardedInterstitialAd.load(withAdUnitID: adUnitId, request: adRequest, completionHandler: { ad, error in
+            if error != nil {
+                self.emit(AMBEvents.adLoadFail, error!)
+                self.emit(AMBEvents.rewardedInterstitialLoadFail, error!)
+
+                ctx.reject(error!)
+                return
+            }
+
+            self.mAd = ad
+            ad?.fullScreenContentDelegate = self
+            ad?.serverSideVerificationOptions = ctx.optGADServerSideVerificationOptions()
+
+            self.emit(AMBEvents.adLoad)
+            self.emit(AMBEvents.rewardedInterstitialLoad)
+
+            ctx.resolve()
+        })
+    }
+
+    override func show(_ ctx: AMBContext) {
+        mAd?.present(fromRootViewController: plugin.viewController, userDidEarnRewardHandler: {
+            let reward = self.mAd!.adReward
+            self.emit(AMBEvents.adReward, reward)
+            self.emit(AMBEvents.rewardedInterstitialReward, reward)
+        })
+        ctx.resolve()
+    }
+
+    func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adImpression)
+        self.emit(AMBEvents.rewardedInterstitialImpression)
+    }
+
+    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        clear()
+        self.emit(AMBEvents.adShowFail, error)
+        self.emit(AMBEvents.rewardedInterstitialShowFail, error)
+    }
+
+    func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adShow)
+        self.emit(AMBEvents.rewardedInterstitialShow)
+    }
+
+    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        clear()
+        self.emit(AMBEvents.adDismiss)
+        self.emit(AMBEvents.rewardedInterstitialDismiss)
+    }
+
+    private func clear() {
+        mAd?.fullScreenContentDelegate = nil
+        mAd = nil
+    }
+}

package/src/www/admob.ts

@@ -0,0 +1,26 @@
+import * as cordova from 'cordova'
+import channel from 'cordova/channel'
+import exec from 'cordova/exec'
+import { AdMob } from '.'
+import { MobileAd, NativeActions } from './shared'
+
+const admob = new AdMob()
+
+function onMessageFromNative(event: any) {
+  const { data } = event
+  if (data && data.adId) {
+    data.ad = MobileAd.getAdById(data.adId)
+  }
+  cordova.fireDocumentEvent(event.type, data)
+}
+
+const feature = 'onAdMobPlusReady'
+channel.createSticky(feature)
+channel.waitForInitialization(feature)
+
+channel.onCordovaReady.subscribe(() => {
+  exec(onMessageFromNative, console.error, 'AdMob', NativeActions.ready, [])
+  channel.initializationComplete(feature)
+})
+
+export default admob

package/src/www/api.ts

@@ -0,0 +1,156 @@
+import { execAsync, NativeActions } from './generated'
+
+export { execAsync, AdSizeType, Events, NativeActions } from './generated'
+
+/** @internal */
+export type MobileAdOptions = {
+  id?: number
+  adUnitId: string
+  contentUrl?: string
+  keywords?: string[]
+  npa?: '1'
+}
+
+let started = false
+let startPromise: Promise<{ version: string }> | null = null
+
+/** @internal */
+export async function start() {
+  startPromise = execAsync(NativeActions.start) as Promise<{ version: string }>
+  const result = await startPromise
+  started = true
+  return result
+}
+
+/** @internal */
+export class MobileAd<T extends MobileAdOptions = MobileAdOptions> {
+  public static readonly type: string = ''
+
+  private static allAds: { [s: number]: MobileAd } = {}
+  private static idCounter = 0
+
+  public readonly id: number
+
+  protected readonly opts: T
+  private _created = false
+  private _init: Promise<any> | null = null
+
+  constructor(opts: T) {
+    this.opts = opts
+
+    this.id = opts.id ?? MobileAd.nextId()
+    MobileAd.allAds[this.id] = this
+  }
+
+  public static getAdById(id: number) {
+    return this.allAds[id]
+  }
+
+  private static nextId() {
+    const storage = window.localStorage
+    const key = 'admob-ad-id-counter'
+    const value = storage.getItem(key)
+    if (value !== null) {
+      MobileAd.idCounter = Number(value)
+    }
+    MobileAd.idCounter += 1
+    storage.setItem(key, `${MobileAd.idCounter}`)
+    return MobileAd.idCounter
+  }
+
+  public get adUnitId() {
+    return this.opts.adUnitId
+  }
+
+  public on(...args: Parameters<typeof document.addEventListener>): () => void {
+    const [eventName, cb, ...rest] = args
+    const type = `admob.ad.${eventName.toLowerCase()}`
+    const listener = (evt: any) => {
+      if (evt.ad === this) {
+        cb(evt)
+      }
+    }
+    document.addEventListener(type, listener, ...rest)
+
+    return () => {
+      document.removeEventListener(type, listener, ...rest)
+    }
+  }
+
+  protected async isLoaded() {
+    await this.init()
+    return execAsync(NativeActions.adIsLoaded, [
+      { id: this.id },
+    ]) as Promise<boolean>
+  }
+
+  protected async load() {
+    await this.init()
+    // TODO read `opts` in native code?
+    await execAsync(NativeActions.adLoad, [{ ...this.opts, id: this.id }])
+  }
+
+  protected async show(opts?: Record<string, any>) {
+    await this.init()
+    return execAsync(NativeActions.adShow, [{ ...opts, id: this.id }])
+  }
+
+  protected async hide() {
+    return execAsync(NativeActions.adHide, [{ id: this.id }])
+  }
+
+  protected async init() {
+    if (this._created) return
+
+    if (!started) {
+      if (startPromise === null) start()
+      await startPromise
+    }
+
+    if (this._init === null) {
+      const cls =
+        (this.constructor as unknown as { cls?: string }).cls ??
+        this.constructor.name
+
+      this._init = execAsync(NativeActions.adCreate, [
+        { ...this.opts, id: this.id, cls },
+      ])
+    }
+
+    await this._init
+    this._created = true
+  }
+}
+
+export enum MaxAdContentRating {
+  G = 'G',
+  MA = 'MA',
+  PG = 'PG',
+  T = 'T',
+  UNSPECIFIED = '',
+}
+
+export type RequestConfig = {
+  maxAdContentRating?: MaxAdContentRating
+  sameAppKey?: boolean,
+  tagForChildDirectedTreatment?: boolean | null
+  tagForUnderAgeOfConsent?: boolean | null
+  testDeviceIds?: string[]
+}
+
+export const enum Platforms {
+  android = 'android',
+  ios = 'ios',
+}
+
+export enum TrackingAuthorizationStatus {
+  notDetermined = 0,
+  restricted = 1,
+  denied = 2,
+  authorized = 3,
+}
+
+export type AdMobConfig = {
+  appMuted?: boolean
+  appVolume?: number
+} & RequestConfig

package/src/www/app-open.ts

@@ -0,0 +1,27 @@
+import { MobileAd, MobileAdOptions } from './shared'
+
+enum AppOpenAdOrientation {
+  Portrait = 1,
+  PortraitUpsideDown = 2,
+  LandscapeRight = 3,
+  LandscapeLeft = 4,
+}
+
+export default class AppOpenAd extends MobileAd<
+  MobileAdOptions & { orientation: AppOpenAdOrientation }
+> {
+  static cls = 'AppOpenAd'
+  static readonly Orientation = AppOpenAdOrientation
+
+  public isLoaded() {
+    return super.isLoaded()
+  }
+
+  public load() {
+    return super.load()
+  }
+
+  async show() {
+    return super.show() as Promise<boolean>
+  }
+}

package/src/www/banner.ts

@@ -0,0 +1,102 @@
+import {
+  AdSizeType,
+  execAsync,
+  MobileAd,
+  MobileAdOptions,
+  NativeActions,
+  Platforms,
+} from './shared'
+
+type Position = 'top' | 'bottom'
+
+const colorToRGBA = (function () {
+  const canvas = document.createElement('canvas')
+  canvas.width = canvas.height = 1
+  const ctx = canvas.getContext('2d')
+  if (!ctx) return () => undefined
+
+  return function (
+    col: string,
+  ): { r: number; g: number; b: number; a: number } | undefined {
+    ctx.clearRect(0, 0, 1, 1)
+    // In order to detect invalid values,
+    // we can't rely on col being in the same format as what fillStyle is computed as,
+    // but we can ask it to implicitly compute a normalized value twice and compare.
+    ctx.fillStyle = '#000'
+    ctx.fillStyle = col
+    const computed = ctx.fillStyle
+    ctx.fillStyle = '#fff'
+    ctx.fillStyle = col
+    if (computed !== ctx.fillStyle) {
+      return // invalid color
+    }
+    ctx.fillRect(0, 0, 1, 1)
+    const { data } = ctx.getImageData(0, 0, 1, 1)
+    return { r: data[0], g: data[1], b: data[2], a: data[3] }
+  }
+})()
+
+type BannerSize =
+  | AdSizeType
+  | { width: number; height: number }
+  | {
+      adaptive: 'anchored'
+      orientation?: 'portrait' | 'landscape'
+      width?: number
+    }
+  | {
+      adaptive: 'inline'
+      maxHeight: number
+      width?: number
+    }
+
+export interface BannerAdOptions extends MobileAdOptions {
+  position?: Position
+  size?: BannerSize
+  offset?: number
+}
+
+export default class BannerAd extends MobileAd<BannerAdOptions> {
+  static cls = 'BannerAd'
+
+  private _loaded = false
+
+  constructor(opts: BannerAdOptions) {
+    super({
+      position: 'bottom',
+      size: AdSizeType.SMART_BANNER,
+      ...opts,
+    })
+  }
+
+  public static config(opts: {
+    backgroundColor?: string
+    marginTop?: number
+    marginBottom?: number
+  }) {
+    if (cordova.platformId === Platforms.ios) {
+      const { backgroundColor: bgColor } = opts
+      return execAsync(NativeActions.bannerConfig, [
+        { ...opts, backgroundColor: bgColor ? colorToRGBA(bgColor) : bgColor },
+      ])
+    }
+    return false
+  }
+
+  public async load() {
+    await super.load()
+    this._loaded = true
+  }
+
+  public async show() {
+    if (!this._loaded) {
+      await this.load()
+    }
+
+    return super.show()
+  }
+
+  public async hide() {
+    return super.hide()
+  }
+}

package/src/www/cordova.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="cordova-plus/types" />
+
+declare module 'cordova/channel'
+
+declare module 'cordova/exec'
+
+interface Cordova {
+  fireDocumentEvent(eventName: string, data: any)
+}

package/src/www/generated.ts

@@ -0,0 +1,125 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+export enum NativeActions {
+  adCreate = 'adCreate',
+  adHide = 'adHide',
+  adIsLoaded = 'adIsLoaded',
+  adLoad = 'adLoad',
+  adShow = 'adShow',
+  bannerConfig = 'bannerConfig',
+  bannerHide = 'bannerHide',
+  bannerLoad = 'bannerLoad',
+  bannerShow = 'bannerShow',
+  configRequest = 'configRequest',
+  configure = 'configure',
+  interstitialIsLoaded = 'interstitialIsLoaded',
+  interstitialLoad = 'interstitialLoad',
+  interstitialShow = 'interstitialShow',
+  ready = 'ready',
+  requestTrackingAuthorization = 'requestTrackingAuthorization',
+  rewardedInterstitialIsLoaded = 'rewardedInterstitialIsLoaded',
+  rewardedInterstitialLoad = 'rewardedInterstitialLoad',
+  rewardedInterstitialShow = 'rewardedInterstitialShow',
+  rewardedIsLoaded = 'rewardedIsLoaded',
+  rewardedLoad = 'rewardedLoad',
+  rewardedShow = 'rewardedShow',
+  setAppMuted = 'setAppMuted',
+  setAppVolume = 'setAppVolume',
+  start = 'start',
+}
+
+export enum Events {
+  adClick = 'admob.ad.click',
+  adDismiss = 'admob.ad.dismiss',
+  adImpression = 'admob.ad.impression',
+  adLoad = 'admob.ad.load',
+  adLoadFail = 'admob.ad.loadfail',
+  adReward = 'admob.ad.reward',
+  adShow = 'admob.ad.show',
+  adShowFail = 'admob.ad.showfail',
+  bannerClick = 'admob.banner.click',
+  bannerClose = 'admob.banner.close',
+  bannerImpression = 'admob.banner.impression',
+  bannerLoad = 'admob.banner.load',
+  bannerLoadFail = 'admob.banner.loadfail',
+  bannerOpen = 'admob.banner.open',
+  bannerSize = 'admob.banner.size',
+  bannerSizeChange = 'admob.banner.sizechange',
+  interstitialDismiss = 'admob.interstitial.dismiss',
+  interstitialImpression = 'admob.interstitial.impression',
+  interstitialLoad = 'admob.interstitial.load',
+  interstitialLoadFail = 'admob.interstitial.loadfail',
+  interstitialShow = 'admob.interstitial.show',
+  interstitialShowFail = 'admob.interstitial.showfail',
+  ready = 'admob.ready',
+  rewardedDismiss = 'admob.rewarded.dismiss',
+  rewardedImpression = 'admob.rewarded.impression',
+  rewardedInterstitialDismiss = 'admob.rewardedi.dismiss',
+  rewardedInterstitialImpression = 'admob.rewardedi.impression',
+  rewardedInterstitialLoad = 'admob.rewardedi.load',
+  rewardedInterstitialLoadFail = 'admob.rewardedi.loadfail',
+  rewardedInterstitialReward = 'admob.rewardedi.reward',
+  rewardedInterstitialShow = 'admob.rewardedi.show',
+  rewardedInterstitialShowFail = 'admob.rewardedi.showfail',
+  rewardedLoad = 'admob.rewarded.load',
+  rewardedLoadFail = 'admob.rewarded.loadfail',
+  rewardedReward = 'admob.rewarded.reward',
+  rewardedShow = 'admob.rewarded.show',
+  rewardedShowFail = 'admob.rewarded.showfail',
+}
+
+export enum AdSizeType {
+  BANNER,
+  LARGE_BANNER,
+  MEDIUM_RECTANGLE,
+  FULL_BANNER,
+  LEADERBOARD,
+  SMART_BANNER,
+}
+
+export const execAsync = (action: NativeActions, args?: any[]) => {
+  return new Promise((resolve, reject) => {
+    cordova.exec(resolve, reject, 'AdMob', action, args)
+  })
+}
+
+export function waitEvent(
+  successEvent: string,
+  failEvent = '',
+): Promise<CustomEvent> {
+  return new Promise((resolve, reject) => {
+    document.addEventListener(
+      successEvent as any,
+      (event: CustomEvent) => {
+        resolve(event)
+      },
+      false,
+    )
+
+    if (failEvent) {
+      document.addEventListener(
+        failEvent as any,
+        (failedEvent: CustomEvent) => {
+          reject(failedEvent)
+        },
+        false,
+      )
+    }
+  })
+}
+
+export const initPlugin = () => {
+  document.addEventListener(
+    'deviceready',
+    () => {
+      cordova.exec(
+        (event) => {
+          cordova.fireDocumentEvent(event.type, event.data)
+        },
+        console.error,
+        'AdMob',
+        NativeActions.ready,
+      )
+    },
+    false,
+  )
+}

package/src/www/index.ts

@@ -0,0 +1,88 @@
+import AppOpenAd from './app-open'
+import BannerAd, { BannerAdOptions } from './banner'
+import InterstitialAd from './interstitial'
+import NativeAd, { NativeAdOptions } from './native'
+import RewardedAd, {
+  RewardedAdOptions,
+  ServerSideVerificationOptions,
+} from './rewarded'
+import RewardedInterstitialAd, {
+  RewardedInterstitialAdOptions,
+} from './rewarded-interstitial'
+import {
+  AdMobConfig,
+  Events,
+  execAsync,
+  NativeActions,
+  Platforms,
+  RequestConfig,
+  start,
+  TrackingAuthorizationStatus,
+} from './shared'
+
+export * from './api'
+export {
+  AppOpenAd,
+  BannerAd,
+  BannerAdOptions,
+  InterstitialAd,
+  NativeAd,
+  NativeAdOptions,
+  RewardedAd,
+  RewardedAdOptions,
+  RewardedInterstitialAd,
+  RewardedInterstitialAdOptions,
+  ServerSideVerificationOptions,
+}
+
+export class AdMob {
+  public readonly AppOpenAd = AppOpenAd
+  public readonly BannerAd = BannerAd
+  public readonly InterstitialAd = InterstitialAd
+  public readonly NativeAd = NativeAd
+  public readonly RewardedAd = RewardedAd
+  public readonly RewardedInterstitialAd = RewardedInterstitialAd
+
+  public readonly Events = Events
+  public readonly TrackingAuthorizationStatus = TrackingAuthorizationStatus
+
+  configure(config: AdMobConfig) {
+    return execAsync(NativeActions.configure, [config])
+  }
+
+  public configRequest(requestConfig: RequestConfig) {
+    return execAsync(NativeActions.configRequest, [requestConfig])
+  }
+
+  public setAppMuted(value: boolean) {
+    return execAsync(NativeActions.setAppMuted, [value])
+  }
+
+  public setAppVolume(value: number) {
+    return execAsync(NativeActions.setAppVolume, [value])
+  }
+
+  public start() {
+    return start()
+  }
+
+  public async requestTrackingAuthorization(): Promise<
+    TrackingAuthorizationStatus | false
+  > {
+    if (cordova.platformId === Platforms.ios) {
+      const n = await execAsync(NativeActions.requestTrackingAuthorization)
+      if (n !== false) {
+        return TrackingAuthorizationStatus[
+          TrackingAuthorizationStatus[n as number]
+        ]
+      }
+    }
+    return false
+  }
+}
+
+declare global {
+  const admob: AdMob
+}
+
+export default AdMob

package/src/www/interstitial.ts

@@ -0,0 +1,17 @@
+import { MobileAd, MobileAdOptions } from './shared'
+
+export default class InterstitialAd extends MobileAd<MobileAdOptions> {
+  static cls = 'InterstitialAd'
+
+  public isLoaded() {
+    return super.isLoaded()
+  }
+
+  public load() {
+    return super.load()
+  }
+
+  public show() {
+    return super.show()
+  }
+}