@cardsjd/portal 0.1.1 → 0.1.3

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 loadInterstitialAd() {
+		if (this.isSetup === false) {
+			return;
+		}
+
+		if (this.isAdLoaded()) {
+			return;
+		}
+
+		return AdMob.prepareInterstitial({
+			adId: this.appConfig?.interstitialAdId,
+		});
+	}
+
+	async showInterstitialAd() {
+		if (!this.isAdLoaded()) {
+			await this.loadInterstitialAd();
+			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/Advertisement.js

@@ -0,0 +1,99 @@
+export class Advertisement {
+    isInterstitialAdReady(options) {
+		//only load/show if ads enabled
+		if (this.isSetup === false) { return; }
+
+		const config = this.config;
+		const offsetStartdelay = options?.offsetStartdelay || config.offsetStartdelay || 120;  //start with 1 min passed to get the first ad to show faster
+		const delayBetweenAds = options?.delayBetweenAds || config.delayBetweenAds || 240;  //check for  240 (4 min) seconds passed was 180
+		const awayResetTime = options?.awayResetTime || config.awayResetTime || 1200;  //check if over 20 min, may have not been in the app and reopened it with out restarting
+		const delayBetweenRewardedAds = options?.delayBetweenRewardedAds || config.delayBetweenRewardedAds || 300;  //check for  600 seconds passed
+
+
+		//0. if ads removed, dont even load the ad
+		//1. only allow ad to be shown/loaded once every 150 second (Advertisement.delayBetweenAds)
+		//2. check if over 20 min, may have not been in the app and reopened it with out restarting 
+		//3. load ad ether way
+		//4. show ad if conditions met
+		if (this.removeAds) { return false; }
+
+		let readyToShowAd = false;
+
+		//reset timer
+		if (this.lastShownInterstitial === null) {
+			this.lastShownInterstitial = Date.now();//now
+			//add start offset delay
+			const newDate = new Date();
+			newDate.setSeconds(newDate.getSeconds() - offsetStartdelay);
+			this.lastShownInterstitial = newDate;
+		}
+
+		const secondsSinceLastAd = (Date.now() - this.lastShownInterstitial) / 1000;
+
+		//check for  delayBetweenAds seconds passed
+		if (secondsSinceLastAd > delayBetweenAds) {
+			readyToShowAd = true;
+		}
+
+		//check if over 20 min, may have not been in the app and reopened it with out restarting 
+		if (secondsSinceLastAd > awayResetTime) {
+			readyToShowAd = false;
+			this.lastShownInterstitial = Date.now();//now, reset
+		}
+
+		console.log('readyToShowInterstitialAd: ' + readyToShowAd + ' : ' + secondsSinceLastAd + ' of ' + delayBetweenAds);
+
+		// show ad or just load ad
+		if (readyToShowAd) {
+			true;
+		} else {
+			false;
+		}
+	}
+	async showAppOpenAdWithMaxDelay(maxDelay) {
+		if (this.isSetUp === false) { return; }
+		if (this.adProvider == null) { return; }
+
+
+
+		if (!maxDelay) {
+			maxDelay = 4000;
+		}
+
+		//todo: fix if long loader time than maxDelay, then skip ad
+		//something like this:
+		//return new Promise(async (resolve, reject) => {
+		// if (this.adProvider && this.adProvider.showAppOpenAd) {
+		//     timeoutPromise = setTimeout(() => {
+		//         //stop ad from showing
+		//         if (this.adProvider) this.adProvider.appOpenAdAutoShow = false;
+		//         reject(new Error('showAppOpenAd has not fired after 4 seconds. Skipping ad'));
+		//     }, maxDelay);
+		//     await this.adProvider.showAppOpenAd();
+		//     clearTimeout(timeoutPromise);
+		//     resolve();
+		// }
+		// else {
+		//     reject();
+		// }
+
+
+		//get start time
+		const startTime = Date.now();
+		if (this.adProvider.loadAppOpenAd) {
+			await this.adProvider.loadAppOpenAd();
+		}
+
+		//this wont work...
+		//is timer over maxDelay
+		const timePassed = Date.now() - startTime;
+		if (timePassed > maxDelay) {
+			console.log(`showAppOpenAdWithMaxDelay took too long to load [${timePassed}ms/${maxDelay}ms], skipping ad`);
+			return;
+		}
+
+		if (this.adProvider.showAppOpenAd) {
+			await this.adProvider.showAppOpenAd();
+		}
+	}
+}

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

@@ -1,3 +1,4 @@
+import { Advertisement } from './Advertisement.js';
 export class BasePortal {
 
 	async init() { }
@@ -5,7 +6,7 @@ export class BasePortal {
 	async load() { }
 
 	async save(data, forceSave) { }
-	
+
 	async delete() { }
 
 	gameStart() { }
@@ -16,6 +17,8 @@ export class BasePortal {
 
 	loadStop() { }
 
+	subscribeBot() { }
+
 	async getInvite() { }
 
 	async inviteSend(user, room) { }
@@ -24,7 +27,36 @@ export class BasePortal {
 
 	async getFriends() { }
 
-	tryShowInterstitialAd() { }
+	tryShowInterstitialAd(options) {
+		const readyToShowAd = Advertisement.isInterstitialAdReady(options);
+		if (readyToShowAd) {
+			this.showInterstitialAd();
+		} else {
+			this.loadInterstitialAd();
+		}
+	}
+	
+	setupAds() { }
+
+	loadInterstitialAd(_force) { }
+
+	showInterstitialAd() { }
+
+	loadRewardedAd(_onLoaded) { }
+
+	showRewardedAd() { }
+
+	loadAppOpenAd() { }
+
+	showAppOpenAd(maxDelay) { }
+
+	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 loadInterstitialAd() {
+		console.log('CrazyGames.loadAd');
+
+		if (!this.isCrazyGames()) {
+			return false;
+		}
+
+		if (!this.isSetup) {
+			await this.setupAds();
+		}
+	}
+
+	async showInterstitialAd() {
+		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();
+		}
+	}
 }