@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/engine/EsEngine.java

@@ -0,0 +1,212 @@
+package com.quicktvui.sdk.core.engine;
+
+import android.content.Context;
+import android.text.TextUtils;
+
+import com.quicktvui.base.ui.ESBaseConfigManager;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.core.EsData;
+import com.quicktvui.sdk.core.InitConfig;
+import com.quicktvui.sdk.core.adapter.DefaultHippyLogAdapter;
+import com.quicktvui.sdk.core.adapter.EsEngineExceptionHandlerAdapter;
+import com.quicktvui.sdk.core.adapter.EsImageLoaderAdapter;
+import com.quicktvui.sdk.core.adapter.EsSoLoaderAdapter;
+import com.quicktvui.sdk.core.adapter.HttpsAdapter;
+import com.quicktvui.sdk.core.adapter.ProxyHttpAdapter;
+import com.quicktvui.sdk.core.internal.Constants;
+import com.quicktvui.sdk.core.internal.EsConfigManager;
+import com.quicktvui.sdk.core.internal.EsContext;
+import com.quicktvui.sdk.core.internal.loader.IRpkLoader;
+import com.quicktvui.sdk.core.internal.loader.RpkInfo;
+import com.quicktvui.sdk.core.pm.InnerProvider;
+import com.quicktvui.sdk.core.utils.CommonUtils;
+import com.quicktvui.sdk.core.utils.MapperUtils;
+import com.sunrain.toolkit.utils.log.L;
+import com.tencent.mtt.hippy.HippyAPIProvider;
+import com.tencent.mtt.hippy.HippyEngine;
+import com.tencent.mtt.hippy.HippyEngineContext;
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.adapter.http.HippyHttpAdapter;
+import com.tencent.mtt.hippy.modules.javascriptmodules.EventDispatcher;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <br>
+ * 对HippyEngine的包装
+ * <br>
+ * <br>
+ * Created by WeiPeng on 2023-09-18 10:59
+ */
+public class EsEngine {
+
+    public static final int TYPE_DEBUG = 0;
+    public static final int TYPE_APP = 1;
+    public static final int TYPE_CARD = 2;
+
+    public static final String ROOT_COMPONENT_NAME = "EsApp";
+    public static final String CODE_CACHE_TAG = "common";
+
+    private final int mEngineType;
+    private HippyEngine mInstance;
+
+    public EsEngine(int engineType) {
+        mEngineType = engineType;
+    }
+
+    public int getEngineType() {
+        return mEngineType;
+    }
+
+    public HippyEngine getInstance() {
+        return mInstance;
+    }
+
+//    public void preloadModule(String filePath, HippyEngine.ModuleListener listener) {
+//        mInstance.preloadModule(new HippyFileBundleLoader(filePath), listener);
+//    }
+
+    public HippyRootView loadModule(Context context, IRpkLoader loader, HippyEngine.ModuleListener listener) {
+        EsData appData = loader.getAppData();
+        RpkInfo rpkInfo = loader.getRpkInfo();
+        HippyEngine.ModuleLoadParams loadParams = new HippyEngine.ModuleLoadParams();
+        loadParams.context = context;
+        loadParams.componentName = ROOT_COMPONENT_NAME;
+        loadParams.jsFilePath = new File(rpkInfo.getCodeDir(), Constants.FILE_JS_INDEX).getAbsolutePath();
+        loadParams.esBaseConfigManager = createConfigManager(rpkInfo.getRpkConfig());
+        loadParams.baseBorderDrawableProvider = EsContext.get().getBorderDrawableProvider();
+        if (appData.getArgs() != null) {
+            loadParams.jsParams = MapperUtils.esMap2HpMap(appData.getArgs());
+        }
+
+        // TODO 自定义Context
+//        ESInstanceContext instanceContext = new ESInstanceContext(context);
+//        instanceContext.setModuleParams(loadParams);
+//        loadParams.hippyContext = instanceContext;
+
+        return mInstance.loadModule(loadParams, listener);
+    }
+
+    private ESBaseConfigManager createConfigManager(EsMap configData) {
+        EsConfigManager configManager = new EsConfigManager();
+        if(configData == null) return configManager;
+        if (EsContext.get().getEsBaseConfigManager() != null) {
+            //此处为runtime配置了默认的packageJson解析，那么将先使用package.json，没配置的属性则使用default
+//            Log.v("EsConfigManager", "runtime配置了默认的packageJson解析---------");
+            configManager.setShakeSelf(EsContext.get().getEsBaseConfigManager().IsShakeSelf());
+            configManager.setListShakeSelf(EsContext.get().getEsBaseConfigManager().IsListShakeSelf());
+            configManager.setFocusBorderType(EsContext.get().getEsBaseConfigManager().getFocusBorderType());
+            configManager.doConfigs(configData.toString());
+        } else {
+            //说明runtime没有配置默认的packageJson解析，那么就使用package.json
+//            Log.v("EsConfigManager", "没有配置默认的packageJson解析---------");
+            configManager.doConfigs(configData.toString());
+        }
+        return configManager;
+    }
+
+    void init(HippyEngine.EngineListener listener) throws Exception {
+        HippyEngine.EngineInitParams initParams = getInitParams();
+        onBeforeCreateEngine(initParams);
+
+        mInstance = HippyEngine.create(initParams);
+        onAfterCreateEngine(mInstance);
+
+        mInstance.initEngine(listener);
+        onAfterInitEngine(mInstance);
+    }
+
+    private HippyEngine.EngineInitParams getInitParams() {
+        HippyEngine.EngineInitParams initParams = new HippyEngine.EngineInitParams();
+        initParams.context = EsContext.get().getContext().getApplicationContext();
+        initParams.imageLoader = new EsImageLoaderAdapter(EsContext.get().getImageLoader());
+        initParams.httpAdapter = createHttpAdapter();
+        if (CommonUtils.isEnableDynamicSo()) {
+            initParams.soLoader = new EsSoLoaderAdapter();
+        }
+        initParams.logAdapter = new DefaultHippyLogAdapter();
+        initParams.enableLog = L.DEBUG;
+        initParams.exceptionHandler = new EsEngineExceptionHandlerAdapter();
+//      TODO 设置预加载类库  initParams.jsPreloadFilePath
+        registerProviders(initParams);
+        return initParams;
+    }
+
+    private void registerProviders(HippyEngine.EngineInitParams initParams) {
+        if (initParams.providers == null) {
+            initParams.providers = new ArrayList<>();
+        }
+        initParams.providers.add(new InnerProvider());
+        List<Object> providerList = InitConfig.getDefault().getApiProviderList();
+        if (providerList != null) {
+            for (Object p : providerList) {
+                initParams.providers.add((HippyAPIProvider) p);
+            }
+        }
+    }
+
+    /**
+     * 网络代理
+     **/
+    private HippyHttpAdapter createHttpAdapter() {
+        String proxyHostName = InitConfig.getDefault().getProxyHostName();
+        int proxyPort = InitConfig.getDefault().getProxyPort();
+        if (!TextUtils.isEmpty(proxyHostName) && proxyPort != 0) {
+            return new ProxyHttpAdapter(proxyHostName, proxyPort);
+        }
+        return new HttpsAdapter();
+    }
+
+    /**
+     * 可提前修改启动参数
+     **/
+    protected void onBeforeCreateEngine(HippyEngine.EngineInitParams params) throws Exception {
+
+    }
+
+    /**
+     * 可提前注册事件
+     **/
+    protected void onAfterCreateEngine(HippyEngine engine) {
+
+    }
+
+    protected void onAfterInitEngine(HippyEngine engine) {
+
+    }
+
+    public void sendUIEvent(int tagId, String eventName, Object params) throws Exception {
+        if (mInstance != null) {
+            HippyEngineContext engineContext = mInstance.getEngineContext();
+            if (engineContext != null) {
+                if (L.DEBUG)
+                    L.logI(engineContext.getEngineId() + " sendUIEvent tagId: " + tagId + ", eventName: " + eventName + ", params: " + params);
+                engineContext.getModuleManager().getJavaScriptModule(EventDispatcher.class).receiveUIComponentEvent(tagId, eventName, MapperUtils.tryMapperEsData2HpData(params));
+            }
+        }
+    }
+
+    public void sendNativeEvent(String eventName, Object params) throws Exception {
+        if (mInstance != null) {
+            HippyEngineContext engineContext = mInstance.getEngineContext();
+            if (engineContext != null) {
+                if (L.DEBUG)
+                    L.logI(engineContext.getEngineId() + " sendNativeEvent eventName: " + eventName + ", params: " + params);
+                engineContext.getModuleManager().getJavaScriptModule(EventDispatcher.class).receiveNativeEvent(eventName, MapperUtils.tryMapperEsData2HpData(params));
+            }
+        }
+    }
+
+    public void destroy() {
+        ESEvents.off(mInstance.getId());
+        mInstance.addRestartListener(null);
+        mInstance.destroyEngine();
+        mInstance = null;
+    }
+
+    public interface OnHippyEngineRestartListener {
+        void onHippyEngineRestart(HippyEngine engine);
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/engine/EsEnginePool.java

@@ -0,0 +1,262 @@
+package com.quicktvui.sdk.core.engine;
+
+import android.os.Looper;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import com.sunrain.toolkit.bolts.tasks.Task;
+import com.sunrain.toolkit.bolts.tasks.TaskCompletionSource;
+import com.sunrain.toolkit.utils.log.L;
+import com.sunrain.toolkit.utils.thread.Executors;
+import com.tencent.mtt.hippy.HippyEngine;
+import com.tencent.mtt.hippy.HippyInstanceLifecycleEventListener;
+
+import java.io.File;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import com.quicktvui.sdk.core.internal.Constants;
+import com.quicktvui.sdk.base.EsException;
+import com.quicktvui.sdk.base.args.EsMap;
+
+/**
+ * <br>
+ * 引擎池管理
+ * <br>
+ * <br>
+ * Created by WeiPeng on 2023-09-18 10:05
+ */
+public class EsEnginePool {
+
+    private final int POOL_SIZE_APP_ENGINE = 1;
+    private final int POOL_SIZE_CARD_ENGINE = 2;
+
+    private final ArrayBlockingQueue<EsEngine> mAppEnginePool = new ArrayBlockingQueue<>(POOL_SIZE_APP_ENGINE);
+    private final ArrayBlockingQueue<EsEngine> mCardEnginePool = new ArrayBlockingQueue<>(POOL_SIZE_CARD_ENGINE);
+
+    private RuntimeManager mRuntimeManager;
+
+    /**
+     * FIXME 回收引擎重复利用 (重复使用几次后，无法加载module)
+     **/
+    public void releaseEngine(EsEngine engine) {
+        if (engine.getEngineType() == EsEngine.TYPE_APP) {
+            mAppEnginePool.offer(engine);
+            if (L.DEBUG) L.logD("put: " + mAppEnginePool.size());
+        }
+    }
+
+    /**
+     * 创建Debug引擎
+     **/
+    public EsEngine createDebugEngine(@NonNull String debugServer, @NonNull EsEngine.OnHippyEngineRestartListener listener) throws Exception {
+        checkNotMainThread();
+        return EngineCreator.createWithDebugRuntime(debugServer, listener);
+    }
+
+    /**
+     * 创建引擎
+     **/
+    public EsEngine createHippyEngine(int engineType, @Nullable File runtimeFile, @NonNull EsMap vueConfig) throws Exception {
+        checkNotMainThread();
+        return createEngineWithType(engineType, runtimeFile, vueConfig);
+    }
+
+    /**
+     * 创建应用引擎
+     **/
+    private EsEngine createEngineWithType(int engineType, @Nullable File runtimeFile, @NonNull EsMap vueConfig) throws Exception {
+        if (runtimeFile != null && runtimeFile.exists()) {
+            return EngineCreator.createWithCustomRuntime(engineType, runtimeFile);
+        }
+        ArrayBlockingQueue<EsEngine> poolQueue;
+        int poolSize;
+        if (engineType == EsEngine.TYPE_CARD) {
+            poolQueue = mCardEnginePool;
+            poolSize = POOL_SIZE_CARD_ENGINE;
+        } else {
+            poolQueue = mAppEnginePool;
+            poolSize = POOL_SIZE_APP_ENGINE;
+        }
+        if (poolQueue.size() == 0) {
+            poolQueue.put(EngineCreator.createWithPublicRuntime(engineType, mRuntimeManager, vueConfig));
+        } else if (poolQueue.size() == 1) {
+            Executors.get().execute(() -> {
+                for (int i = 0; i < poolSize; i++) {
+                    try {
+                        poolQueue.put(EngineCreator.createWithPublicRuntime(engineType, mRuntimeManager, vueConfig));
+                    } catch (Exception e) {
+                        L.logW("put engine 2 pool", e);
+                    }
+                }
+            });
+        }
+        return poolQueue.take();
+    }
+
+    public void clear() {
+        synchronized (mAppEnginePool) {
+            for (EsEngine engine : mAppEnginePool) {
+                engine.destroy();
+            }
+            mAppEnginePool.clear();
+        }
+
+        synchronized (mCardEnginePool) {
+            for (EsEngine engine : mCardEnginePool) {
+                engine.destroy();
+            }
+            mCardEnginePool.clear();
+        }
+        if (mRuntimeManager != null) {
+            mRuntimeManager.clear();
+        }
+    }
+
+    private static final class EngineCreator {
+
+        public static EsEngine createWithCustomRuntime(int engineType, File file) throws Exception {
+            L.logIF("use custom runtime");
+            return create(new EsEngine(engineType) {
+                @Override
+                protected void onBeforeCreateEngine(HippyEngine.EngineInitParams params) throws Exception {
+                    if (L.DEBUG) L.logD("coreJSFilePath: " + file.getAbsolutePath());
+                    params.coreJSFilePath = file.getAbsolutePath();
+                }
+            });
+        }
+
+        public static EsEngine createWithDebugRuntime(String server, EsEngine.OnHippyEngineRestartListener listener) throws Exception {
+            L.logIF("use debug runtime");
+            return create(new EsEngine(EsEngine.TYPE_DEBUG) {
+                @Override
+                protected void onBeforeCreateEngine(HippyEngine.EngineInitParams params) throws Exception {
+                    params.debugMode = true;
+                    params.debugServerHost = server;
+                }
+
+                @Override
+                protected void onAfterCreateEngine(HippyEngine engine) {
+                    engine.addRestartListener(() -> listener.onHippyEngineRestart(engine));
+                }
+            });
+        }
+
+        public static EsEngine createWithPublicRuntime(int engineType, RuntimeManager manager, EsMap vueConfig) throws Exception {
+            L.logIF("use public " + (engineType == EsEngine.TYPE_APP ? "app" : "card") + " runtime");
+            return create(new EsEngine(engineType) {
+                @Override
+                protected void onBeforeCreateEngine(HippyEngine.EngineInitParams params) throws Exception {
+
+                    // 获取标记后缀
+                    String runtimeSuffix = vueConfig == null ? null : vueConfig.getString(Constants.PACKAGE_JSON_K_RUNTIME_SUFFIX);
+                    L.logIF("suffix: " + runtimeSuffix);
+
+                    // 拼接后缀 详见 UWHF-4428 例如:
+                    // 包名: eskit.runtime.app 后缀: tag1
+                    // 拼接后:  eskit.runtime.app.tag1
+                    String runtimePackageName = engineType == EsEngine.TYPE_APP ? Constants.ES_VUE_RUNTIME_PKG_APP : Constants.ES_VUE_RUNTIME_PKG_CARD;
+                    if (runtimeSuffix != null) {
+                        runtimePackageName += "." + runtimeSuffix;
+                    }
+
+                    float minVersion = vueConfig.getFloat(Constants.PACKAGE_JSON_K_RUNTIME_MIN_VERSION);
+                    L.logIF("minVersion: " + minVersion);
+
+                    RuntimeManager.VRuntime runtime = manager.getLatestRuntime(params.context, runtimePackageName);
+                    if (runtime.version < minVersion) {
+                        manager.invalidateRuntime(runtimePackageName);
+                        runtime = manager.getLatestRuntime(params.context, runtimePackageName);
+                    }
+                    // 二次验证
+                    if (runtime.version < minVersion) {
+                        throw new EsException(Constants.ERR_RUNTIME_NOT_SUPPORT, "运行时库版本小于最低要求的版本" + minVersion);
+                    }
+                    if (L.DEBUG) L.logD("coreJSFilePath: " + runtime.path);
+                    params.coreJSFilePath = runtime.path;
+                }
+            });
+        }
+
+        private static EsEngine create(EsEngine engine) throws Exception {
+            TaskCompletionSource<Void> result = new TaskCompletionSource<>();
+            engine.init((status, msg) -> {
+                if (status == HippyEngine.EngineInitStatus.STATUS_OK) {
+                    result.setResult(null);
+                } else {
+                    result.setError(new EsException(status.value(), msg));
+                }
+            });
+            Task<Void> task = result.getTask();
+            boolean initSuccess = task.waitForCompletion(20, TimeUnit.SECONDS);
+            if (!initSuccess) {
+                throw new EsException(Constants.ERR_INIT_TIMEOUT, "engine init timeout");
+            }
+            if (task.isFaulted()) {
+                throw task.getError();
+            }
+            return engine;
+        }
+
+    }
+
+    /**
+     * 不能在主线程调用
+     **/
+    private void checkNotMainThread() {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            throw new EsException(Constants.ERR_RUNTIME_THREAD, "引擎只运行在子线程创建");
+        }
+    }
+
+    private void init() {
+        mRuntimeManager = new RuntimeManager();
+    }
+
+    private static final class HippyEngineLifecycleEventListener implements HippyInstanceLifecycleEventListener {
+
+        private EsEngine mEngine;
+
+        public HippyEngineLifecycleEventListener(EsEngine engine) {
+            mEngine = engine;
+        }
+
+        @Override
+        public void onInstanceLoad(int i) {
+
+        }
+
+        @Override
+        public void onInstanceResume(int i) {
+
+        }
+
+        @Override
+        public void onInstancePause(int i) {
+
+        }
+
+        @Override
+        public void onInstanceDestroy(int i) {
+            EsEnginePool.get().releaseEngine(mEngine);
+            mEngine = null;
+        }
+    }
+
+    //region 单例
+
+    private static final class EsEnginePoolHolder {
+        private static final EsEnginePool INSTANCE = new EsEnginePool();
+    }
+
+    public static EsEnginePool get() {
+        return EsEnginePoolHolder.INSTANCE;
+    }
+
+    private EsEnginePool() {
+        init();
+    }
+
+    //endregion
+
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/engine/RuntimeManager.java

@@ -0,0 +1,94 @@
+package com.quicktvui.sdk.core.engine;
+
+import android.content.Context;
+import android.text.format.DateUtils;
+
+import com.quicktvui.sdk.core.internal.EsContext;
+import com.quicktvui.sdk.core.utils.SpUtils;
+import com.sunrain.toolkit.utils.FileUtils;
+import com.sunrain.toolkit.utils.log.L;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * <br>
+ * Vendor版本管理
+ * <br>
+ * <br>
+ * Created by WeiPeng on 2023-09-18 14:40
+ */
+public class RuntimeManager {
+
+    private final long TIME_CACHE = DateUtils.HOUR_IN_MILLIS * 2;
+
+    // 内存缓存当前使用的Runtime版本
+    private final ConcurrentMap<String, VRuntime> mCachedRuntimeVersions = new ConcurrentHashMap<>();
+
+    /** 网络缓存runtime **/
+    private VRuntime fetchRuntimeFormServer(String runtimePackage) throws Exception {
+        L.logIF("update runtime");
+        return EsContext.get().getEsApiAdapter().fetchRuntimeInfo(runtimePackage);
+    }
+
+    public synchronized VRuntime getLatestRuntime(Context context, String runtimePackage) throws Exception {
+        long currentTime = System.currentTimeMillis();
+        VRuntime runtime = getRuntimeFromCache(runtimePackage);
+
+        if (runtime == null     // 没有缓存
+                || (currentTime - runtime.updateTime) > TIME_CACHE      // 缓存超时
+                || !FileUtils.isFileExists(runtime.path)                // 文件不存在
+        ) {
+            runtime = fetchRuntimeFormServer(runtimePackage);
+            saveRuntimeToCache(runtime);
+            mCachedRuntimeVersions.put(runtimePackage, runtime);
+        }
+
+        return runtime;
+    }
+
+    public synchronized void invalidateRuntime(String runtimePackage) {
+        mCachedRuntimeVersions.remove(runtimePackage);
+        SpUtils.saveRuntimeUpdateTime(runtimePackage, -1);
+    }
+
+    /**
+     * 从内存或磁盘获取缓存
+     **/
+    private VRuntime getRuntimeFromCache(String runtimePackage) {
+        // 内存缓存
+        VRuntime runtime = mCachedRuntimeVersions.get(runtimePackage);
+        if (runtime == null) {
+            // 磁盘缓存
+            long updateTime = SpUtils.getRuntimeUpdateTime(runtimePackage);
+            if (updateTime > 0) {
+                L.logIF("use cache runtime");
+                runtime = new VRuntime();
+                runtime.version = SpUtils.getRuntimeVersion(runtimePackage);
+                runtime.path = SpUtils.getRuntimePath(runtimePackage);
+                runtime.updateTime = SpUtils.getRuntimeUpdateTime(runtimePackage);
+            }
+        }
+        return runtime;
+    }
+
+    /**
+     * 保存runtime使用信息
+     **/
+    private void saveRuntimeToCache(VRuntime runtime) {
+        SpUtils.saveRuntimePath(runtime.packageName, runtime.path);
+        SpUtils.saveRuntimeVersion(runtime.packageName, runtime.version);
+        SpUtils.saveRuntimeUpdateTime(runtime.packageName, runtime.updateTime);
+    }
+
+    public void clear() {
+        mCachedRuntimeVersions.clear();
+    }
+
+    public static final class VRuntime {
+        public String packageName;
+        public float version;
+        public String path;
+        public long updateTime;
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/entity/DeviceInfo.java

@@ -0,0 +1,62 @@
+package com.quicktvui.sdk.core.entity;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.provider.Settings;
+
+import com.sunrain.toolkit.utils.NetworkUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.quicktvui.sdk.core.internal.EsContext;
+import com.quicktvui.sdk.base.Constants;
+import com.quicktvui.sdk.base.core.EsProxy;
+
+/**
+ * Create by weipeng on 2022/03/01 18:24
+ */
+public class DeviceInfo {
+
+    private final Map<String, String> info;
+
+    public DeviceInfo(Context context) {
+        info = new HashMap<>();
+        info.put("os", "android");
+        info.put("os_ver", Build.VERSION.RELEASE);
+        info.put("brand", Build.BRAND);
+        info.put("model", Build.MODEL);
+        info.put("id", Build.ID);
+        info.put("mac_eth", NetworkUtils.getEthMac());
+        info.put("mac_wifi", NetworkUtils.getWifiMac());
+        info.put("app_bundle", context.getPackageName());
+        info.put("appid", EsContext.get().getAppId());
+        info.put("sdk_channel", EsContext.get().getAppChannel());
+        info.put("sdk_ver", EsProxy.get().getSdkVersionName());
+        info.put("sdk_ver_code", "" + EsProxy.get().getSdkVersionCode());
+        info.put(Constants.ESKIT_V_CODE, "" + EsProxy.get().getEsKitVersionCode());
+        info.put(Constants.ESKIT_V_NAME, "" + EsProxy.get().getEsKitVersionName());
+
+        try {
+            PackageManager pm = context.getPackageManager();
+            PackageInfo pi = pm.getPackageInfo(context.getPackageName(), 0);
+            this.info.put("app_ver_code", String.valueOf(pi.versionCode));
+            this.info.put("app_ver_name", pi.versionName);
+        } catch (Exception ignore) {
+        }
+
+        String androidId;
+        try {
+            androidId = Settings.Secure.getString(context.getContentResolver(), Settings.System.ANDROID_ID);
+        } catch (Throwable e) {
+            androidId = "";
+        }
+        info.put("android_id", androidId);
+    }
+
+    public Map<String, String> getInfo() {
+        return info;
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/entity/InfoEntity.java

@@ -0,0 +1,13 @@
+package com.quicktvui.sdk.core.entity;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * Create by WeiPeng on 2020/11/20 16:02
+ */
+
+public class InfoEntity {
+  @SerializedName("tvpackagever")
+  public String esVersion;
+  public boolean refresh;
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/ext/loadproxy/IEsRpkLoadProxy.java

@@ -0,0 +1,43 @@
+package com.quicktvui.sdk.core.ext.loadproxy;
+
+import com.quicktvui.sdk.base.EsException;
+import com.quicktvui.sdk.core.entity.InfoEntity;
+
+import java.io.File;
+import java.util.Map;
+
+/**
+ * 介入rpk下载的代理
+ */
+public interface IEsRpkLoadProxy {
+
+    /** 使用自己的解密规则 **/
+    int DEC_RET_USE_SELF = 0;
+    /** 使用默认解密规则 **/
+    int DEC_RET_USE_DEFAULT = 1;
+
+    /**
+     * 鉴权
+     * @param params
+     * @return authCode
+     */
+    EsException auth(Map<String, String> params);
+
+    /**
+     * 请求rpk信息
+     *
+     * @param params 参数
+     * @return 实体类
+     */
+    InfoEntity requestRpkInfo(Map<String, String> params);
+
+    /**
+     * 解密rpk包
+     *
+     * @param originFile  原包路径
+     * @param decryptFile 解密到的路径
+     * @return 处理结果<br/>
+     * {{@link IEsRpkLoadProxy#DEC_RET_USE_SELF}} {{@link IEsRpkLoadProxy#DEC_RET_USE_DEFAULT}}
+     */
+    int decryptRpk(File originFile, File decryptFile);
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/ext/log/ILogCallback.java

@@ -0,0 +1,10 @@
+package com.quicktvui.sdk.core.ext.log;
+
+/**
+ * <br>
+ *
+ * <br>
+ */
+public interface ILogCallback {
+    void log(String tag, String msg);
+}