@chiyou/minigame-framework 1.0.0

package/dist/Framework/Adapter/PlatformAdapter/PlatformAdapterZhiFuBao.js

@@ -0,0 +1,393 @@
+import { AbsPlatformAdapter } from './AbsPlatformAdapter';
+import { LogUtils } from '../../Utils/LogUtils';
+import { AuthorizeResult, GetSettingResult } from '../../Definition/PrivacyDefinition';
+import { ScreenInfo } from '../../Definition/SystemDefinition';
+export class PlatformAdapterZhiFuBao extends AbsPlatformAdapter {
+    // Common
+    init() {
+    }
+    onLoadingStart() {
+    }
+    onLoadingFinish(args) {
+    }
+    exitGame() {
+        if (window["my"] && window["my"].exitProgram) {
+            LogUtils.Instance.log("my.exitProgram");
+            window["my"].exitProgram();
+        }
+    }
+    getSDKVersion() {
+        if (window["my"]) {
+            return window["my"].SDKVersion;
+        }
+        return "";
+    }
+    downloadFile(fileUrl, success, fail) {
+        if (window["my"] && window["my"].downloadFile) {
+            LogUtils.Instance.log("my.downloadFile");
+            window["my"].downloadFile({
+                url: fileUrl,
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                    if (success) {
+                        success(res.tempFilePath);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail(err);
+                    }
+                },
+            });
+        }
+    }
+    requestGet(url, success, fail) {
+        if (window["my"] && window["my"].request) {
+            LogUtils.Instance.log("my.request");
+            window["my"].request({
+                url: url,
+                dataType: 'text',
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (success) {
+                        success(res.data);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail(err);
+                    }
+                }
+            });
+        }
+    }
+    requestPost(url, data, success, fail) {
+        if (window["my"] && window["my"].request) {
+            LogUtils.Instance.log("my.request");
+            window["my"].request({
+                url: url,
+                method: "POST",
+                data: data,
+                dataType: 'text',
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (success) {
+                        success(res.data);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail(err);
+                    }
+                }
+            });
+        }
+    }
+    configPassiveShare(title, desc, imageUrl, templateId, query) {
+    }
+    activeShareToFriend(callback, title, desc, imageUrl, templateId, query) {
+    }
+    getScreenInfo() {
+        if (window["my"] && window["my"].getSystemInfoSync) {
+            LogUtils.Instance.log("my.getSystemInfoSync");
+            let systemInfo = window["my"].getSystemInfoSync();
+            if (systemInfo !== null) {
+                return new ScreenInfo(systemInfo.windowWidth, systemInfo.windowHeight, systemInfo.screenWidth, systemInfo.screenHeight);
+            }
+        }
+        return new ScreenInfo(0, 0, 0, 0);
+    }
+    navigateToMiniProgram(appid, path) {
+        if (window["my"] && window["my"].navigateToMiniProgram) {
+            LogUtils.Instance.log("my.navigateToMiniProgram");
+            window["my"].navigateToMiniProgram({
+                appId: appid,
+                path: path,
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                }
+            });
+        }
+    }
+    reportEvent(eventId, data) {
+    }
+    getScreenBrightness(callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!(window["my"] && window["my"].getScreenBrightness)) {
+            callback(0);
+            return;
+        }
+        LogUtils.Instance.log("my.getScreenBrightness");
+        window["my"].getScreenBrightness({
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                    callback(res.value);
+                }
+                else {
+                    callback(0);
+                }
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+                callback(0);
+            }
+        });
+    }
+    setScreenBrightness(value) {
+        if (window["my"] && window["my"].setScreenBrightness) {
+            LogUtils.Instance.log("my.setScreenBrightness");
+            window["my"].setScreenBrightness({
+                brightness: value,
+            });
+        }
+    }
+    setKeepScreenOn(keepScreenOn) {
+        if (window["my"] && window["my"].setKeepScreenOn) {
+            LogUtils.Instance.log("my.setKeepScreenOn");
+            window["my"].setKeepScreenOn({
+                keepScreenOn: keepScreenOn,
+            });
+        }
+    }
+    updateColdStartScene() {
+        this.coldStartOptions = null;
+        this.coldStartScene = "";
+        if (window["my"] && window["my"].getLaunchOptionsSync) {
+            this.coldStartOptions = window["my"].getLaunchOptionsSync();
+            if (this.coldStartOptions !== null && this.coldStartOptions["scene"]) {
+                this.coldStartScene = this.coldStartOptions["scene"];
+            }
+        }
+        LogUtils.Instance.log("my updateColdStartScene", "scene=" + this.coldStartScene);
+    }
+    updateWarmStartScene(warmStartOptions) {
+        this.warmStartOptions = warmStartOptions;
+        this.warmStartScene = "";
+        if (this.warmStartOptions !== null && this.warmStartOptions["scene"]) {
+            this.warmStartScene = this.warmStartOptions["scene"];
+        }
+        LogUtils.Instance.log("my updateWarmStartScene", "scene=" + this.warmStartScene);
+    }
+    onShow(fn) {
+        if (window["my"] && window["my"].onShow) {
+            window["my"].onShow(fn);
+        }
+    }
+    offShow(fn) {
+        if (window["my"] && window["my"].offShow) {
+            window["my"].offShow(fn);
+        }
+    }
+    onHide(fn) {
+        if (window["my"] && window["my"].onHide) {
+            window["my"].onHide(fn);
+        }
+    }
+    offHide(fn) {
+        if (window["my"] && window["my"].offHide) {
+            window["my"].offHide(fn);
+        }
+    }
+    isRecentUseAvailable() {
+        return false;
+    }
+    isNavigateToRecentUseAvailable(callback) {
+        if (callback === null) {
+            return;
+        }
+        callback(false);
+    }
+    navigateToRecentUse() {
+    }
+    isLaunchFromRecentUse() {
+        let recentUseSceneSet = new Set([
+            "1000",
+            "1001",
+            "1002",
+            "1003",
+        ]);
+        let isLaunchFromRecentUse = recentUseSceneSet.has(this.coldStartScene) || recentUseSceneSet.has(this.warmStartScene);
+        LogUtils.Instance.log("my isLaunchFromRecentUse", isLaunchFromRecentUse);
+        return isLaunchFromRecentUse;
+    }
+    isLaunchFromDesktopShortcut() {
+        let desktopShortcutSceneSet = new Set([
+            "1023",
+        ]);
+        let isLaunchFromDesktopShortcut = desktopShortcutSceneSet.has(this.coldStartScene) || desktopShortcutSceneSet.has(this.warmStartScene);
+        LogUtils.Instance.log("my isLaunchFromDesktopShortcut", isLaunchFromDesktopShortcut);
+        return isLaunchFromDesktopShortcut;
+    }
+    isLaunchFromAdvertisement() {
+        let advertisementSceneSet = new Set([
+            "1400",
+        ]);
+        let isLaunchFromAdvertisement = advertisementSceneSet.has(this.coldStartScene);
+        LogUtils.Instance.log("wx isLaunchFromAdvertisement", isLaunchFromAdvertisement);
+        return isLaunchFromAdvertisement;
+    }
+    checkSession(success, fail) {
+        if (success) {
+            success();
+        }
+    }
+    login(success, fail) {
+        if (window["my"] && window["my"].getAuthCode) {
+            LogUtils.Instance.log("my.getAuthCode");
+            window["my"].getAuthCode({
+                scopes: "auth_base",
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                    if (success) {
+                        success(res.authCode, "");
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail(true);
+                    }
+                },
+            });
+        }
+        else {
+            LogUtils.Instance.log("my.getAuthCode", "no function");
+            if (fail) {
+                fail(true);
+            }
+        }
+    }
+    requirePrivacyAuthorize(callback) {
+        if (callback === null) {
+            return;
+        }
+        callback(true);
+    }
+    getSetting(scope, callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!window["my"] || !window["my"].getSetting) {
+            callback(GetSettingResult.Result_SettingNotAvailable);
+            return;
+        }
+        LogUtils.Instance.log("my.getSetting", "scope=" + scope);
+        window["my"].getSetting({
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                }
+                if (res?.authSetting?.hasOwnProperty(scope)) {
+                    if (res.authSetting[scope]) {
+                        callback(GetSettingResult.Result_Authorized);
+                    }
+                    else {
+                        callback(GetSettingResult.Result_Rejected);
+                    }
+                }
+                else {
+                    callback(GetSettingResult.Result_NotExist_AuthorizeNotAvailable);
+                }
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+                callback(GetSettingResult.Result_Rejected);
+            },
+        });
+    }
+    openSetting(scope, callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!window["my"] || !window["my"].openSetting) {
+            callback(-1);
+            return;
+        }
+        LogUtils.Instance.log("my.openSetting", "scope=" + scope);
+        window["my"].openSetting({
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                }
+                if (res?.authSetting?.hasOwnProperty(scope)) {
+                    if (res.authSetting[scope]) {
+                        callback(1);
+                    }
+                    else {
+                        callback(0);
+                    }
+                }
+                else {
+                    callback(0);
+                }
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+                callback(0);
+            },
+        });
+    }
+    authorize(scope, callback) {
+        if (callback === null) {
+            return;
+        }
+        callback(AuthorizeResult.Result_AuthorizeNotAvailable);
+    }
+    setRankData(args) {
+    }
+    showRankList(args) {
+    }
+    openPortalGame() {
+    }
+    openGameClub() {
+    }
+    openRecommendToFriend() {
+    }
+    openRecommendToGameClub() {
+    }
+}

package/dist/Framework/Definition/AdDefinition.d.ts

@@ -0,0 +1,130 @@
+import { PlatformID } from "./SystemDefinition";
+export declare enum AdType {
+    Type_Banner = 0,
+    Type_Custom = 1,
+    Type_Interstitial = 2,
+    Type_RewardedVideo = 3,
+    Type_Portal = 4
+}
+export type InterstitialAd_Scene = string;
+export type RewardedVideoAd_Scene = string;
+export declare class AdCallback {
+    callback: Function;
+    target: any;
+    constructor(callback: Function, target: any);
+}
+export declare class RewardedVideoAd_Record {
+    clickCount: number;
+    viewCount: number;
+    completeCount: number;
+    giveupCount: number;
+    errorCount: number;
+    constructor();
+}
+export declare class InterstitialAd_Record {
+    viewCount: number;
+    completeCount: number;
+    errorCount: number;
+    constructor();
+}
+export declare class Ad_Record {
+    intersitialAdRecord: Map<InterstitialAd_Scene, InterstitialAd_Record>;
+    rewardedVideoAdRecord: Map<InterstitialAd_Scene, RewardedVideoAd_Record>;
+    constructor();
+}
+export declare enum InterstitialAd_Callback_Status {
+    Status_NotSupport = -2,
+    Status_Error = -1,
+    Status_Close = 0,
+    Status_Watching = 1,
+    Status_InsufficientInterval = 2
+}
+export declare enum RewardedVideoAd_Callback_Status {
+    Status_NotSupport = -2,
+    Status_Error = -1,
+    Status_Complete = 0,
+    Status_Giveup = 1,
+    Status_Watching = 2
+}
+export declare enum AdSwitchType {
+    Off = 0,
+    On_Debug = 1,
+    On_Release = 2
+}
+export type AdPlatformUnitInfo = {
+    switchType: AdSwitchType;
+    intersitialAd: string;
+    rewardedVideoAd: string;
+    bannerAd: string;
+    customAd: string;
+    portalAd: string;
+};
+export type AdPlatformSettingInfo = {
+    launchNoAdInterval_permanentAd: number;
+    launchNoAdInterval_interstitialAd: number;
+    registerUser_interstitialAd_IntervalBase: number;
+    retainUser_interstitialAd_IntervalBase: number;
+};
+export declare enum BannerAd_XPosition {
+    Center = 0,
+    Left = 1,
+    Right = 2
+}
+export declare enum BannerAd_YPosition {
+    Center = 0,
+    Top = 1,
+    Bottom = 2
+}
+export type BannerAd_Info = {
+    xPosition: BannerAd_XPosition;
+    yPosition: BannerAd_YPosition;
+    shouldShow: boolean;
+};
+export type BannerAd_PlatformInfo = {
+    xMargin: number;
+    yMargin: number;
+    width: number;
+    height: number;
+    scaleRatio: number;
+    canAutoRefresh: boolean;
+    refreshInterval: number;
+};
+export declare enum CustomAd_XPosition {
+    Center = 0,
+    Left = 1,
+    Right = 2
+}
+export declare enum CustomAd_YPosition {
+    Center = 0,
+    Top = 1,
+    Bottom = 2
+}
+export type CustomAd_Info = {
+    xPostion: CustomAd_XPosition;
+    yPostion: CustomAd_YPosition;
+    shouldShow: boolean;
+};
+export type CustomAd_PlatformInfo = {
+    xMargin: number;
+    yMargin: number;
+    width: number;
+    height: number;
+    scaleRatio: number;
+    canAutoRefresh: boolean;
+    refreshInterval: number;
+};
+export type PortalAd_PlatformInfo = {
+    width: number;
+    height: number;
+    scaleRatio: number;
+};
+export declare class AdDefinition {
+    static readonly AdInfoConfig: {
+        new (): {};
+        CustomAd_Info: CustomAd_Info;
+        BannerAd_Info: BannerAd_Info;
+    };
+    static readonly CustomAdStyleConfig: Map<PlatformID, CustomAd_PlatformInfo>;
+    static readonly BannerAdStyleConfig: Map<PlatformID, BannerAd_PlatformInfo>;
+    static readonly PortalAdStyleConfig: Map<PlatformID, PortalAd_PlatformInfo>;
+}