@chiyou/minigame-framework 1.0.0

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

@@ -0,0 +1,715 @@
+import { AbsPlatformAdapter } from './AbsPlatformAdapter';
+import { LogUtils } from '../../Utils/LogUtils';
+import { AuthorizeResult, GetSettingResult } from '../../Definition/PrivacyDefinition';
+import { ScreenInfo } from '../../Definition/SystemDefinition';
+class DouYinPlatformBusiness {
+    constructor() {
+        this.gameClub_path = "";
+    }
+}
+export class PlatformAdapterDouYin extends AbsPlatformAdapter {
+    constructor() {
+        super(...arguments);
+        this.portalGame = null;
+        this.business = new DouYinPlatformBusiness();
+    }
+    // Common
+    init() {
+        this.portalGame = null;
+    }
+    onLoadingStart() {
+    }
+    onLoadingFinish(args) {
+        this.business.gameClub_path = args[0];
+        this.initPortalGame();
+    }
+    exitGame() {
+        if (window["tt"] && window["tt"].exitMiniProgram) {
+            LogUtils.Instance.log("tt.exitMiniProgram");
+            window["tt"].exitMiniProgram({});
+        }
+    }
+    getSDKVersion() {
+        if (window["tt"] && window["tt"].getSystemInfoSync) {
+            LogUtils.Instance.log("tt.getSystemInfoSync");
+            let systemInfo = window["tt"].getSystemInfoSync();
+            if (systemInfo !== null) {
+                return systemInfo.SDKVersion;
+            }
+        }
+        return "";
+    }
+    requestGet(url, success, fail) {
+        if (window["tt"] && window["tt"].request) {
+            LogUtils.Instance.log("tt.request");
+            window["tt"].request({
+                url: url,
+                dataType: "string",
+                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["tt"] && window["tt"].request) {
+            LogUtils.Instance.log("tt.request");
+            window["tt"].request({
+                url: url,
+                method: "POST",
+                data: data,
+                dataType: "string",
+                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);
+                    }
+                }
+            });
+        }
+    }
+    downloadFile(fileUrl, success, fail) {
+        if (window["tt"] && window["tt"].downloadFile) {
+            LogUtils.Instance.log("tt.downloadFile");
+            window["tt"].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);
+                    }
+                },
+            });
+        }
+    }
+    configPassiveShare(title, desc, imageUrl, templateId, query) {
+        if (window["tt"] && window["tt"].showShareMenu) {
+            LogUtils.Instance.log("tt.showShareMenu");
+            window["tt"].showShareMenu({});
+        }
+        if (window["tt"] && window["tt"].onShareAppMessage) {
+            window["tt"].onShareAppMessage((res) => {
+                LogUtils.Instance.log("tt.onShareAppMessage");
+                LogUtils.Instance.log("", "channel=" + res.channel);
+                return {
+                    title: title,
+                    desc: desc,
+                    imageUrl: imageUrl,
+                    templateId: templateId,
+                    query: query,
+                    success: () => {
+                        LogUtils.Instance.log("", "success");
+                    },
+                    fail: (err) => {
+                        LogUtils.Instance.log("", "fail");
+                        if (err) {
+                            LogUtils.Instance.log("", err);
+                        }
+                    }
+                };
+            });
+        }
+    }
+    activeShareToFriend(callback, title, desc, imageUrl, templateId, query) {
+        // 通过callback回调
+        if (window["tt"] && window["tt"].shareAppMessage) {
+            LogUtils.Instance.log("tt.shareAppMessage");
+            window["tt"].shareAppMessage({
+                title: title,
+                desc: desc,
+                imageUrl: imageUrl,
+                templateId: templateId,
+                query: query,
+                success() {
+                    LogUtils.Instance.log("", "success");
+                    if (callback) {
+                        callback(true);
+                    }
+                },
+                fail(err) {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (callback) {
+                        callback(false);
+                    }
+                }
+            });
+        }
+    }
+    getScreenInfo() {
+        if (window["tt"] && window["tt"].getSystemInfoSync) {
+            LogUtils.Instance.log("tt.getSystemInfoSync");
+            let systemInfo = window["tt"].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["tt"] && window["tt"].navigateToMiniProgram) {
+            LogUtils.Instance.log("tt.navigateToMiniProgram");
+            window["tt"].navigateToMiniProgram({
+                appId: appid,
+                path: path,
+            });
+        }
+    }
+    reportEvent(eventId, data) {
+        if (window["tt"] && window["tt"].reportAnalytics) {
+            LogUtils.Instance.log("tt.reportAnalytics");
+            window["tt"].reportAnalytics(eventId, data);
+        }
+    }
+    getScreenBrightness(callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!(window["tt"] && window["tt"].getScreenBrightness)) {
+            callback(0);
+            return;
+        }
+        LogUtils.Instance.log("tt.getScreenBrightness");
+        window["tt"].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");
+                callback(0);
+            }
+        });
+    }
+    setScreenBrightness(value) {
+        if (window["tt"] && window["tt"].setScreenBrightness) {
+            LogUtils.Instance.log("tt.setScreenBrightness");
+            window["tt"].setScreenBrightness({
+                value: value,
+            });
+        }
+    }
+    setKeepScreenOn(keepScreenOn) {
+        if (window["tt"] && window["tt"].setKeepScreenOn) {
+            LogUtils.Instance.log("tt.setKeepScreenOn");
+            window["tt"].setKeepScreenOn({
+                keepScreenOn: keepScreenOn,
+            });
+        }
+    }
+    updateColdStartScene() {
+        this.coldStartOptions = null;
+        this.coldStartScene = "";
+        if (window["tt"] && window["tt"].getLaunchOptionsSync) {
+            this.coldStartOptions = window["tt"].getLaunchOptionsSync();
+            if (this.coldStartOptions !== null && this.coldStartOptions["scene"]) {
+                this.coldStartScene = this.coldStartOptions["scene"];
+            }
+        }
+        LogUtils.Instance.log("tt 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("tt updateWarmStartScene", "scene=" + this.warmStartScene);
+    }
+    onShow(fn) {
+        if (window["tt"] && window["tt"].onShow) {
+            window["tt"].onShow(fn);
+        }
+    }
+    offShow(fn) {
+        if (window["tt"] && window["tt"].offShow) {
+            window["tt"].offShow(fn);
+        }
+    }
+    onHide(fn) {
+        if (window["tt"] && window["tt"].onHide) {
+            window["tt"].onHide(fn);
+        }
+    }
+    offHide(fn) {
+        if (window["tt"] && window["tt"].offHide) {
+            window["tt"].offHide(fn);
+        }
+    }
+    isNavigateToRecentUseAvailable(callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!(window["tt"] && window["tt"].checkScene)) {
+            callback(false);
+            return;
+        }
+        LogUtils.Instance.log("tt.checkScene");
+        window["tt"].checkScene({
+            scene: "sidebar",
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                    callback(res.isExist);
+                }
+                else {
+                    callback(false);
+                }
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                callback(false);
+            }
+        });
+    }
+    navigateToRecentUse() {
+        if (!(window["tt"] && window["tt"].navigateToScene)) {
+            return;
+        }
+        LogUtils.Instance.log("tt.navigateToScene");
+        window["tt"].navigateToScene({
+            scene: "sidebar",
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                }
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+            },
+        });
+    }
+    isLaunchFromRecentUse() {
+        let recentUseSceneSet = new Set([
+            "021036",
+            "021012",
+            "101036",
+            "011004",
+            "181003",
+            "061004",
+        ]);
+        let isLaunchFromRecentUse = recentUseSceneSet.has(this.coldStartScene) || recentUseSceneSet.has(this.warmStartScene);
+        LogUtils.Instance.log("tt isLaunchFromRecentUse", isLaunchFromRecentUse);
+        return isLaunchFromRecentUse;
+    }
+    isLaunchFromDesktopShortcut() {
+        let desktopShortcutSceneSet = new Set([
+            "021020",
+            "101020",
+            "181020",
+            "141020",
+            "991020",
+        ]);
+        let isLaunchFromDesktopShortcut = desktopShortcutSceneSet.has(this.coldStartScene) || desktopShortcutSceneSet.has(this.warmStartScene);
+        LogUtils.Instance.log("tt isLaunchFromDesktopShortcut", isLaunchFromDesktopShortcut);
+        return isLaunchFromDesktopShortcut;
+    }
+    isLaunchFromAdvertisement() {
+        let advertisementSceneSet = new Set([
+            "025001", "235001", "016001",
+            "016002", "016003", "105001",
+        ]);
+        let isLaunchFromAdvertisement = advertisementSceneSet.has(this.coldStartScene);
+        LogUtils.Instance.log("tt isLaunchFromAdvertisement", isLaunchFromAdvertisement);
+        return isLaunchFromAdvertisement;
+    }
+    checkSession(success, fail) {
+        if (window["tt"] && window["tt"].checkSession) {
+            LogUtils.Instance.log("tt.checkSession");
+            window["tt"].checkSession({
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                    if (success) {
+                        success();
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail();
+                    }
+                },
+            });
+        }
+        else {
+            LogUtils.Instance.log("tt.checkSession", "no function");
+            if (fail) {
+                fail();
+            }
+        }
+    }
+    login(success, fail) {
+        if (window["tt"] && window["tt"].login) {
+            LogUtils.Instance.log("tt.login");
+            window["tt"].login({
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                    if (success) {
+                        success(res.code, "");
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                    if (fail) {
+                        fail(true);
+                    }
+                },
+            });
+        }
+        else {
+            LogUtils.Instance.log("tt.login", "no function");
+            if (fail) {
+                fail(true);
+            }
+        }
+    }
+    requirePrivacyAuthorize(callback) {
+        if (callback === null) {
+            return;
+        }
+        callback(true);
+    }
+    getSetting(scope, callback) {
+        if (callback === null) {
+            return;
+        }
+        if (!window["tt"] || !window["tt"].getSetting) {
+            callback(GetSettingResult.Result_SettingNotAvailable);
+            return;
+        }
+        LogUtils.Instance.log("tt.getSetting", "scope=" + scope);
+        window["tt"].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_AuthorizeAvailable);
+                }
+            },
+            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["tt"] || !window["tt"].openSetting) {
+            callback(-1);
+            return;
+        }
+        LogUtils.Instance.log("tt.openSetting", "scope=" + scope);
+        window["tt"].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;
+        }
+        if (!window["tt"] || !window["tt"].authorize) {
+            callback(AuthorizeResult.Result_AuthorizeNotAvailable);
+            return;
+        }
+        LogUtils.Instance.log("tt.authorize", "scope=" + scope);
+        window["tt"].authorize({
+            scope: scope,
+            success: (res) => {
+                LogUtils.Instance.log("", "success");
+                if (res) {
+                    LogUtils.Instance.log("", res);
+                }
+                callback(AuthorizeResult.Result_Authorized);
+            },
+            fail: (err) => {
+                LogUtils.Instance.log("", "fail");
+                if (err) {
+                    LogUtils.Instance.log("", err);
+                }
+                callback(AuthorizeResult.Result_Rejected);
+            },
+        });
+    }
+    setRankData(args) {
+        let rankId = args[0];
+        let value = args[1];
+        if (window["tt"] && window["tt"].setImRankData) {
+            LogUtils.Instance.log("tt.setImRankData");
+            window["tt"].setImRankData({
+                zoneId: rankId,
+                value: value,
+                dataType: 0,
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                },
+            });
+        }
+    }
+    showRankList(args) {
+        let rankId = args[0];
+        let rankTitle = args[1];
+        let suffix = args[2];
+        if (window["tt"] && window["tt"].getImRankList) {
+            LogUtils.Instance.log("tt.getImRankList");
+            window["tt"].getImRankList({
+                zoneId: rankId,
+                rankTitle: rankTitle,
+                suffix: suffix,
+                dataType: 0,
+                relationType: "default",
+                rankType: "all",
+                success: (res) => {
+                    LogUtils.Instance.log("", "success");
+                    if (res) {
+                        LogUtils.Instance.log("", res);
+                    }
+                },
+                fail: (err) => {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                },
+            });
+        }
+    }
+    initPortalGame() {
+        if (!window["tt"] || !window["tt"].createGridGamePanel) {
+            return;
+        }
+        if (this.portalGame !== null) {
+            return;
+        }
+        LogUtils.Instance.log("tt.createGridGamePanel");
+        try {
+            this.portalGame = window["tt"].createGridGamePanel({
+                gridCount: "nine",
+            });
+        }
+        catch (err) {
+            LogUtils.Instance.log("", "error");
+            LogUtils.Instance.log("", err);
+        }
+    }
+    openPortalGame() {
+        LogUtils.Instance.log("", this.portalGame);
+        if (this.portalGame === null) {
+            LogUtils.Instance.log("", "error: this.portalGame === null");
+            return;
+        }
+        LogUtils.Instance.log("", "portalGame.show()");
+        this.portalGame.show()
+            .then(() => {
+            LogUtils.Instance.log("", "success");
+        }).catch((err) => {
+            LogUtils.Instance.log("", "error");
+            if (err) {
+                LogUtils.Instance.log("", err);
+            }
+        });
+    }
+    openGameClub() {
+        if (this.business.gameClub_path === "") {
+            return;
+        }
+        this.navigateToMiniProgram("ttc9e5bf5856eff54001", this.business.gameClub_path);
+    }
+    openRecommendToFriend() {
+        if (window["tt"] && window["tt"].shareAppMessage) {
+            LogUtils.Instance.log("tt.shareAppMessage");
+            window["tt"].shareAppMessage({
+                channel: "invite",
+                success() {
+                    LogUtils.Instance.log("", "success");
+                },
+                fail(err) {
+                    LogUtils.Instance.log("", "fail");
+                    if (err) {
+                        LogUtils.Instance.log("", err);
+                    }
+                }
+            });
+        }
+    }
+    openRecommendToGameClub() {
+    }
+    // Private
+    getOceanEngineClickId() {
+        if (!window["tt"]) {
+            return "";
+        }
+        let clickid = "";
+        let query_clickid = "";
+        let query_adParams_clickid = "";
+        if (this.coldStartOptions["query"]) {
+            let query = this.coldStartOptions["query"];
+            if (query["clickid"]) {
+                query_clickid = query["clickid"];
+            }
+            if (query["ad_params"]) {
+                let ad_params_json = JSON.parse(decodeURIComponent(query["ad_params"]));
+                if (ad_params_json["web_url"]) {
+                    let web_url = ad_params_json["web_url"];
+                    let queryString = "clickid";
+                    let regex = new RegExp(`[?&]${queryString}=([^&#]*)`);
+                    let results = regex.exec(web_url);
+                    if (results && results.length > 0) {
+                        query_adParams_clickid = results[1];
+                    }
+                }
+            }
+        }
+        clickid = query_adParams_clickid;
+        if (query_clickid.length > 0) {
+            clickid = query_clickid;
+        }
+        return clickid;
+    }
+    reportToOceanEngine(clickid, eventType, properties, callback) {
+        if (callback === null) {
+            return;
+        }
+        if (clickid === null || clickid === "") {
+            return;
+        }
+        let timestamp = Math.floor(Date.now());
+        let requestParam_json = {
+            "event_type": eventType,
+            "context": {
+                "ad": {
+                    "callback": clickid,
+                },
+            },
+            "properties": properties,
+            "timestamp": timestamp,
+        };
+        let requestParam = JSON.stringify(requestParam_json);
+        let url = "https://analytics.oceanengine.com/api/v2/conversion";
+        LogUtils.Instance.log("reportToOceanEngine", "url=" + url);
+        LogUtils.Instance.log("requestParam", requestParam);
+        this.requestPost(url, requestParam, (data) => {
+            let jsObj = JSON.parse(data);
+            if (jsObj === null) {
+                callback(false);
+                return;
+            }
+            if (jsObj.code === 0) {
+                callback(true);
+                return;
+            }
+            else {
+                callback(false);
+                return;
+            }
+        }, () => {
+            LogUtils.Instance.log("reportToOceanEngine", "response fail");
+            callback(false);
+            return;
+        });
+    }
+}