@cardsjd/portal 0.1.1 → 0.1.2

package/lib/AdMobPortal.js

@@ -0,0 +1,193 @@
+import {
+	AdMob, AdmobConsentStatus, InterstitialAdPluginEvents, RewardAdPluginEvents,
+} from '@capacitor-community/admob';
+
+import { BasePortal } from './BasePortal';
+
+export class AdMobPortal extends BasePortal {
+	name = 'AdMobPortal';
+	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.adProviderName = 'CapacitorAdmob';
+		this.isSetup = false;
+		this.isSetupLoading = false;
+		this.isInterstitialAdReady = false;
+		this._isRewardedAdLoaded = false;
+		this._receivedReward = false;
+		this._rewardInfo = null;
+		this.isTesting = false;
+	}
+
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (this.isSetup) {
+			console.log('CapacitorAdmob is already setup');
+			return;
+		}
+
+		if (this.isSetupLoading) {
+			throw Error('Capacitor AdMob setup is in progress already');
+		}
+
+		this.isSetupLoading = true;
+
+		await AdMob.initialize({
+			initializeForTesting: this.isTesting,
+			testingDevices: [],
+		});
+
+		const trackingInfo = await AdMob.trackingAuthorizationStatus();
+		let consentInfo;
+		try {
+			consentInfo = await AdMob.requestConsentInfo();
+		} catch (error) {
+			console.error('Failed to get consent info:', error);
+			consentInfo = {
+				isConsentFormAvailable: false,
+				status: null,
+			};
+		}
+
+		if (trackingInfo.status === 'notDetermined') {
+			await AdMob.requestTrackingAuthorization();
+		}
+
+		const authorizationStatus = await AdMob.trackingAuthorizationStatus();
+
+		if (
+			authorizationStatus.status === 'authorized' &&
+			consentInfo.isConsentFormAvailable &&
+			consentInfo.status === AdmobConsentStatus.REQUIRED
+		) {
+			await AdMob.showConsentForm();
+		}
+
+		AdMob.addListener(InterstitialAdPluginEvents.Loaded, () => {
+			this.isInterstitialAdReady = true;
+		});
+		AdMob.addListener(InterstitialAdPluginEvents.Showed, () => {
+			this.isInterstitialAdReady = false;
+			if (this.onAdOpened) {
+				this.onAdOpened({
+					adType: 'interstitial',
+					adProvider: this.adProviderName,
+				});
+			}
+		});
+		AdMob.addListener(InterstitialAdPluginEvents.Dismissed, () => {
+			this.isInterstitialAdReady = false;
+			if (this.onAdClosed) {
+				this.onAdClosed({
+					adType: 'interstitial',
+					adProvider: this.adProviderName,
+				});
+			}
+		});
+		AdMob.addListener(InterstitialAdPluginEvents.FailedToLoad, () => {
+			if (this.onAdError) {
+				this.onAdError(new Error('InterstitialAd failed to load'));
+			}
+		});
+		AdMob.addListener(RewardAdPluginEvents.Loaded, () => {
+			this._isRewardedAdLoaded = true;
+			this._receivedReward = false;
+			this._rewardInfo = null;
+		});
+		AdMob.addListener(RewardAdPluginEvents.Rewarded, (info) => {
+			this._receivedReward = true;
+			this._rewardInfo = info;
+		});
+		AdMob.addListener(RewardAdPluginEvents.Dismissed, () => {
+			this._isRewardedAdLoaded = false;
+			if (this.onAdClosed) {
+				this.onAdClosed({
+					adType: 'rewarded',
+					adProvider: this.adProviderName,
+				});
+			}
+
+			if (this._receivedReward && this.onAdRewarded) {
+				this.onAdRewarded(this._rewardInfo);
+			}
+		});
+		AdMob.addListener(RewardAdPluginEvents.FailedToLoad, () => {
+			if (this.onAdError) {
+				this.onAdError(new Error('RewardAd failed to load'));
+			}
+		});
+
+		this.isSetup = true;
+		this.isSetupLoading = false;
+	}
+
+	isAdLoaded() {
+		return this.isInterstitialAdReady;
+	}
+
+	isRewardedAdLoaded() {
+		return this._isRewardedAdLoaded;
+	}
+
+	async loadAd() {
+		if (this.isSetup === false) {
+			return;
+		}
+
+		if (this.isAdLoaded()) {
+			return;
+		}
+
+		return AdMob.prepareInterstitial({
+			adId: this.appConfig?.interstitialAdId,
+		});
+	}
+
+	async showAd() {
+		if (!this.isAdLoaded()) {
+			await this.loadAd();
+			return; // no auto show
+		}
+
+		this.isInterstitialAdReady = false;
+		return AdMob.showInterstitial();
+	}
+
+	async loadRewardedAd() {
+		if (this.isSetup === false) {
+			return;
+		}
+
+		if (this.isRewardedAdLoaded()) {
+			return;
+		}
+
+		return AdMob.prepareRewardVideoAd({
+			adId: this.appConfig?.rewardedAdId,
+		});
+	}
+
+	async showRewardedAd() {
+		if (this.isSetup === false) {
+			return;
+		}
+
+		if (!this.isRewardedAdLoaded()) {
+			await this.loadRewardedAd();
+		}
+
+		this._isRewardedAdLoaded = false;
+		return AdMob.showRewardVideoAd();
+	}
+}

package/lib/AndroidPortal.js

@@ -0,0 +1,17 @@
+import { AdMobPortal } from './AdMobPortal';
+
+export class AndroidPortal extends AdMobPortal {
+	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

@@ -16,6 +16,8 @@ export class BasePortal {
 
 	loadStop() { }
 
+	subscribeBot() { }
+
 	async getInvite() { }
 
 	async inviteSend(user, room) { }
@@ -26,5 +28,25 @@ export class BasePortal {
 
 	tryShowInterstitialAd() { }
 
+	setupAds() { }
+
+	loadAd(_force) { }
+
+	showAd() { }
+
+	loadAndShowAd() { }
+
+	loadRewardedAd(_onLoaded) { }
+
+	showRewardedAd() { }
+
+	isAdLoaded() { }
+
+	isRewardedAdLoaded() { }
+
+	logError(_errorCode) { }
+
+	isErrorState() { }
+
 	createShortCut() { }
 }

package/lib/CrazyGamesPortal.js

@@ -7,6 +7,21 @@ export class CrazyGamesPortal extends BasePortal {
 	hideSuggestions = false;
 	hideReportBug = 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.adProviderName = 'crazygames';
+		this.isSetup = false;
+	}
+
 	async init() {
 		try {
 			await import('https://sdk.crazygames.com/crazygames-sdk-v3.js');
@@ -18,17 +33,24 @@ export class CrazyGamesPortal extends BasePortal {
 		}
 
 	}
+
 	isCrazyGames() {
-		if (typeof globalThis.CrazyGames === 'undefined') return false;
-		if (!globalThis.CrazyGames.SDK) return false;
-		if (globalThis.CrazyGames.SDK.environment === "disabled") {
+		if (typeof globalThis.CrazyGames === 'undefined' || !globalThis.CrazyGames.SDK) {
+			return false;
+		}
+
+		if (globalThis.CrazyGames.SDK.environment === 'disabled') {
 			console.log('CrazyGames SDK is disabled');
 			return false;
 		}
+
 		return true;
 	}
+
 	async load() {
-		if (!this.isCrazyGames()) return;
+		if (!this.isCrazyGames()) {
+			return;
+		}
 
 		const data = {};
 		try {
@@ -37,34 +59,46 @@ export class CrazyGamesPortal extends BasePortal {
 		} catch (err) {
 			console.warn('Failed to call CrazyGames SDK load:', err);
 		}
+
 		return data;
 	}
-	async save(data, forceSave) {
+
+	async save(data, _forceSave) {
 		if (!this.isCrazyGames()) {
 			return;
 		}
 
 		const sdk = globalThis.CrazyGames.SDK;
-		if (!sdk.data) return;
+		if (!sdk.data) {
+			return;
+		}
 
-		sdk.data.setItem("userdata", JSON.stringify(data));
+		sdk.data.setItem('userdata', JSON.stringify(data));
 
 	}
+
 	async delete() {
 		if (!this.isCrazyGames()) {
 			return;
 		}
+
 		const sdk = globalThis.CrazyGames.SDK;
-		if (!sdk.data) return;
+		if (!sdk.data) {
+			return;
+		}
 
 		sdk.data.clear();
 	}
+
 	async loadData() {
 		if (!this.isCrazyGames()) {
 			return null;
 		}
+
 		const sdk = globalThis.CrazyGames.SDK;
-		if (!sdk.data) return null;
+		if (!sdk.data) {
+			return null;
+		}
 
 		//get userdata from crazygames storage - and get newest data
 		const userdata_crazyGame_string = sdk.data.getItem('userdata');
@@ -81,15 +115,16 @@ export class CrazyGamesPortal extends BasePortal {
 		}
 
 	}
+
 	async loadUser() {
 		if (!this.isCrazyGames()) {
 			return null;
 		}
 
 		const sdk = globalThis.CrazyGames.SDK;
-		if (!sdk.data) return null;
-
-		
+		if (!sdk.data) {
+			return null;
+		}
 
 		if (!sdk.user.isUserAccountAvailable) {
 			return null;
@@ -109,6 +144,7 @@ export class CrazyGamesPortal extends BasePortal {
 				user.name = userdetails.username;
 				user.crazyGamesId = userdetails.username; //use username for now, not actual userid from crazy games, too many steps and higher risk of failure
 			}
+
 			if (userdetails?.profilePictureUrl) {
 				user.avatar = userdetails.profilePictureUrl;
 			}
@@ -131,7 +167,6 @@ export class CrazyGamesPortal extends BasePortal {
 		// // //   }
 		// // // } catch (e) { }
 
-
 		return user;
 	}
 
@@ -187,4 +222,155 @@ export class CrazyGamesPortal extends BasePortal {
 		}
 	}
 
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (this.isSetup) {
+			console.log('CrazyGames.isSetup is already done');
+			return true;
+		}
+
+		await globalThis.CrazyGames.SDK.init();
+
+		this.isSetup = true;
+
+		return true;
+	}
+
+	isAdReady() {
+		return this.isCrazyGames();
+	}
+
+	async loadAd() {
+		console.log('CrazyGames.loadAd');
+
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (!this.isSetup) {
+			await this.setupAds();
+		}
+	}
+
+	async showAd() {
+		console.log('CrazyGames.showAd');
+
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (!this.isSetup) {
+			await this.setupAds();
+		}
+
+		const adType = 'interstitial';
+		const adProvider = this.adProviderName;
+
+		const callbacks = {
+			adFinished: () => {
+				if (typeof this.onAdClosed === 'function') {
+					this.onAdClosed({
+						adType,
+						adProvider,
+					});
+				}
+			},
+			adError: (error) => {
+				if (typeof this.onAdError === 'function') {
+					this.onAdError({
+						error,
+						adType,
+						adProvider,
+					});
+				}
+			},
+			adStarted: () => {
+				if (typeof this.onAdOpened === 'function') {
+					this.onAdOpened({
+						adType,
+						adProvider,
+					});
+				}
+			},
+		};
+
+		globalThis.CrazyGames.SDK.ad.requestAd('midgame', callbacks);
+	}
+
+	isAdLoaded() {
+		return true;
+	}
+
+	isRewardedAdLoaded() {
+		return true;
+	}
+
+	async showRewardedAd() {
+		console.log('CrazyGames.ShowRewardedAd');
+
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (!this.isSetup) {
+			await this.setupAds();
+		}
+
+		const adType = 'rewarded';
+		const adProvider = this.adProviderName;
+
+		const callbacks = {
+			adFinished: () => {
+				if (typeof this.onAdClosed === 'function') {
+					this.onAdClosed({
+						adType,
+						adProvider,
+					});
+				}
+
+				if (typeof this.onAdRewarded === 'function') {
+					this.onAdRewarded({
+						adType,
+						adProvider,
+					});
+				}
+			},
+			adError: (error) => {
+				if (typeof this.onAdError === 'function') {
+					this.onAdError({
+						error,
+						adType,
+						adProvider,
+					});
+				}
+			},
+			adStarted: () => {
+				if (typeof this.onAdOpened === 'function') {
+					this.onAdOpened({
+						adType,
+						adProvider,
+					});
+				}
+			},
+		};
+
+		globalThis.CrazyGames.SDK.ad.requestAd('rewarded', callbacks);
+	}
+
+	async loadRewardedAd() {
+		console.log('CrazyGames.loadRewardedAd');
+
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (!this.isSetup) {
+			await this.setupAds();
+		}
+	}
 }