@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/AutoUtils.java

@@ -0,0 +1 @@
+package com.quicktvui.sdk.core.utils;
 * <br>
 *
 * <br>
 */
    private static final List<String> registerList = new ArrayList<>();
    private static final List<String> initList = new ArrayList<>();
    public static void init(Context context) {
        final long startTime = System.currentTimeMillis();
        try {
            DexFile dexFile = new DexFile(context.getPackageCodePath());
            Enumeration<String> entries = dexFile.entries();
            while (entries.hasMoreElements()) {
                String className = entries.nextElement();
                if (className.endsWith(AUTO_REGISTER_CLASS_SUFFIX)) {
                    registerList.add(className);
                } else if (className.endsWith(AUTO_INIT_CLASS_SUFFIX)) {
                    initList.add(className);
                }
            }
        } catch (Exception e) {
            L.logEF("AutoUtils", e);
        } finally {
            L.logIF("AutoUtils cost:" + (System.currentTimeMillis() - startTime));
        }
    }
    public static void autoRegister() {
        for (String className : registerList) {
            processRegister(className);
        }
    }
    public static void autoInit(Application context, InitConfig config) {
        Collections.sort(initList);
        for (String className : initList) {
            processInit(className, context, config);
        }
    }
    private static void processRegister(String className) {
        try {
            Class<?> regClass = Class.forName(className);
            regClass.getDeclaredMethod(AUTO_REGISTER_CLASS_METHOD).invoke(null);
        } catch (ClassNotFoundException e) {
            L.logEF("请在项目中使用:\nannotationProcessor/kapt 'com.extscreen.sdk:compiler:xxx'", e);
        } catch (NoSuchMethodException e) {
            L.logEF("找不到注册方法", e);
        } catch (Exception e) {
            L.logEF("注册失败", e);
        }
    }
    private static void processInit(String className, Application context, InitConfig config) {
        try {
            Class<?> initClass = Class.forName(className);
            Bundle bundle = new Bundle();
            bundle.putBoolean("debug", config.getDebug());
            bundle.putString("channel", config.getChannel());
            bundle.putInt("flags", config.getFlags());
            bundle.putString("bcCode", config.getBcCode());
            initClass.getDeclaredMethod("init", Context.class, Bundle.class).invoke(null, context, bundle);
        } catch (ClassNotFoundException e) {
            L.logEF("请在项目中使用:\nannotationProcessor/kapt 'com.extscreen.sdk:compiler:xxx'", e);
        } catch (NoSuchMethodException e) {
            L.logEF("找不到初始化方法", e);
        } catch (IllegalAccessException e) {
            L.logEF("执行初始化失败", e);
        } catch (InvocationTargetException e) {
            L.logEF("调用初始化方法异常", e);
        }catch (Exception e) {
            L.logEF("初始化未知异常", e);
        }
    }

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/CommonUtils.java

@@ -0,0 +1,150 @@
+package com.quicktvui.sdk.core.utils;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.net.Uri;
+import android.os.Build;
+import android.text.TextUtils;
+
+import com.quicktvui.sdk.core.EsData;
+import com.quicktvui.sdk.core.InitConfig;
+import com.quicktvui.sdk.core.internal.Constants;
+import com.sunrain.toolkit.utils.NetworkUtils;
+import com.sunrain.toolkit.utils.log.L;
+
+import java.io.File;
+
+/**
+ *
+ */
+public class CommonUtils {
+
+    public static boolean hasNetworkByPing() {
+//        String[] targets = new String[]{InitConfig.getDefault().getProxyHostName(), UrlConstants.getBaseUrl()};
+        String[] targets = new String[]{InitConfig.getDefault().getProxyHostName()};
+        for (String target : targets) {
+            if (TextUtils.isEmpty(target)) continue;
+            String host = Uri.parse(target).getHost();
+            int count = 5;
+            while (count > 0) {
+                L.logIF("ping " + host + " " + count);
+                if (NetworkUtils.isAvailableByPing(host)) return true;
+                count--;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 检查设备是否连接了Wi-Fi或网线
+     * @param context
+     * @return
+     */
+    public static boolean isConnectedToWifiOrEthernet(Context context) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        if (connectivityManager != null) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                Network network = connectivityManager.getActiveNetwork();
+                if (network == null) {
+                    return false;
+                }
+
+                NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
+                if (networkCapabilities != null) {
+                    return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
+                            networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET);
+                }
+            } else {
+                // 适配老版本
+                NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
+                if (networkInfo != null) {
+                    return networkInfo.getType() == ConnectivityManager.TYPE_WIFI ||
+                            networkInfo.getType() == ConnectivityManager.TYPE_ETHERNET;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean isContainsFlag(int flag) {
+        return isContainsFlag(InitConfig.getDefault().getFlags(), flag);
+    }
+
+    public static boolean isContainsFlag(int flags, int flag) {
+        return (flags & flag) == flag;
+    }
+
+    /** 是否开启UDP **/
+    public static boolean isEnableUdp(){
+        return isContainsFlag(InitConfig.FLAG_ENABLE_UDP);
+    }
+
+    /** 是否开启websocket **/
+    public static boolean isEnableWebSocket(){
+        return isContainsFlag(InitConfig.FLAG_ENABLE_WS);
+    }
+
+    /** 是否开启动态So **/
+    public static boolean isEnableDynamicSo(){
+        return isContainsFlag(InitConfig.FLAG_DYNAMIC_SO);
+    }
+
+    /** 是否开启崩溃监控 **/
+    public static boolean isEnableCrashWatch(){
+        return isContainsFlag(InitConfig.FLAG_WATCH_CRASH);
+    }
+
+    /** 是否开启接口加密 **/
+    public static boolean isEnableApiEnc() {
+        return isContainsFlag(InitConfig.FLAG_API_ENC);
+    }
+
+    /** 动态SO注入 **/
+    public static boolean isEnableDynamicSoInject() {
+        return isContainsFlag(InitConfig.FLAG_DYNAMIC_SO_INJECT);
+    }
+
+    /** 开启宿主升级检测 **/
+    public static boolean isEnableCheckUpgrade() {
+        return isContainsFlag(InitConfig.FLAG_CHECK_UPGRADE);
+    }
+
+    /** 是否跳过报活 **/
+    public static boolean isSkipActiveCountEvent(){
+        return isContainsFlag(InitConfig.FLAG_SKIP_COUNT_ACTIVE);
+    }
+
+    /** 是否关闭了所有埋点 **/
+    public static boolean isDisableAnalysis(){
+        return isContainsFlag(InitConfig.FLAG_DISABLE_ANALYSIS);
+    }
+
+    /** 当按下home键的时候不退出应用 **/
+    public static boolean isNotExitAppOnClickHomeKey(){
+        return isContainsFlag(InitConfig.FLAG_NO_EXIT_ON_CLICK_HOME);
+    }
+
+    /** 是否开启XLog **/
+    public static boolean isEnableXLog() {
+        return isContainsFlag(InitConfig.FLAG_SAVE_LOG);
+    }
+
+    /** 获取真实意图的nexus源 **/
+    public static String getRepositoryHost(EsData data) {
+        String repository = data.getRepository();
+        if(!TextUtils.isEmpty(repository)) return repository;
+        InitConfig cfg = InitConfig.getDefault();
+        return cfg == null ? null : cfg.repository();
+    }
+
+    public static boolean checkIsSafeFile(File file){
+        if(Constants.PATH_APP_FILES.equals(file.getName())) return true;
+        if(Constants.PATH_RPK_MD5.equals(file.getName())) return true;
+        return false;
+    }
+
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/CpuAbiUtils.java

@@ -0,0 +1,280 @@
+/*
+ *
+ * Copyright 2018 iQIYI.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package com.quicktvui.sdk.core.utils;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.os.Build;
+import android.text.TextUtils;
+
+import com.sunrain.toolkit.utils.log.L;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class CpuAbiUtils {
+    private static final String TAG = "CpuAbiUtils";
+    /* apk 中 lib 目录的前缀标示。比如 lib/armeabi/libshare_v2.so */
+    private static final String APK_LIB_DIR_PREFIX = "lib/";
+    /* libs目录so后缀 */
+    private static final String APK_LIB_SUFFIX = ".so";
+    /* 当前手机指令集 */
+    private static String currentInstructionSet = null;
+    /* 当前APP运行的主abi */
+    private static String primaryCpuAbi = null;
+
+    private static final Map<String, String> INSTRUCTION_SET_TO_ABI_MAP = new HashMap<>();
+    static {
+        // arm --> armeabi, armeabi-v7a，不放入map
+        INSTRUCTION_SET_TO_ABI_MAP.put("mips", "mips");
+        INSTRUCTION_SET_TO_ABI_MAP.put("mips64", "mips64");
+        INSTRUCTION_SET_TO_ABI_MAP.put("x86", "x86");
+        INSTRUCTION_SET_TO_ABI_MAP.put("x86_64", "x86_64");
+        INSTRUCTION_SET_TO_ABI_MAP.put("arm64", "arm64-v8a");
+    }
+
+    /**
+     * 获取当前运行的指令集
+     */
+    public static String getCurrentInstructionSet() {
+        if (!TextUtils.isEmpty(currentInstructionSet)) {
+            return currentInstructionSet;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // 5.0以上VMRuntime才有这个方法
+            try {
+                Class<?> clazz = Class.forName("dalvik.system.VMRuntime");
+                Method currentGet = clazz.getDeclaredMethod("getCurrentInstructionSet");
+                currentGet.setAccessible(true);
+
+                currentInstructionSet = (String) currentGet.invoke(null);
+                return currentInstructionSet;
+            } catch (Exception e) {
+                L.logW("get abi1", e);
+            }
+        } else {
+            // 4.x只支持arm指令集
+            currentInstructionSet = "arm";
+        }
+        //默认返回arm指令集
+        return "arm";
+    }
+
+    /**
+     * 获取设备支持的abi列表
+     */
+    public static String[] getSupportAbis() {
+        String[] cpuAbis;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            cpuAbis = Build.SUPPORTED_ABIS;
+        } else {
+            cpuAbis = new String[]{Build.CPU_ABI, Build.CPU_ABI2};
+        }
+        // avoid NPE
+        if (cpuAbis == null) {
+            cpuAbis = new String[0];
+        }
+
+        return cpuAbis;
+    }
+
+    /**
+     * 获取设备运行的cpuAbi模式
+     */
+    public static String getPrimaryCpuAbi(Context context) {
+        if (!TextUtils.isEmpty(primaryCpuAbi)) {
+            return primaryCpuAbi;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // 5.0以上Application才有primaryCpuAbi字段
+            try {
+                ApplicationInfo appInfo = context.getApplicationInfo();
+                Field abiField = ApplicationInfo.class.getDeclaredField("primaryCpuAbi");
+                abiField.setAccessible(true);
+                primaryCpuAbi = (String) abiField.get(appInfo);
+            } catch (Exception e) {
+                L.logW("get abi2", e);
+            }
+        }
+
+        if (TextUtils.isEmpty(primaryCpuAbi)) {
+            // 反射失败，读取指令集匹配
+            String instrSet = getCurrentInstructionSet();
+            String matchAbi = INSTRUCTION_SET_TO_ABI_MAP.get(instrSet);
+            if (!TextUtils.isEmpty(matchAbi)) {
+                primaryCpuAbi = matchAbi;
+            } else {
+                // arm指令集对应可能是armeabi或者armeabi-v7a，根据apk内的abi目录结构做匹配
+                primaryCpuAbi = findMatchedAbi(context);
+            }
+        }
+
+        return primaryCpuAbi;
+    }
+
+    /**
+     * 由于4.x的手机只能获取最多两个abi, 部分x86手机主ABI是x86，次ABI是armeabi-v7a
+     * 但是兼容armeabi，因此在末尾追加一个armeabi配置
+     */
+    private static String[] getCompatSupportAbis() {
+        ArrayList<String> compatAbis = new ArrayList<>();
+        String[] supportAbis = getSupportAbis();
+        boolean hasArmeabi = false;
+        for (String cpuAbi : supportAbis) {
+            if ("armeabi".equals(cpuAbi)) {
+                hasArmeabi = true;
+            }
+            compatAbis.add(cpuAbi);
+        }
+        if (!hasArmeabi) {
+            compatAbis.add("armeabi");
+        }
+        String[] toArray = new String[compatAbis.size()];
+        return compatAbis.toArray(toArray);
+    }
+
+    /**
+     * 根据宿主APK内放置的libs文件夹类型和
+     * 设备支持的abi列表选择最match的abi
+     */
+    private static String findMatchedAbi(Context context) {
+        String[] cpuAbis = getCompatSupportAbis();
+        boolean[] abiResolved = new boolean[cpuAbis.length];
+        String apkPath = context.getApplicationInfo().sourceDir;
+        ZipFile zipFile = null;
+        try {
+            zipFile = new ZipFile(apkPath);
+            Enumeration<? extends ZipEntry> entries = zipFile.entries();
+            ZipEntry entry;
+            while (entries.hasMoreElements()) {
+                entry = entries.nextElement();
+                String name = entry.getName();
+                if (!name.startsWith(APK_LIB_DIR_PREFIX)
+                        || !name.endsWith(APK_LIB_SUFFIX)) {
+                    continue;
+                }
+                String[] splits = name.split("/");
+                if (splits.length < 3) {
+                    continue;
+                }
+                // entry: lib/armeabi/libimagepipeline.so
+                String arch = splits[1];
+                for (int index = 0; index < cpuAbis.length; index++) {
+                    if (TextUtils.equals(cpuAbis[index], arch)) {
+                        // 对应arch目录下存在so库
+                        abiResolved[index] = true;
+                        break;
+                    }
+                }
+            }
+        } catch (IOException e) {
+            L.logW("get abi3", e);
+        } finally {
+            try {
+                zipFile.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        String matchedAbi = null;
+        for (int index = 0; index < cpuAbis.length; index++) {
+            if (abiResolved[index]) {
+                // 对应的abi目录下找到了so库
+                matchedAbi = cpuAbis[index];
+                break;
+            }
+        }
+        // 宿主没有放置lib目录，则按默认的模式运行
+        if (TextUtils.isEmpty(matchedAbi)) {
+            matchedAbi = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
+                    ? Build.SUPPORTED_ABIS[0] : Build.CPU_ABI;
+        }
+        return matchedAbi;
+    }
+
+    /**
+     * 获取与primaryCpuAbi能够兼容的abi
+     * 比如32位：armeabi与armeabi-v7a是兼容的
+     */
+    public static String getCompatCpuAbi(String primaryCpuAbi) {
+        if (TextUtils.equals(primaryCpuAbi, "armeabi")
+                && isCompatible("armeabi-v7a")) {
+            // 主abi是armeabi，如果设备支持armeabi-v7a，兼容模式
+            return "armeabi-v7a";
+        }
+
+        if (TextUtils.equals(primaryCpuAbi, "armeabi-v7a")
+                && isCompatible("armeabi")) {
+            // 主abi是armeabi-v7a，如果设备支持armeabi，兼容模式
+            return "armeabi";
+        }
+        return "";
+    }
+
+    /**
+     * 指定的cpuArch是否与设备兼容
+     */
+    private static boolean isCompatible(String cpuArch) {
+        String[] cpuAbis = getSupportAbis();
+        for (String cpuAbi : cpuAbis) {
+            if (TextUtils.equals(cpuAbi, cpuArch)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * APP进程是否运行在64位模式
+     */
+    public static boolean is64Bit() {
+        // 5.0以下默认不支持64位
+        boolean is64bit = false;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            // 6.0以上使用公开API获取
+            is64bit = android.os.Process.is64Bit();
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // 反射VMRuntime.getRuntime().is64Bit()方法，5.0上有这个方法
+            Boolean result = null;
+            try {
+                Class<?> clazz = Class.forName("dalvik.system.VMRuntime");
+                Method getRuntime = clazz.getDeclaredMethod("getRuntime");
+                getRuntime.setAccessible(true);
+                Object currentRuntime = getRuntime.invoke(null);
+
+                Method get64Bit = clazz.getDeclaredMethod("is64Bit");
+                get64Bit.setAccessible(true);
+                result = (Boolean)get64Bit.invoke(currentRuntime);
+            } catch (Exception e) {
+                L.logW("get abi3", e);
+            }
+            is64bit = result != null ? result : false;
+        }
+        return is64bit;
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/CrashHandler.java

@@ -0,0 +1,40 @@
+package com.quicktvui.sdk.core.utils;
+
+import android.support.annotation.NonNull;
+
+/**
+ *
+ */
+public class CrashHandler implements Thread.UncaughtExceptionHandler {
+
+    private Thread.UncaughtExceptionHandler mDefaultHandler;
+
+    private CrashHandler(Thread thread) {
+//        SecurityManager sm = System.getSecurityManager();
+//        if (sm != null) {
+//            sm.checkPermission(
+//                    new RuntimePermission("setDefaultUncaughtExceptionHandler")
+//            );
+//        }
+//
+//        SecurityManager security = System.getSecurityManager();
+//        if (security != null) {
+//            security.checkAccess(thread);
+//        }
+
+//        Thread.setDefaultUncaughtExceptionHandler();
+//        mDefaultHandler = thread.getUncaughtExceptionHandler();
+//        thread.setUncaughtExceptionHandler(this);
+    }
+
+    public static void startWatch(Thread thread) {
+//        new CrashHandler(thread);
+    }
+
+    @Override
+    public void uncaughtException(@NonNull Thread t, @NonNull Throwable e) {
+        if (mDefaultHandler != null) {
+            mDefaultHandler.uncaughtException(t, e);
+        }
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/DebugLog.java

@@ -0,0 +1,28 @@
+package com.quicktvui.sdk.core.utils;
+
+import com.sunrain.toolkit.utils.log.L;
+
+/**
+ *
+ */
+public class DebugLog {
+
+    private static final String TAG = "DEBUG_FILTER ";
+
+    public static void d(Object obj, String message) {
+        L.logDF(TAG + getObjectInfo(obj) + message);
+    }
+
+    public static void w(Object obj, String message) {
+        L.logWF(TAG + getObjectInfo(obj) + message);
+    }
+
+    public static void e(Object obj, String message) {
+        L.logEF(TAG + getObjectInfo(obj) + message);
+    }
+
+    private static String getObjectInfo(Object obj){
+        if(obj == null) return "null 0";
+        return obj.getClass().getSimpleName() + " " + obj.hashCode() + " ";
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/DefaultLifecycleObserver.java

@@ -0,0 +1,35 @@
+package com.quicktvui.sdk.core.utils;
+
+import android.arch.lifecycle.LifecycleObserver;
+import android.arch.lifecycle.LifecycleOwner;
+import android.support.annotation.NonNull;
+
+/**
+ * <br>
+ * 注释
+ * <br>
+ * <br>
+ * Created by WeiPeng on 2023-12-12 13:21
+ */
+public interface DefaultLifecycleObserver extends LifecycleObserver {
+
+    default void onCreate(@NonNull LifecycleOwner owner) {
+    }
+
+    default void onStart(@NonNull LifecycleOwner owner) {
+    }
+
+    default void onResume(@NonNull LifecycleOwner owner) {
+    }
+
+    default void onPause(@NonNull LifecycleOwner owner) {
+    }
+
+    default void onStop(@NonNull LifecycleOwner owner) {
+    }
+
+    default void onDestroy(@NonNull LifecycleOwner owner) {
+    }
+
+
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/utils/DexUtil.java

@@ -0,0 +1,75 @@
+package com.quicktvui.sdk.core.utils;
+
+import android.content.Context;
+import android.os.Build;
+
+import com.sunrain.toolkit.utils.ReflectUtils;
+import com.sunrain.toolkit.utils.log.L;
+
+import java.io.File;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import dalvik.system.DexFile;
+
+/**
+ *
+ */
+public class DexUtil {
+
+    public static void insertLibDir(Context context, File nativeLibsDir) {
+        try {
+            Comparator<File> nativeLibraryDirectoriesSort = (file, t1) -> file.getAbsolutePath().equals(nativeLibsDir.getAbsolutePath()) ? -1 :1;
+
+            ClassLoader baseClassLoader = context.getClassLoader();
+            if (L.DEBUG) L.logD("baseClassLoader: " + baseClassLoader);
+            Object basePathList = ReflectUtils.reflect(baseClassLoader).field("pathList").get();
+            if (L.DEBUG) L.logD("pathList:" + basePathList);
+
+            if(Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP_MR1){
+                File[] nativeLibraryDirectories = ReflectUtils.reflect(basePathList).field("nativeLibraryDirectories").get();
+                final int N = nativeLibraryDirectories.length;
+                File[] newNativeLibraryDirectories = new File[N + 1];
+                System.arraycopy(nativeLibraryDirectories, 0, newNativeLibraryDirectories, 0, N);
+                newNativeLibraryDirectories[N] = nativeLibsDir;
+                Arrays.sort(newNativeLibraryDirectories, nativeLibraryDirectoriesSort);
+                ReflectUtils.reflect(basePathList).field("nativeLibraryDirectories", newNativeLibraryDirectories);
+            }else{
+                List<File> nativeLibraryDirectories = ReflectUtils.reflect(basePathList).field("nativeLibraryDirectories").get();
+                if(nativeLibraryDirectories != null){
+                    for (File path : nativeLibraryDirectories) {
+                        if(path.getAbsolutePath().equals(nativeLibsDir.getAbsolutePath())) return;
+                    }
+                }
+                nativeLibraryDirectories.add(nativeLibsDir);
+                Collections.sort(nativeLibraryDirectories, nativeLibraryDirectoriesSort);
+
+                Object baseNativeLibraryPathElements = ReflectUtils.reflect(basePathList).field("nativeLibraryPathElements").get();
+                final int baseArrayLength = Array.getLength(baseNativeLibraryPathElements);
+
+                Class<?> elementClass = baseNativeLibraryPathElements.getClass().getComponentType();
+                Object allNativeLibraryPathElements = Array.newInstance(elementClass, baseArrayLength + 1);
+
+                Object element;
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    element = elementClass.getConstructor(File.class).newInstance(nativeLibsDir);
+                } else {
+                    element = elementClass.getConstructor(File.class, boolean.class, File.class, DexFile.class).newInstance(nativeLibsDir, true, null, null);
+                }
+
+                Array.set(allNativeLibraryPathElements, 0, element);
+                System.arraycopy(baseNativeLibraryPathElements, 0, allNativeLibraryPathElements, 1, baseArrayLength);
+
+                ReflectUtils.reflect(basePathList).field("nativeLibraryPathElements", allNativeLibraryPathElements);
+            }
+
+            if (L.DEBUG) L.logD("baseClassLoader new : " + baseClassLoader);
+
+        } catch (Exception e) {
+            L.logW("insert so", e);
+        }
+    }
+}