@cardsjd/portal 0.1.1 → 0.1.3

package/lib/FacebookPortal.js

@@ -5,18 +5,31 @@ export class FacebookPortal extends BasePortal {
 	name = 'FacebookPortal';
 	fBInstantGame = null;
 
-	constructor(config, advertisementConfig) {
+	constructor(appConfig) {
 		super();
-		this.fBInstantGame = new FBInstantGame(config);
-		this.advertisementConfig = advertisementConfig;
+		this.fBInstantGame = new FBInstantGame(appConfig);
+
+		this.appConfig = appConfig;
+
+		// Ad state
+		this.preloadedInterstitial = null;
+		this.preloadedRewardedVideo = null;
+		this._isAdLoading = false;
+		this._isAdLoaded = false;
+		this._isRewardedAdLoading = false;
+		this._isRewardedAdLoaded = false;
+		this._errorCount = 0;
+		this._errorCountMax = 6;
 	}
+
 	async init() {
 		await this.fBInstantGame.initialize();
 	}
-	isAvailable() {
 
+	isAvailable() {
 		return true;
 	}
+
 	async load() {
 		const fbUserdata = await this.fBInstantGame.loadData();
 		const fbProfile = await this.fBInstantGame.getProfile();
@@ -25,9 +38,11 @@ export class FacebookPortal extends BasePortal {
 		data.user = fbProfile;
 		return data;
 	}
+
 	async save(data, forceSave) {
 		this.fBInstantGame.saveData(data, forceSave).catch(function () { });
 	}
+
 	gameStart() {
 	}
 
@@ -51,31 +66,418 @@ export class FacebookPortal extends BasePortal {
 	async subscribeBot() {
 		await this.fBInstantGame.subscribeBot();
 	}
+
 	createShortCut() {
 		this.fBInstantGame.createShortcut();
 	}
+
 	async getInvite() {
 		//returns {message,room}
 		return this.fBInstantGame.getInvite();
 	}
+
 	async invite(userId, room) {
 		return this.fBInstantGame.invitePlayer(userId, room);
 	}
+
 	async findAndInvite(userFrom, room) {
 		return this.fBInstantGame.inviteSend(userFrom, room);
 	}
+
 	async getFriends() {
 		const fbUsers = await this.fBInstantGame.getConnectedPlayersAsync();
-		if (!fbUsers) return [];
+		if (!fbUsers) {
+			return [];
+		}
+
 		const friends = [];
 		for (let i = 0; i < fbUsers.length; i++) {
 			const fbUser = fbUsers[i];
 
 			//Facebook only gaves the facebookid, no name or userid
 			const facebookId = fbUser.getID();
-			friends.push({ facebookId: facebookId });
+			friends.push({
+				facebookId: facebookId,
+			});
 		}
+
 		return friends;
 	}
 
+	// ----- Ad methods -----
+
+	setupAds() {
+		console.log('FB_Ads.setup');
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		this.isSetup = true;
+		return true;
+	}
+
+	isApiSupported(apiName) {
+		if (!globalThis.FBInstant) {
+			return false;
+		}
+
+		if (typeof globalThis.FBInstant[apiName] !== 'function') {
+			return false;
+		}
+
+		if (typeof globalThis.FBInstant.getSupportedAPIs !== 'function') {
+			return true;
+		}
+
+		try {
+			const supported = globalThis.FBInstant.getSupportedAPIs();
+			if (!Array.isArray(supported)) {
+				return true;
+			}
+
+			return supported.includes(apiName);
+		} catch (_ex) {
+			return true;
+		}
+	}
+
+	isErrorState() {
+		const isErrorState = this._errorCount > this._errorCountMax;
+		return isErrorState;
+	}
+
+	logError(errorCode) {
+		if (errorCode === 'ADS_NO_FILL') {
+			return;
+		}
+
+		if (errorCode === 'CLIENT_UNSUPPORTED_OPERATION') {
+			this._errorCount = this._errorCountMax;
+		}
+
+		this._errorCount = (this._errorCount || 0) + 1;
+	}
+
+	loadInterstitialAd(force) {
+		console.log('FB_Ads.loadInterstitialAd');
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		if (!force && this._isAdLoading) {
+			console.log('FBInstant.loadInterstitialAd() - _isAdLoading = true');
+			return true;
+		}
+
+		if (!force && this._isAdLoaded) {
+			console.log('FBInstant.loadInterstitialAd() - _isAdLoaded = true');
+			return true;
+		}
+
+		if (!force && this.isErrorState()) {
+			console.log('FBInstant.loadInterstitialAd() - ErrorState = true');
+			return true;
+		}
+
+		this._isAdLoading = true;
+
+		const interstitialAdId = this.appConfig?.interstitalAdId;
+
+		console.log('FB_Ads.getInterstitialAdAsync start: ' + interstitialAdId);
+		if (!this.isApiSupported('getInterstitialAdAsync')) {
+			this._isAdLoading = false;
+			this._isAdLoaded = false;
+			this.logError('CLIENT_UNSUPPORTED_OPERATION');
+			console.warn('FBInstant.getInterstitialAdAsync is not supported on this client');
+			return false;
+		}
+
+		console.log('FB_Ads.getInterstitialAdAsync start: ' + this.appId);
+
+		try {
+			globalThis.FBInstant.getInterstitialAdAsync(
+				interstitialAdId, // Your Ad Placement Id
+			).then((interstitial) => {
+				console.log('FB_Ads.getInterstitialAdAsync finished');
+				// Load the Ad asynchronously
+				this.preloadedInterstitial = interstitial;
+				return this.preloadedInterstitial.loadAsync();
+			}).then(() => {
+				this._isAdLoading = false;
+				this._isAdLoaded = true;
+
+				if (this.onAdLoaded) {
+					this.onAdLoaded({
+						adType: 'interstitial',
+					});
+				}
+
+				console.log('onAdLoaded: Interstitial preloaded');
+			}).catch((err) => {
+				this._isAdLoading = false;
+				this._isAdLoaded = false;
+
+				this.logError(err.code);
+
+				console.error('InterstitialAd  Error: ' + err.message + ' ' + err.code);
+			});
+		} catch (ex) {
+			console.error('FB_Ads.getInterstitialAdAsync error: ' + ex);
+		}
+	}
+
+	showInterstitialAd() {
+		console.log('FB_Ads.showInterstitialAd');
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		if (this.isErrorState()) {
+			console.log('FBInstant.showInterstitialAd() - ErrorState = true');
+			return true;
+		}
+
+		const isAdLoaded = this._isAdLoaded;
+
+		if (!isAdLoaded) {
+			this.loadInterstitialAd();
+		}
+
+		if (isAdLoaded) {
+			if (!this.preloadedInterstitial) {
+				console.log('FBInstant.showInterstitialAd() - error: preloadedInterstitial = null');
+				return false;
+			}
+
+			this.preloadedInterstitial.showAsync()
+				.then(() => {
+					// Perform post-ad success operation
+					console.log('Interstitial ad finished successfully');
+					this._isAdLoaded = false;
+
+					if (this.onAdClosed) {
+						this.onAdClosed({
+							adType: 'interstitial',
+						});
+					}
+				}).catch((err) => {
+
+					this.logError(err.code);
+					console.error('interstitialAd  Error: ' + err.message + ' ' + err.code);
+
+				});
+		}
+
+	}
+
+	loadAndShowInterstitialAd() {
+		console.log('FB_Ads.showAd');
+
+		if (this.isErrorState()) {
+			console.log('FBInstant.loadAndShowInterstitialAd() - isErrorState = true');
+			return true;
+		}
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		const interstitialAdId = this.appConfig?.interstitalAdId;
+		if (!this.isApiSupported('getInterstitialAdAsync')) {
+			this.logError('CLIENT_UNSUPPORTED_OPERATION');
+			console.warn('FBInstant.getInterstitialAdAsync is not supported on this client');
+			return false;
+		}
+		////FBInstant.isGameStarted is a custom attached property, not from facebook.  I am phaseing it out and hoping FBInstant will be ready when needed.
+		// if (!FBInstant.isGameStarted) {
+		//     console.log('FBInstant plugin not ready: FBInstant.isGameStarted = false, aborting');
+		//     return false;
+		// }
+
+		try {
+			globalThis.FBInstant.getInterstitialAdAsync(
+				interstitialAdId, // Your Ad Placement Id
+			).then((interstitial) => {
+				console.log('FB_Ads.getInterstitialAdAsync finished');
+				// Load the Ad asynchronously
+				this.preloadedInterstitial = interstitial;
+				return this.preloadedInterstitial.loadAsync();
+			}).then(() => {
+				if (this.onAdLoaded) {
+					this.onAdLoaded({
+						adType: 'interstitial',
+					});
+				}
+
+				console.log('onAdLoaded: Interstitial preloaded');
+				return this.preloadedInterstitial.showAsync();
+			}).then(() => {
+				// Perform post-ad success operation
+				console.log('Interstitial ad finished successfully');
+
+				this._isAdLoaded = false;
+
+				if (this.onAdClosed) {
+					this.onAdClosed({
+						adType: 'interstitial',
+					});
+				}
+			}).catch((err) => {
+
+				this.logError(err.code);
+				console.error('InterstitialAd  Error: ' + err.message + ' ' + err.code);
+
+			});
+
+		} catch (ex) {
+			console.error('FB_Ads.getInterstitialAdAsync error: ' + ex);
+		}
+	}
+
+	isAdLoaded() {
+		return this._isAdLoaded;
+	}
+
+	isRewardedAdLoaded() {
+		return this._isRewardedAdLoaded;
+	}
+
+	loadRewardedAd(onLoaded) {
+		console.log('FB_Ads.loadRewardedAd');
+
+		if (this.isErrorState()) {
+			console.log('FBInstant.loadRewardedAd() - isErrorState = true');
+			return true;
+		}
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		const isAdLoaded = this._isRewardedAdLoaded;
+
+		if (!isAdLoaded) {
+			const rewardedAdId = this.appConfig?.rewardAdId;
+			if (!this.isApiSupported('getRewardedVideoAsync')) {
+				this._isRewardedAdLoaded = false;
+				this.logError('CLIENT_UNSUPPORTED_OPERATION');
+				console.warn('FBInstant.getRewardedVideoAsync is not supported on this client');
+				return false;
+			}
+
+			try {
+				globalThis.FBInstant.getRewardedVideoAsync(
+					rewardedAdId, // Your Ad Placement Id
+				).then((rewarded) => {
+					console.log('FB_Ads.getRewardedVideoAsync finished');
+					// Load the Ad asynchronously
+					this.preloadedRewardedVideo = rewarded;
+					return this.preloadedRewardedVideo.loadAsync();
+				}).then(() => {
+					if (this.onAdLoaded) {
+						this.onAdLoaded({
+							adType: 'rewarded',
+						});
+					}
+
+					console.log('onAdLoaded: Rewarded preloaded');
+					this._isRewardedAdLoaded = true;
+
+					if (onLoaded) {
+						onLoaded();
+					}
+
+				}).catch((err) => {
+
+					this.logError(err.code);
+					console.error('loadRewardedAd  Error: ' + err.message + ' ' + err.code);
+
+				});
+			} catch (ex) {
+				console.error('FB_Ads.getRewardedVideoAsync error: ' + ex);
+			}
+		}
+
+		if (isAdLoaded) {
+			console.log('requestRewardedAd is already loaded');
+		}
+
+	}
+
+	showRewardedAd() {
+		console.log('FB_Ads.ShowRewardedAd');
+
+		if (this.isErrorState()) {
+			console.log('FBInstant.ShowRewardedAd() - isErrorState = true');
+			return true;
+		}
+
+		if (typeof FBInstant === 'undefined' || !globalThis.FBInstant) {
+			console.log('FBInstant plugin not ready'); return false;
+		}
+
+		const isAdLoaded = this._isRewardedAdLoaded;
+
+		if (!isAdLoaded) {
+			//change to auto play
+			this.loadRewardedAd(() => {
+				this.preloadedRewardedVideo.showAsync()
+					.then(() => {
+						// Perform post-ad success operation
+						console.log('Rewarded ad finished successfully');
+						this._isRewardedAdLoaded = false;
+
+						if (this.onAdClosed) {
+							this.onAdClosed({
+								adType: 'rewarded',
+							});
+						}
+
+						if (this.onAdRewarded) {
+							this.onAdRewarded({
+								adType: 'rewarded',
+								rewardAmount: 150,
+							});
+						}
+					}).catch((err) => {
+						this.logError(err.code);
+						console.error('RewardedAd  Error: ' + err.message + ' ' + err.code);
+					});
+			});
+		}
+
+		if (isAdLoaded) {
+			this.preloadedRewardedVideo.showAsync()
+				.then(() => {
+					// Perform post-ad success operation
+					console.log('Rewarded ad finished successfully');
+					this._isRewardedAdLoaded = false;
+
+					if (this.onAdClosed) {
+						this.onAdClosed({
+							adType: 'rewarded',
+						});
+					}
+
+					if (this.onAdRewarded) {
+						this.onAdRewarded({
+							adType: 'rewarded',
+							rewardAmount: 150,
+						});
+					}
+				}).catch((err) => {
+
+					if (err && err.code === 'ADS_NO_FILL') { /* squelch */ } else {
+						this.logError();
+					}
+
+					console.error('RewardedAd  Error: ' + err.message + ' ' + err.code);
+
+				});
+		}
+
+	}
 }

package/lib/GameDistributionPortal.js

@@ -1,72 +1,107 @@
 import { BasePortal } from './BasePortal';
 
-const isGameDistribution = () => typeof globalThis.gdsdk !== 'undefined';
+const AdType = {
+	Rewarded: 'rewarded',
+	Interstitial: 'interstitial',
+};
 
-export class GameDistributionPortal extends BasePortal {
+export class GameDistribution extends BasePortal {
 	name = 'GameDistributionPortal';
-	isInitialized = false;
-	isError = false;
+	autoLogin = false;
 
-	async init() {
+	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 = 'GameDistribution';
+		this.isSetup = false;
+		this.isRewardedAdReady = false;
+		this.isInterstitialAdReady = false;
+	}
+
+	isReady() {
+		if (typeof globalThis.gdsdk === 'undefined') {
+			console.log('GameDistribution sdk not ready');
+			return false;
+		}
+
+		return true;
+	}
+
+	// ----- Ad methods -----
+
+	async setupAds() {
+		if (!this.isReady()) {
+			return false;
+		}
+
+		if (this.isSetup) {
+			return true;
+		}
+
+		this.isSetup = true;
+
+		return true;
 	}
 
-	async load(userdata, advertisementConfig) {
-		if (!this.isInitialized && advertisementConfig.gameDistributionId) {
-			await this.#doInit(advertisementConfig.gameDistributionId);
+	async loadInterstitialAd() {
+		if (!this.isReady()) {
+			return false;
 		}
 
-		if (!isGameDistribution()) {
-			return;
+		try {
+			await globalThis.gdsdk.preloadAd(AdType.Interstitial);
+			this.isInterstitialAdReady = true;
+		} catch {
+			this.isInterstitialAdReady = false;
 		}
 	}
 
-	tryShowInterstitialAd() {
-		if (!isGameDistribution()) {
-			return;
+	async showInterstitialAd() {
+		if (!this.isReady()) {
+			return false;
 		}
 
-		globalThis?.gdsdk?.showAd?.();
+		return globalThis.gdsdk.showAd(AdType.Interstitial);
+	}
+
+	isAdLoaded() {
+		return this.isInterstitialAdReady;
 	}
 
-	async #doInit(gameId) {
-		if (!this.isError) {
-			globalThis.GD_OPTIONS = {
-				gameId,
-				onEvent: (event) => {
-					this.#handleEvent(event);
-				},
-			};
+	isRewardedAdLoaded() {
+		return this.isRewardedAdReady;
+	}
 
+	async loadRewardedAd() {
+		if (!this.isReady()) {
+			return false;
+		}
+
+		(async () => {
 			try {
-				await import('https://html5.api.gamedistribution.com/main.min.js');
-				this.isInitialized = true;
-			} catch (err) {
-				console.error('Failed to load GameDistribution');
-				this.isError = true;
+				await globalThis.gdsdk.preloadAd(AdType.Rewarded);
+				this.isRewardedAdReady = true;
+
+			} catch (er) {
+				this.isRewardedAdReady = false;
 			}
-		}
+
+		})();
 	}
 
-	async #handleEvent(event) {
-		console.log('got event from GD', event);
-
-		switch (event.name) {
-			case 'SDK_GAME_START':
-				// advertisement done, resume game logic and unmute audio
-				break;
-			case 'SDK_GAME_PAUSE':
-				// pause game logic / mute audio
-				break;
-			case 'SDK_GDPR_TRACKING':
-				// this event is triggered when your user doesn't want to be tracked
-				break;
-			case 'SDK_GDPR_TARGETING':
-				// this event is triggered when your user doesn't want personalised targeting of ads and such
-				break;
-			case 'SDK_REWARDED_WATCH_COMPLETE':
-				// this event is triggered when your user completely watched rewarded ad
-				break;
+	showRewardedAd() {
+		if (!this.isReady()) {
+			return false;
 		}
+
+		return globalThis.gdsdk.showAd(AdType.Rewarded);
 	}
-}
+}