@cardsjd/portal 0.1.9 → 0.1.11

package/lib/AndroidPortal.js

@@ -1,17 +1,6 @@
-import { AdMobPortal } from './AdMobPortal';
+import { NextGenAdMobPortal } from './NextGenAdMobPortal.js';
 
-export class AndroidPortal extends AdMobPortal {
+export class AndroidPortal extends NextGenAdMobPortal {
 	name = 'AndroidPortal';
 
-	updateConfig(config = {}, adConfig = {}) {
-		const configToUpdate = structuredClone(config);
-
-		// Map android-specific ad config items to generic "ad" config items
-		configToUpdate.interstitialAdId = adConfig.admobInterstitialAdId_Android;
-		configToUpdate.rewardedAdId = adConfig.admobRewardedAdId_Android;
-		configToUpdate.appOpenAdId = adConfig.admobAppOpenAdId_Android;
-		configToUpdate.appId = adConfig.admobAppId_Android;
-
-		return configToUpdate;
-	}
-}
+}

package/lib/BasePortal.js

@@ -42,9 +42,15 @@ export class BasePortal {
 
 	isAdLoaded() { }
 
-	isRewardedAdLoaded() { }
-
-	logError(_errorCode) { }
+	isRewardedAdLoaded() { }
+
+	isPrivacyOptionsRequired() {
+		return false;
+	}
+
+	async showPrivacyOptions() { }
+
+	logError(_errorCode) { }
 
 	isErrorState() { }
 

package/lib/FacebookPortal.js

@@ -1,4 +1,4 @@
-import { BasePortal } from './BasePortal';
+import { BasePortal } from './BasePortal';
 import { FBInstantGame } from '@cardsjd/fbinstantgame';
 
 export class FacebookPortal extends BasePortal {
@@ -32,15 +32,20 @@ export class FacebookPortal extends BasePortal {
 
 	async load() {
 		const fbUserdata = await this.fBInstantGame.loadData();
-		const fbProfile = await this.fBInstantGame.getProfile();
-		const data = {};
-		data.userdata = fbUserdata;
-		data.user = fbProfile;
+		const fbProfile = await this.fBInstantGame.getProfile();
+		const data = {};
+		data.userdata = fbUserdata;
+		data.user = fbProfile ? {
+			facebookId: fbProfile.facebookId ?? fbProfile.id,
+			name: fbProfile.name,
+			avatar: fbProfile.avatar ?? fbProfile.pic,
+			locale: fbProfile.locale,
+		} : null;
 		return data;
 	}
 
-	async save(data, forceSave) {
-		this.fBInstantGame.saveData(data, forceSave).catch(function () { });
+	async save(data, forceSave) {
+		this.fBInstantGame.saveData(data, forceSave).catch(function () { });
 	}
 
 	gameStart() {
@@ -60,10 +65,10 @@ export class FacebookPortal extends BasePortal {
 	
 		this.subscribeBot();
 	}
-	createShortCut() {
-		this.portal?.createShortCut?.();
-	}
-	async subscribeBot() {
+	createShortCut() {
+		this.portal?.createShortCut?.();
+	}
+	async subscribeBot() {
 		await this.fBInstantGame.subscribeBot();
 	}
 
@@ -183,7 +188,7 @@ export class FacebookPortal extends BasePortal {
 
 		this._isAdLoading = true;
 
-		const interstitialAdId = this.appConfig?.interstitalAdId;
+		const interstitialAdId = this.appConfig?.interstitialAdId;
 
 		console.log('FB_Ads.getInterstitialAdAsync start: ' + interstitialAdId);
 		if (!this.isApiSupported('getInterstitialAdAsync')) {
@@ -285,7 +290,7 @@ export class FacebookPortal extends BasePortal {
 			console.log('FBInstant plugin not ready'); return false;
 		}
 
-		const interstitialAdId = this.appConfig?.interstitalAdId;
+		const interstitialAdId = this.appConfig?.interstitialAdId;
 		if (!this.isApiSupported('getInterstitialAdAsync')) {
 			this.logError('CLIENT_UNSUPPORTED_OPERATION');
 			console.warn('FBInstant.getInterstitialAdAsync is not supported on this client');

package/lib/NextGenAdMobPortal.js

@@ -0,0 +1,400 @@
+import { BasePortal } from './BasePortal.js';
+
+export class NextGenAdMobPortal extends BasePortal {
+	name = 'NextGenAdMobPortal';
+	autoLogin = false;
+
+	constructor(appConfig) {
+		super();
+		this.appConfig = appConfig;
+
+		// Ad callback properties
+		this.onAdLoaded = null;
+		this.onAdOpened = null;
+		this.onAdClosed = null;
+		this.onAdError = null;
+		this.onAdRewarded = null;
+		this.onBeforeTrackingAuthorization = null;
+		this.onPrivacyOptionsRequirementChanged = null;
+
+		this.adProviderName = 'CapgoAdmob';
+		this.isSetup = false;
+		this.isSetupLoading = false;
+		this.isInterstitialAdReady = false;
+		this._isRewardedAdLoaded = false;
+		this._receivedReward = false;
+		this._rewardInfo = null;
+		this._interstitialAd = null;
+		this._interstitialLoadPromise = null;
+		this._rewardedAd = null;
+		this._adMobModule = null;
+		this._umpModule = null;
+		this._consentInfoUpdated = false;
+		this._consentGathered = false;
+		this._canRequestAds = false;
+		this._privacyOptionsRequired = false;
+		this.isTesting = false;
+	}
+
+	async getAdMob() {
+		if (!this._adMobModule) {
+			// eslint-disable-next-line import/no-unresolved
+			this._adMobModule = await import('@capgo/capacitor-admob');
+		}
+
+		return this._adMobModule;
+	}
+
+	async loadUmp() {
+		if (!this._umpModule) {
+			// eslint-disable-next-line import/no-unresolved
+			const { GoogleUmpConsent } = await import('@cardsjd/google-ump');
+			this._umpModule = GoogleUmpConsent;
+		}
+	}
+
+	async requestTrackingAuthorization(_consentInfo) {
+		return false;
+	}
+
+	async canStartAdsWithoutPrompt() {
+		return true;
+	}
+
+	setConsentInfo(consentInfo) {
+		const wasRequired = this._privacyOptionsRequired;
+		if (typeof consentInfo?.canRequestAds === 'boolean') {
+			this._canRequestAds = consentInfo.canRequestAds;
+		}
+
+		this._privacyOptionsRequired = consentInfo?.privacyOptionsRequired === true;
+
+		if (
+			wasRequired !== this._privacyOptionsRequired &&
+			this.onPrivacyOptionsRequirementChanged
+		) {
+			this.onPrivacyOptionsRequirementChanged(this._privacyOptionsRequired);
+		}
+	}
+
+	isPrivacyOptionsRequired() {
+		return this._privacyOptionsRequired;
+	}
+
+	async showPrivacyOptions() {
+		await this.loadUmp();
+		const consentInfo = await this._umpModule.showPrivacyOptions();
+		this.setConsentInfo(consentInfo);
+		return consentInfo;
+	}
+
+	async updateConsentInfo() {
+		await this.loadUmp();
+		const consentInfo = await this._umpModule.updateConsentInfo();
+		this._consentInfoUpdated = true;
+		this.setConsentInfo(consentInfo);
+		return consentInfo;
+	}
+
+	async gatherConsent() {
+		await this.loadUmp();
+		const consentInfo = await this._umpModule.gatherConsent();
+		this._consentInfoUpdated = true;
+		this._consentGathered = true;
+		this.setConsentInfo(consentInfo);
+		return consentInfo;
+	}
+
+	getAdError(info, fallbackMessage) {
+		return new Error(info?.error?.message || info?.message || fallbackMessage);
+	}
+
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (this.isSetup || this._consentInfoUpdated) {
+			return;
+		}
+
+		if (this.isSetupLoading) {
+			throw Error('Capgo AdMob setup is in progress already');
+		}
+
+		this.isSetupLoading = true;
+
+		try {
+			await this.updateConsentInfo();
+		} catch (error) {
+			console.error('Failed to update UMP consent info:', error);
+		} finally {
+			this.isSetupLoading = false;
+		}
+	}
+
+	async ensureAdsReady() {
+		if (this.isSetup) {
+			return {
+				canRequestAds: true,
+				promptShown: false,
+			};
+		}
+
+		let consentInfo;
+		try {
+			if (!this._consentInfoUpdated) {
+				await this.updateConsentInfo();
+			}
+
+			consentInfo = this._consentGathered ? {
+				canRequestAds: this._canRequestAds,
+			} : await this.gatherConsent();
+		} catch (error) {
+			if (this.onAdError) {
+				this.onAdError(error);
+			}
+
+			return {
+				canRequestAds: false,
+				promptShown: false,
+			};
+		}
+
+		const trackingPromptShown = await this.requestTrackingAuthorization(consentInfo);
+		const promptShown = consentInfo?.formShown === true || trackingPromptShown;
+
+		if (consentInfo.canRequestAds !== true) {
+			return {
+				canRequestAds: false,
+				promptShown,
+			};
+		}
+
+		await this.startAds();
+		return {
+			canRequestAds: true,
+			promptShown,
+		};
+	}
+
+	async prepareAdsWithoutPrompt() {
+		if (this.isSetup) {
+			return true;
+		}
+
+		if (!this._consentInfoUpdated) {
+			await this.setupAds();
+		}
+
+		if (!this._canRequestAds || !await this.canStartAdsWithoutPrompt()) {
+			return false;
+		}
+
+		await this.startAds();
+		return true;
+	}
+
+	async startAds() {
+		if (this.isSetup) {
+			return;
+		}
+
+		if (this.isSetupLoading) {
+			throw Error('Capgo AdMob setup is in progress already');
+		}
+
+		this.isSetupLoading = true;
+
+		try {
+			const { AdMob } = await this.getAdMob();
+			await AdMob.start();
+
+			await AdMob.addListener('interstitial.show', (info) => {
+				if (info.id === this._interstitialAd?.id) {
+					this.isInterstitialAdReady = false;
+					if (this.onAdOpened) {
+						this.onAdOpened({
+							adType: 'interstitial',
+							adProvider: this.adProviderName,
+						});
+					}
+				}
+			});
+			await AdMob.addListener('interstitial.dismiss', (info) => {
+				if (info.id === this._interstitialAd?.id) {
+					this.isInterstitialAdReady = false;
+					this._interstitialAd = null;
+					if (this.onAdClosed) {
+						this.onAdClosed({
+							adType: 'interstitial',
+							adProvider: this.adProviderName,
+						});
+					}
+				}
+			});
+			await AdMob.addListener('interstitial.loadfail', (info) => {
+				if (info.id === this._interstitialAd?.id) {
+					this.isInterstitialAdReady = false;
+					this._interstitialAd = null;
+					if (this.onAdError) {
+						this.onAdError(this.getAdError(info, 'InterstitialAd failed to load'));
+					}
+				}
+			});
+			await AdMob.addListener('interstitial.showfail', (info) => {
+				if (info.id === this._interstitialAd?.id) {
+					this.isInterstitialAdReady = false;
+					this._interstitialAd = null;
+					if (this.onAdError) {
+						this.onAdError(this.getAdError(info, 'InterstitialAd failed to show'));
+					}
+				}
+			});
+			await AdMob.addListener('rewarded.dismiss', (info) => {
+				if (info.id === this._rewardedAd?.id) {
+					this._isRewardedAdLoaded = false;
+					this._rewardedAd = null;
+					if (this.onAdClosed) {
+						this.onAdClosed({
+							adType: 'rewarded',
+							adProvider: this.adProviderName,
+						});
+					}
+
+					if (this._receivedReward && this.onAdRewarded) {
+						this.onAdRewarded(this._rewardInfo);
+					}
+				}
+			});
+			await AdMob.addListener('rewarded.loadfail', (info) => {
+				if (info.id === this._rewardedAd?.id) {
+					this._isRewardedAdLoaded = false;
+					this._rewardedAd = null;
+					if (this.onAdError) {
+						this.onAdError(this.getAdError(info, 'RewardAd failed to load'));
+					}
+				}
+			});
+			await AdMob.addListener('rewarded.showfail', (info) => {
+				if (info.id === this._rewardedAd?.id) {
+					this._isRewardedAdLoaded = false;
+					this._rewardedAd = null;
+					if (this.onAdError) {
+						this.onAdError(this.getAdError(info, 'RewardAd failed to show'));
+					}
+				}
+			});
+			await AdMob.addListener('rewarded.reward', (info) => {
+				if (info.id === this._rewardedAd?.id) {
+					this._receivedReward = true;
+					this._rewardInfo = info.reward;
+				}
+			});
+
+			this.isSetup = true;
+		} finally {
+			this.isSetupLoading = false;
+		}
+	}
+
+	isAdLoaded() {
+		return this.isInterstitialAdReady;
+	}
+
+	isRewardedAdLoaded() {
+		return this._isRewardedAdLoaded;
+	}
+
+	async loadInterstitialAd() {
+		if (this.isAdLoaded()) {
+			return;
+		}
+
+		if (!this._interstitialLoadPromise) {
+			this._interstitialLoadPromise = (async () => {
+				if (!await this.prepareAdsWithoutPrompt()) {
+					return;
+				}
+
+				const { InterstitialAd } = await this.getAdMob();
+				this._interstitialAd = new InterstitialAd({
+					adUnitId: this.appConfig?.interstitialAdId,
+				});
+
+				await this._interstitialAd.load();
+				this.isInterstitialAdReady = true;
+			})();
+		}
+
+		const loadPromise = this._interstitialLoadPromise;
+		try {
+			await loadPromise;
+		} catch (error) {
+			this._interstitialAd = null;
+			throw error;
+		} finally {
+			if (this._interstitialLoadPromise === loadPromise) {
+				this._interstitialLoadPromise = null;
+			}
+		}
+	}
+
+	async showInterstitialAd() {
+		const setup = await this.ensureAdsReady();
+		if (!setup.canRequestAds || setup.promptShown) {
+			return;
+		}
+
+		if (!this.isAdLoaded()) {
+			let timeoutId;
+			await Promise.race([this.loadInterstitialAd(), new Promise(resolve => {
+				timeoutId = setTimeout(resolve, 2000);
+			})]);
+			clearTimeout(timeoutId);
+			if (!this.isAdLoaded()) {
+				return;
+			}
+		}
+
+		this.isInterstitialAdReady = false;
+		return this._interstitialAd.show();
+	}
+
+	async loadRewardedAd() {
+		if (!await this.prepareAdsWithoutPrompt()) {
+			return;
+		}
+
+		if (this.isRewardedAdLoaded()) {
+			return;
+		}
+
+		const { RewardedAd } = await this.getAdMob();
+		this._rewardedAd = new RewardedAd({
+			adUnitId: this.appConfig?.rewardedAdId,
+		});
+
+		try {
+			await this._rewardedAd.load();
+			this._isRewardedAdLoaded = true;
+			this._receivedReward = false;
+			this._rewardInfo = null;
+		} catch (error) {
+			this._rewardedAd = null;
+			throw error;
+		}
+	}
+
+	async showRewardedAd() {
+		const setup = await this.ensureAdsReady();
+		if (!setup.canRequestAds || setup.promptShown) {
+			return;
+		}
+
+		if (!this.isRewardedAdLoaded()) {
+			await this.loadRewardedAd();
+		}
+
+		this._isRewardedAdLoaded = false;
+		return this._rewardedAd.show();
+	}
+}

package/lib/iOSPortal.js

@@ -1,7 +1,31 @@
-import { AdMobPortal } from './AdMobPortal';
-
-export class iOSPortal extends AdMobPortal {
-	name = 'iOSPortal';
-
-
-}
+import { NextGenAdMobPortal } from './NextGenAdMobPortal.js';
+
+export class iOSPortal extends NextGenAdMobPortal {
+	name = 'iOSPortal';
+
+	async canStartAdsWithoutPrompt() {
+		const { AdMob, TrackingAuthorizationStatus } = await this.getAdMob();
+		const trackingInfo = await AdMob.trackingAuthorizationStatus();
+		return trackingInfo.status !== TrackingAuthorizationStatus.notDetermined;
+	}
+
+	async requestTrackingAuthorization(consentInfo) {
+		const { AdMob, TrackingAuthorizationStatus } = await this.getAdMob();
+		const trackingInfo = await AdMob.trackingAuthorizationStatus();
+
+		if (trackingInfo.status === TrackingAuthorizationStatus.notDetermined) {
+			// UMP reaches this fallback only when no IDFA explainer handled ATT.
+			if (this.onBeforeTrackingAuthorization) {
+				const shouldContinue = await this.onBeforeTrackingAuthorization();
+				if (shouldContinue === false) {
+					return false;
+				}
+			}
+
+			await AdMob.requestTrackingAuthorization();
+			return true;
+		}
+
+		return consentInfo?.trackingAuthorizationChanged === true;
+	}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cardsjd/portal",
 	"private": false,
-	"version": "0.1.9",
+	"version": "0.1.11",
 	"type": "module",
 	"main": "lib/index.js",
 	"publishConfig": {
@@ -17,8 +17,24 @@
 	},
 	"devDependencies": {},
 	"dependencies": {
-		"@capacitor-community/admob": "^7.0.3",
+		"@cardsjd/device": "^0.1.15",
+		"@cardsjd/fbinstantgame": "^0.1.12",
 		"@discord/embedded-app-sdk": "^2.4.0"
 	},
-	"peerDependencies": {}
+	"peerDependencies": {
+		"@capacitor-community/admob": ">=7 <9",
+		"@capgo/capacitor-admob": ">=8 <9",
+		"@cardsjd/google-ump": ">=0.0.1 <1"
+	},
+	"peerDependenciesMeta": {
+		"@capacitor-community/admob": {
+			"optional": true
+		},
+		"@capgo/capacitor-admob": {
+			"optional": true
+		},
+		"@cardsjd/google-ump": {
+			"optional": true
+		}
+	}
 }