@galacean/effects-plugin-alipay-downgrade 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/alipay-downgrade-plugin.d.ts

@@ -1,7 +1,5 @@
-import type { Player, SceneLoadOptions, spec } from '@galacean/effects';
+import type { SceneLoadOptions, spec } from '@galacean/effects';
 import { AbstractPlugin } from '@galacean/effects';
 export declare class AlipayDowngradePlugin extends AbstractPlugin {
-    static glLostOccurred: boolean;
-    static onPlayerCreated(player: Player): Promise<void>;
-    static processRawJSON(json: spec.JSONScene, options?: SceneLoadOptions): Promise<undefined>;
+    static processRawJSON(json: spec.JSONScene, options?: SceneLoadOptions): Promise<void>;
 }

package/dist/alipay.js

@@ -0,0 +1,597 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EFFECTS = require('@galacean/effects/alipay');
+var alipay = require('@galacean/appx-adapter/alipay');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var EFFECTS__namespace = /*#__PURE__*/_interopNamespace(EFFECTS);
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+// class DowngradeItem {
+//   // empty
+// }
+var DowngradeVFXItem = /*#__PURE__*/ function(VFXItem) {
+    _inherits(DowngradeVFXItem, VFXItem);
+    function DowngradeVFXItem() {
+        return VFXItem.apply(this, arguments);
+    }
+    return DowngradeVFXItem;
+}(EFFECTS.VFXItem);
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+
+function __generator(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g;
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var mockIdPass = "mock-pass";
+var mockIdFail = "mock-fail";
+var DEVICE_LEVEL_HIGH = "high";
+var DEVICE_LEVEL_MEDIUM = "medium";
+var DEVICE_LEVEL_LOW = "low";
+var DEVICE_LEVEL_NONE = "none";
+var hasRegisterEvent = false;
+function getDowngradeResult(bizId) {
+    return _getDowngradeResult.apply(this, arguments);
+}
+function _getDowngradeResult() {
+    _getDowngradeResult = _async_to_generator(function(bizId, options) {
+        var ap, now;
+        return __generator(this, function(_state) {
+            if (options === void 0) options = {};
+            if (!hasRegisterEvent) {
+                registerEvent(options);
+                hasRegisterEvent = true;
+            }
+            if (bizId === mockIdFail || bizId === mockIdPass) {
+                return [
+                    2,
+                    Promise.resolve({
+                        mock: {
+                            downgrade: bizId === mockIdFail
+                        }
+                    })
+                ];
+            }
+            ap = EFFECTS.isAlipayMiniApp() ? my : alipay.window.AlipayJSBridge;
+            if (ap) {
+                now = performance.now();
+                return [
+                    2,
+                    getSystemInfo().then(function(systemInfo) {
+                        return new Promise(function(resolve) {
+                            var techPoint = [
+                                "mars"
+                            ];
+                            var tc = options.techPoint;
+                            if (tc) {
+                                var _techPoint;
+                                (_techPoint = techPoint).push.apply(_techPoint, [].concat(tc));
+                            }
+                            var downgradeOptions = {
+                                bizId: bizId,
+                                scene: 0,
+                                ext: {
+                                    techPoint: techPoint
+                                }
+                            };
+                            var downgradeCallback = function(result) {
+                                var totalTime = performance.now() - now;
+                                console.info("Downgrade time: " + totalTime + "ms.");
+                                resolve({
+                                    bizId: bizId,
+                                    systemInfo: systemInfo,
+                                    downgradeResult: result,
+                                    totalTime: totalTime
+                                });
+                            };
+                            var _options_callBridge;
+                            var callBridge = (_options_callBridge = options.callBridge) != null ? _options_callBridge : ap.call;
+                            callBridge("getDowngradeResult", downgradeOptions, downgradeCallback);
+                        });
+                    })
+                ];
+            } else {
+                return [
+                    2,
+                    Promise.resolve({
+                        noAlipayEnv: true
+                    })
+                ];
+            }
+        });
+    });
+    return _getDowngradeResult.apply(this, arguments);
+}
+function registerEvent(options) {
+    var autoPause = options.autoPause;
+    alipay.window.addEventListener("unload", function() {
+        EFFECTS.getActivePlayers().forEach(function(player) {
+            return player.dispose();
+        });
+    });
+    if (autoPause) {
+        document.addEventListener("pause", pauseAllActivePlayers);
+        document.addEventListener("resume", resumePausedPlayers);
+    }
+}
+function getSystemInfo() {
+    return _getSystemInfo.apply(this, arguments);
+}
+function _getSystemInfo() {
+    _getSystemInfo = _async_to_generator(function() {
+        return __generator(this, function(_state) {
+            return [
+                2,
+                new Promise(function(resolve, reject) {
+                    var ap = EFFECTS.isAlipayMiniApp() ? my : alipay.window.AlipayJSBridge;
+                    if (ap) {
+                        ap.call("getSystemInfo", function(e) {
+                            if (e.error) {
+                                reject(e);
+                            } else {
+                                resolve(e);
+                            }
+                        });
+                    } else {
+                        reject("no ap");
+                    }
+                })
+            ];
+        });
+    });
+    return _getSystemInfo.apply(this, arguments);
+}
+var DeviceProxy = /*#__PURE__*/ function() {
+    function DeviceProxy() {
+        this.isIOS = false;
+        this.model = "DESKTOP_DEBUG";
+        this.system = "Unknown";
+        this.deviceLevel = DEVICE_LEVEL_NONE;
+        this.isDowngrade = false;
+    }
+    var _proto = DeviceProxy.prototype;
+    _proto.getRenderLevel = function getRenderLevel() {
+        if (this.deviceLevel === DEVICE_LEVEL_HIGH) {
+            return EFFECTS.spec.RenderLevel.S;
+        } else if (this.deviceLevel === DEVICE_LEVEL_MEDIUM) {
+            return EFFECTS.spec.RenderLevel.A;
+        } else if (this.deviceLevel === DEVICE_LEVEL_LOW) {
+            return EFFECTS.spec.RenderLevel.B;
+        } else {
+            return this.isIOS ? EFFECTS.spec.RenderLevel.S : EFFECTS.spec.RenderLevel.B;
+        }
+    };
+    _proto.hasDeviceLevel = function hasDeviceLevel() {
+        return isDeviceLevel(this.deviceLevel);
+    };
+    _proto.setBySystemInfo = function setBySystemInfo(systemInfo) {
+        var performance1 = systemInfo.performance, platform = systemInfo.platform, _systemInfo_model = systemInfo.model, model = _systemInfo_model === void 0 ? "UNKNOWN_DEVICE" : _systemInfo_model, _systemInfo_system = systemInfo.system, system = _systemInfo_system === void 0 ? "Unknown" : _systemInfo_system;
+        this.isIOS = platform === "iOS";
+        this.model = model;
+        this.system = system;
+        if (performance1 && !this.hasDeviceLevel()) {
+            this.deviceLevel = performance1;
+        }
+    };
+    _proto.updateDeviceLevel = function updateDeviceLevel() {
+        if (this.hasDeviceLevel()) {
+            return;
+        }
+        if (/iPhone(\d+),/.test(this.model)) {
+            var gen = +RegExp.$1;
+            if (gen <= 9) {
+                this.deviceLevel = DEVICE_LEVEL_LOW;
+            } else if (gen < 10) {
+                this.deviceLevel = DEVICE_LEVEL_MEDIUM;
+            } else {
+                this.deviceLevel = DEVICE_LEVEL_HIGH;
+            }
+        }
+    };
+    _proto.getDeviceInfo = function getDeviceInfo() {
+        return {
+            isIOS: this.isIOS,
+            model: this.model,
+            system: this.system,
+            deviceLevel: this.deviceLevel
+        };
+    };
+    return DeviceProxy;
+}();
+var device = new DeviceProxy();
+function checkDowngradeResult(result) {
+    if (result.mock) {
+        var _result_mock = result.mock, downgrade = _result_mock.downgrade, _result_mock_deviceLevel = _result_mock.deviceLevel, deviceLevel = _result_mock_deviceLevel === void 0 ? DEVICE_LEVEL_HIGH : _result_mock_deviceLevel;
+        device.deviceLevel = deviceLevel;
+        return {
+            downgrade: downgrade,
+            reason: "mock"
+        };
+    }
+    if (result.noAlipayEnv) {
+        return {
+            downgrade: false,
+            reason: "no AP env"
+        };
+    }
+    if (!result.systemInfo) {
+        return {
+            downgrade: false,
+            reason: "systemInfo is required"
+        };
+    }
+    if (!result.downgradeResult) {
+        return {
+            downgrade: false,
+            reason: "downgradeResult is required"
+        };
+    }
+    device.setBySystemInfo(result.systemInfo);
+    return parseDowngradeResult(result.downgradeResult);
+}
+function parseDowngradeResult(result) {
+    var resultType = undefined;
+    var resultReason = undefined;
+    if (!result.error) {
+        try {
+            var ret = EFFECTS.isString(result) ? JSON.parse(result) : result;
+            if ("downgradeResultType" in ret) {
+                resultType = ret.downgradeResultType;
+            } else if ("resultType" in ret) {
+                resultType = ret.resultType;
+                resultReason = ret.resultReason;
+            }
+            if (result.context) {
+                var deviceInfo = result.context.deviceInfo;
+                if (deviceInfo) {
+                    var deviceLevel = deviceInfo.deviceLevel;
+                    if (isDeviceLevel(deviceLevel)) {
+                        device.deviceLevel = deviceLevel;
+                    }
+                }
+            }
+            device.updateDeviceLevel();
+        } catch (ex) {
+            console.error(ex);
+        }
+        if (resultType === undefined) {
+            return {
+                downgrade: true,
+                reason: "call downgrade fail"
+            };
+        } else {
+            if (resultType === 1) {
+                return {
+                    downgrade: true,
+                    reason: getDowngradeReason(resultReason)
+                };
+            } else {
+                if (EFFECTS.isAlipayMiniApp() && downgradeForMiniprogram()) {
+                    return {
+                        downgrade: true,
+                        reason: "Force downgrade by downgrade plugin"
+                    };
+                } else {
+                    return {
+                        downgrade: false,
+                        reason: resultType
+                    };
+                }
+            }
+        }
+    } else {
+        // 无权调用的情况下不降级
+        return {
+            downgrade: result.error !== 4,
+            reason: "api error: " + result.error
+        };
+    }
+}
+function getDowngradeReason(reason) {
+    if (reason === -1) {
+        return "" + reason + "-no config";
+    } else if (reason === 0) {
+        return "" + reason + "-none";
+    } else if (reason === 1) {
+        return "" + reason + "-downgrade by memory";
+    } else if (reason === 2) {
+        return "" + reason + "-downgrade by crash";
+    } else if (reason === 3) {
+        return "" + reason + "-downgrade by device";
+    } else if (reason === 4) {
+        return "" + reason + "-downgrade by force";
+    } else {
+        return "" + reason;
+    }
+}
+function getRenderLevelByDevice(renderLevel) {
+    if (!renderLevel) {
+        return device.getRenderLevel();
+    } else {
+        return /[ABS]/.test(renderLevel) ? renderLevel : EFFECTS.spec.RenderLevel.S;
+    }
+}
+function isDeviceLevel(deviceLevel) {
+    return deviceLevel === DEVICE_LEVEL_HIGH || deviceLevel === DEVICE_LEVEL_MEDIUM || deviceLevel === DEVICE_LEVEL_LOW;
+}
+var internalPaused = Symbol("@@_inter_pause");
+function pauseAllActivePlayers(e) {
+    if (e.target === document) {
+        EFFECTS.logger.info("Auto pause all players with data offloaded.");
+        var players = EFFECTS.getActivePlayers();
+        players.forEach(function(player) {
+            if (!player.paused) {
+                player.pause({
+                    offloadTexture: true
+                });
+                // @ts-expect-error
+                player[internalPaused] = true;
+            }
+        });
+    }
+}
+function resumePausedPlayers(e) {
+    if (e.target === document) {
+        EFFECTS.logger.info("Auto resume all players.");
+        var players = EFFECTS.getActivePlayers();
+        players.forEach(function(player) {
+            // @ts-expect-error
+            if (player[internalPaused]) {
+                void player.resume();
+                // @ts-expect-error
+                player[internalPaused] = false;
+            }
+        });
+    }
+}
+var deviceModelList = [
+    "12,8",
+    "13,1",
+    "13,2",
+    "13,3",
+    "13,4"
+];
+/**
+ * iPhone SE2 和 12 全系列机型，如果是 iOS16 系统，在小程序中强制降级
+ * @returns
+ */ function downgradeForMiniprogram() {
+    if (device.isIOS) {
+        if (deviceModelList.find(function(v) {
+            return v === device.model;
+        })) {
+            var versionList = device.system.split(".");
+            if (versionList.length > 0 && versionList[0] === "16") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+var AlipayDowngradePlugin = /*#__PURE__*/ function(AbstractPlugin) {
+    _inherits(AlipayDowngradePlugin, AbstractPlugin);
+    function AlipayDowngradePlugin() {
+        return AbstractPlugin.apply(this, arguments);
+    }
+    AlipayDowngradePlugin.processRawJSON = function processRawJSON(json, options) {
+        if (options === void 0) options = {};
+        return _async_to_generator(function() {
+            var _options_pluginData, downgradeResult, downgradeDecision;
+            return __generator(this, function(_state) {
+                downgradeResult = (_options_pluginData = options.pluginData) == null ? void 0 : _options_pluginData["downgrade"];
+                if (downgradeResult) {
+                    downgradeDecision = checkDowngradeResult(downgradeResult);
+                    if (downgradeDecision.downgrade) {
+                        throw new Error("Downgraded, reason: " + downgradeDecision.reason + ".");
+                    }
+                } else {
+                    console.warn("No downgrade result in pluginData of SceneLoadOptions.");
+                }
+                if (!options.renderLevel) {
+                    options.renderLevel = getRenderLevelByDevice(options.renderLevel);
+                }
+                return [
+                    2
+                ];
+            });
+        })();
+    };
+    return AlipayDowngradePlugin;
+}(EFFECTS.AbstractPlugin);
+
+var prefix = "[Galacean Effects]";
+var ap = EFFECTS.isAlipayMiniApp() ? my : alipay.window.AlipayJSBridge;
+EFFECTS.logger.register(nativeLogger);
+function nativeLogger(type, msg) {
+    for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+        args[_key - 2] = arguments[_key];
+    }
+    var content = {
+        "message": prefix + " " + msg + " " + args.join(""),
+        "level": type
+    };
+    if (EFFECTS.isAndroid()) {
+        content["anr_info"] = "mars";
+    }
+    try {
+        ap == null ? void 0 : ap.call("localLog", content);
+    } catch (e) {
+        console.error(e);
+    }
+}
+
+var version = "2.0.0-alpha.20";
+EFFECTS.registerPlugin("alipay-downgrade", AlipayDowngradePlugin, DowngradeVFXItem, true);
+EFFECTS.logger.info("Plugin downgrade version: " + version + ".");
+if (version !== EFFECTS__namespace.version) {
+    console.error("注意：请统一 Downgrade 插件与 Player 版本，不统一的版本混用会有不可预知的后果！", "\nAttention: Please ensure the Downgrade plugin is synchronized with the Player version. Mixing and matching incompatible versions may result in unpredictable consequences!");
+}
+
+exports.checkDowngradeResult = checkDowngradeResult;
+exports.downgradeForMiniprogram = downgradeForMiniprogram;
+exports.getDowngradeResult = getDowngradeResult;
+exports.getRenderLevelByDevice = getRenderLevelByDevice;
+exports.version = version;
+//# sourceMappingURL=alipay.js.map