@quicktvui/ai 1.0.7 → 1.0.9

package/rules/.source/sdk/support/player-ijk/src/main/java/com/quicktvui/support/player/ijk/utils/FormatTools.java

@@ -0,0 +1,32 @@
+package com.quicktvui.support.player.ijk.utils;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class FormatTools {
+
+    /**
+     * 格式化网速
+     * @param orSpeed   传入的网速，单位 byte
+     * @return  单位 MBps
+     */
+    public static double formatSpeed(long orSpeed) {
+        BigDecimal bg = new BigDecimal(Double.toString(orSpeed / (1024 * 1024.0)));
+        return bg.setScale(2, RoundingMode.HALF_UP).doubleValue();
+    }
+
+    /**
+     * 格式化比特率
+     * @param orBitRate   传入的码率，单位 bit
+     * @return  单位 MBps
+     */
+    public static double formatBitRate(long orBitRate) {
+        BigDecimal bg = new BigDecimal(Double.toString(orBitRate / (1024 * 1024.0 * 8)));
+        return bg.setScale(2, RoundingMode.HALF_UP).doubleValue();
+    }
+
+    public static double formatNetSpeed(long totalByte, long milliSeconds) {
+        BigDecimal bg = new BigDecimal(Double.toString((totalByte / (milliSeconds / 1000.0)) / (1024 * 1024.0)));
+        return bg.setScale(2, RoundingMode.HALF_UP).doubleValue();
+    }
+}

package/rules/.source/sdk/support/player-ijk/src/main/java/com/quicktvui/support/player/ijk/utils/MetadataUtils.java

@@ -0,0 +1,150 @@
+package com.quicktvui.support.player.ijk.utils;
+
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaPlayer;
+import android.os.Build;
+
+import com.quicktvui.sdk.base.EsPromise;
+import com.quicktvui.sdk.base.args.EsArray;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.support.ijk.base.misc.AndroidTrackInfo;
+import com.quicktvui.support.ijk.base.misc.ITrackInfo;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MetadataUtils {
+
+    public static final String STREAM_KEY_INDEX = "index";
+    public static final String STREAM_KEY_SEEK_FLAG = "seekFlag";
+    public static final String STREAM_KEY_TRACK_TYPE = "trackType";
+    public static final String STREAM_KEY_LANGUAGE = "language";
+    public static final String STREAM_KEY_TITLE = "title";
+    public static final String STREAM_KEY_SUB_TYPE = "subType";
+    public static final String STREAM_KEY_CODEC = "codec";
+    public static final String STREAM_KEY_CHANNELS = "channels";
+    public static final String STREAM_KEY_CHANNEL_NAME = "channelName";
+    public static final String STREAM_KEY_VIDEO_WIDTH = "videoWidth";
+    public static final String STREAM_KEY_VIDEO_HEIGHT = "videoHeight";
+    public static final String IJK_STREAM_KEY_CODE_NAME = "codec_name";
+    public static final String IJK_STREAM_KEY_CHANNELS = "channels";
+    public static final String IJK_STREAM_KEY_WIDTH = "width";
+    public static final String IJK_STREAM_KEY_HEIGHT = "height";
+    public static final String APOLLO_STREAM_KEY_PLUGIN = "isPlugin";
+    public static final String APOLLO_STREAM_KEY_DETECTED_LANG = "detectedLanguage";
+    public static final String APOLLO_STREAM_KEY_ID = "resourceID";
+
+    private static final Map<String, Field> fieldMap = new HashMap<>();
+
+    public static void getAndroidTrackInfo(AndroidTrackInfo trackInfo, EsMap map) {
+        try {
+//            Field mTrackInfoField = trackInfo.getClass().getDeclaredField("mTrackInfo");
+            Field mTrackInfoField = getFieldByName("mTrackInfo", trackInfo.getClass());
+            mTrackInfoField.setAccessible(true);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+                MediaPlayer.TrackInfo mTrackInfo = (MediaPlayer.TrackInfo) mTrackInfoField.get(trackInfo);
+
+                if (mTrackInfo != null) {
+//                    @SuppressLint("PrivateApi") Field mFormatField = mTrackInfo.getClass().getDeclaredField("mFormat");
+                    Field mFormatField = getFieldByName("mFormat", mTrackInfo.getClass());
+                    mFormatField.setAccessible(true);
+                    MediaFormat mFormat = (MediaFormat) mFormatField.get(mTrackInfo);
+
+                    if (mFormat != null) {
+                        map.pushString(STREAM_KEY_CODEC, mFormat.getString(MediaFormat.KEY_MIME));
+
+                    }
+
+                }
+
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void getAndroidTracksInfo(String url, EsPromise promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+            MediaExtractor extractor = new MediaExtractor();
+            EsArray array = new EsArray();
+            try {
+                extractor.setDataSource(url);
+                for (int i = 0; i < extractor.getTrackCount(); i++) {
+                    MediaFormat trackFormat = extractor.getTrackFormat(i);
+                    if (trackFormat != null) {
+                        EsMap map = new EsMap();
+
+                        String mime = trackFormat.getString(MediaFormat.KEY_MIME);
+                        int trackType = getTrackType(mime);
+                        map.pushInt(STREAM_KEY_INDEX, i);
+
+                        map.pushBoolean(STREAM_KEY_SEEK_FLAG, true);
+                        map.pushInt(STREAM_KEY_TRACK_TYPE, trackType);
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+                            map.pushString(STREAM_KEY_LANGUAGE, trackFormat.getString(MediaFormat.KEY_LANGUAGE));
+                        }
+                        map.pushString(STREAM_KEY_CODEC, mime);
+
+                        if (trackType == ITrackInfo.MEDIA_TRACK_TYPE_AUDIO) {
+                            int channels;
+                            try {
+                                channels = trackFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
+                            } catch (NullPointerException e) {
+                                channels = 0;
+                            }
+                            String channelName = AudioChannelType.getChannelName(channels);
+                            map.pushInt(STREAM_KEY_CHANNELS, channels);
+                            map.pushString(STREAM_KEY_CHANNEL_NAME, channelName);
+                        } else if (trackType == ITrackInfo.MEDIA_TRACK_TYPE_VIDEO) {
+                            try {
+                                map.pushInt(STREAM_KEY_VIDEO_WIDTH, trackFormat.getInteger(MediaFormat.KEY_WIDTH));
+                                map.pushInt(STREAM_KEY_VIDEO_HEIGHT, trackFormat.getInteger(MediaFormat.KEY_HEIGHT));
+                            } catch (NullPointerException e) {
+                                e.printStackTrace();
+                            }
+                        }
+
+                        array.pushMap(map);
+                    }
+                    extractor.unselectTrack(i);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            } finally {
+                promise.resolve(array);
+                extractor.release();
+            }
+        }
+    }
+
+    public static int getTrackType(String mime) {
+        if (mime == null) return -1;
+        if (mime.startsWith("video/")) {
+            return 1;
+        }
+        if (mime.startsWith("audio/")) {
+            return 2;
+        }
+        if (mime.startsWith("subtitle/")) {
+            return 3;
+        }
+
+        return -1;
+    }
+
+    private static Field getFieldByName(String fieldName, Class<?> clazz) {
+        Field field = fieldMap.get(fieldName);
+        if (field != null) return field;
+        try {
+            field = clazz.getDeclaredField(fieldName);
+            fieldMap.put(fieldName, field);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return field;
+    }
+}

package/rules/.source/sdk/support/player-ijk/src/main/java/com/quicktvui/support/player/ijk/utils/PlayerThreadTools.java

@@ -0,0 +1,97 @@
+package com.quicktvui.support.player.ijk.utils;
+
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+
+public class PlayerThreadTools {
+
+    public static boolean useThread = false;
+    public static boolean threadQuit = false;
+    //    public static boolean useHandlerThread = true;
+    private static volatile PlayerThreadTools instance;
+    private Handler playerHandler;
+    private final Handler uiHandler;
+//    private final ExecutorService executorService;
+
+    private PlayerThreadTools() {
+        uiHandler = new Handler(Looper.getMainLooper());
+        initThread();
+    }
+
+    private void initThread() {
+        HandlerThread singleThread = new HandlerThread("PlayerSingleThread", Thread.MAX_PRIORITY);
+        singleThread.start();
+        playerHandler = new Handler(singleThread.getLooper());
+
+//        executorService = Executors.newSingleThreadExecutor();
+    }
+
+    public static PlayerThreadTools getInstance() {
+        if (instance == null) {
+            synchronized (PlayerThreadTools.class) {
+                if (instance == null) {
+                    instance = new PlayerThreadTools();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public void delegateMethod(Runnable task) {
+        if (useThread) {
+            runOnPlayerThread(task);
+        } else {
+            task.run();
+        }
+    }
+
+    public void runOnPlayerThread(Runnable task) {
+        runOnPlayerThread(task, 0);
+    }
+
+    public void runOnPlayerThread(Runnable task, int delayTime) {
+        if (threadQuit) {
+            initThread();
+            threadQuit = false;
+        }
+        if (delayTime > 0) {
+            playerHandler.postDelayed(task, delayTime);
+        } else {
+//            if (useHandlerThread)
+            playerHandler.post(task);
+//            else
+//                executorService.submit(task);
+        }
+    }
+
+    public void runOnUiThread(Runnable task) {
+        runOnUiThread(task, 0);
+    }
+
+    public void runOnUiThread(Runnable task, int delayTime) {
+        if (delayTime > 0) {
+            uiHandler.postDelayed(task, delayTime);
+        } else {
+            uiHandler.post(task);
+        }
+    }
+
+    public void init() {
+        useThread = false;
+    }
+
+    public void quit() {
+        Handler handler = playerHandler;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            handler.getLooper().quitSafely();
+        } else {
+            handler.getLooper().quit();
+        }
+        playerHandler = null;
+        threadQuit = true;
+        useThread = false;
+    }
+
+}

package/rules/.source/sdk/support/player-ijk/src/main/java/com/quicktvui/support/player/ijk/utils/StorageUtils.java

@@ -0,0 +1,159 @@
+package com.quicktvui.support.player.ijk.utils;
+
+import android.util.Log;
+
+import java.io.File;
+import java.io.IOException;
+
+
+/**
+ * 本地代理存储相关的工具类
+ */
+
+public class StorageUtils {
+
+    private static final String TAG = "StorageUtils";
+
+    public static final int DEFAULT_BUFFER_SIZE = 8 * 1024;
+    public static final String INFO_FILE = "video.info";
+    public static final String LOCAL_M3U8_SUFFIX = "_local.m3u8";
+    public static final String PROXY_M3U8_SUFFIX = "_proxy.m3u8";
+    public static final String M3U8_SUFFIX = ".m3u8";
+    public static final String NON_M3U8_SUFFIX = ".video";
+    public static final String FF_CONCAT_SUFFIX = ".ffconcat";
+
+    private static final Object sInfoFileLock = new Object();
+
+    public static final int CLEAR_CACHE_FLAG_USE_TIME = 1;          // 根据过期时间清除
+    public static final int CLEAR_CACHE_FLAG_USE_SIZE = 1 << 1;     // 根据总缓存大小清除
+    public static final int CLEAR_CACHE_FLAG_USE_NUMBER = 1 << 2;   // 根据缓存视频数量进行清除
+
+
+
+//    public static File getNumberCacheDir(File cacheRoot) {
+//        return new File(cacheRoot, "num");
+//    }
+//
+//    public static File getSizeCacheDir(File cacheRoot) {
+//        return new File(cacheRoot, "size");
+//    }
+//
+//    public static File getMixCacheDir(File cacheRoot) {
+//        return new File(cacheRoot, "mix");
+//    }
+
+    public static void clearAllData(File file) {
+        if (file == null || !file.exists()) return;
+        File[] listFiles = file.listFiles();
+        if (listFiles == null) return;
+        for (File itemFile : listFiles) { // 这里应该是单条视频的文件夹
+            deleteFile(itemFile);
+        }
+    }
+
+    /**
+     * 清理过期的数据 以文件夹为单位
+     *
+     * @param file        视频缓存路径
+     * @param expiredTime 过期时间
+     */
+    public static void cleanExpiredCacheData(File file, long expiredTime) {
+        if (file == null || !file.exists()) return;
+        File[] listFiles = file.listFiles();
+        if (listFiles == null) return;
+        for (File itemFile : listFiles) { // 这里应该是单条视频的文件夹
+            Log.d(TAG, "itemFile " + itemFile.getAbsolutePath());
+            if (isExpiredCacheData(itemFile.lastModified(), expiredTime)) {
+                Log.d(TAG, "deleteFile " + itemFile.getAbsolutePath());
+//                delete(itemFile);
+                deleteFile(itemFile);
+            }
+        }
+    }
+
+    private static boolean isExpiredCacheData(long lastModifiedTime, long expiredTime) {
+        long now = System.currentTimeMillis();
+        return Math.abs(now - lastModifiedTime) > expiredTime;
+    }
+
+    private static void delete(File file) throws IOException {
+        if (file.isFile() && file.exists()) {
+            boolean isDeleted = file.delete();
+            if (!isDeleted) {
+                throw new IOException(String.format("File %s cannot be deleted", file.getAbsolutePath()));
+            }
+        }
+    }
+
+    // 删除视频文件夹里的文件
+    public static boolean deleteFile(File file) {
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            if (files == null) return true;
+            for (File f : files) {
+                if (!f.delete()) return false;
+            }
+        }
+        return file.delete();
+    }
+
+    /**
+     * 获取file目录中所有文件的总大小
+     *
+     * @param file
+     * @return
+     */
+    public static long getTotalSize(File file) {
+        if (file.isDirectory()) {
+            long totalSize = 0;
+            File[] files = file.listFiles();
+            if (files == null) return 0;
+            for (File f : files) {
+                totalSize += getTotalSize(f);
+            }
+            return totalSize;
+        } else {
+            return file.length();
+        }
+    }
+
+    public static void setLastModifiedTimeStamp(File file) throws IOException {
+        if (file.exists()) {
+            long now = System.currentTimeMillis();
+            boolean modified = file.setLastModified(now);
+            if (!modified) {
+                modify(file);
+            }
+        }
+    }
+
+    //file是一个目录文件
+    private static void modify(File file) throws IOException {
+        File tempFile = new File(file, "tempFile");
+        if (!tempFile.exists()) {
+            tempFile.createNewFile();
+            tempFile.delete();
+        } else {
+            tempFile.delete();
+        }
+    }
+
+    // -----------------缓存改造分割线-------------------------
+
+    public static int addClearFlag(int clearFlags,int flag) {
+        clearFlags |= flag;
+        return clearFlags;
+    }
+
+    public static boolean containUseTime(int flags) {
+        return (flags & CLEAR_CACHE_FLAG_USE_TIME) > 0;
+    }
+
+    public static boolean containUseSize(int flags) {
+        return (flags & CLEAR_CACHE_FLAG_USE_SIZE) > 0;
+    }
+
+    public static boolean containUseNumber(int flags) {
+        return (flags & CLEAR_CACHE_FLAG_USE_NUMBER) > 0;
+    }
+}

package/rules/.source/sdk/support/player-ijk/src/main/java/com/quicktvui/support/player/ijk/utils/TimedHelper.java

@@ -0,0 +1,233 @@
+package com.quicktvui.support.player.ijk.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.text.TextUtils;
+import android.view.Gravity;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import android.support.annotation.NonNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.quicktvui.support.ijk.base.IjkMediaPlayer;
+import com.quicktvui.support.ijk.base.IjkTimedBitmap;
+import com.quicktvui.support.player.ijk.setting.Settings;
+import com.quicktvui.support.player.manager.utils.ScreenUtils;
+
+public class TimedHelper {
+    public static final int SIZE_TYPE_NORMAL = 0;
+    public static final int SIZE_TYPE_BIG = 1;
+    public static final int SIZE_TYPE_SUPER_BIG = 2;
+
+    // 0 imageview, 1 surface view
+    public static int VIEW_TYPE = 0;
+
+    private View imgContainerView;
+
+    private boolean tSEnble = false;
+    private SurfaceHolder tSHolder;
+
+    private final int screenWidth;
+    private final int screenHeight;
+    private final int bottomPadding;
+    private final float scale;
+    private int lastHeight;
+
+//    private static int sizeType = SIZE_TYPE_NORMAL;
+    private static final Map<String, Integer> sizeTypeMap = new HashMap<>();
+
+    public TimedHelper(Context context) {
+        screenWidth = ScreenUtils.getScreenWidth(context);
+        screenHeight = ScreenUtils.getScreenHeight(context);
+        scale = screenWidth / 1920.0f;
+        bottomPadding = (int) (30 * scale + 0.5f);
+        initView(context);
+    }
+
+    private void initView(Context context) {
+        if (VIEW_TYPE == 0) {
+            imgContainerView = new ImageView(context);
+            ImageView imageView = (ImageView) imgContainerView;
+//            imageView.setScaleType(ImageView.ScaleType.CENTER_INSIDE);
+            imageView.setScaleType(ImageView.ScaleType.FIT_CENTER);
+            imageView.setBackgroundColor(Color.TRANSPARENT);
+            imageView.setPadding(0, 0, 0, bottomPadding);
+        } else {
+            imgContainerView = new SurfaceView(context);
+            SurfaceHolder holder = ((SurfaceView) imgContainerView).getHolder();
+            holder.addCallback(new SurfaceHolder.Callback() {
+                @Override
+                public void surfaceCreated(@NonNull SurfaceHolder holder) {
+                    tSHolder = holder;
+                    tSEnble = true;
+                }
+
+                @Override
+                public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
+
+                }
+
+                @Override
+                public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+                    tSEnble = false;
+                }
+            });
+        }
+    }
+
+    public View getView() {
+        return imgContainerView;
+    }
+
+    public void addView(ViewGroup parent) {
+
+        FrameLayout.LayoutParams layoutParams_txt = new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                Gravity.BOTTOM);
+
+        imgContainerView.setLayoutParams(layoutParams_txt);
+
+        parent.addView(imgContainerView);
+    }
+
+    public void removeView(ViewGroup parent) {
+        parent.removeView(imgContainerView);
+    }
+
+    public void setBitmap(IjkTimedBitmap bitmap, String appName) {
+        if (VIEW_TYPE == 0) {
+            ImageView imageView = (ImageView) imgContainerView;
+            // 先增加bitmap回收逻辑（不一定有效果），有时间再尝试把bitmap绘制到surfaceView上
+            Drawable drawable = imageView.getDrawable();
+            if (drawable instanceof BitmapDrawable) {
+                Bitmap bitmapBefore = ((BitmapDrawable) drawable).getBitmap();
+                if (bitmapBefore != null) {
+                    bitmapBefore.recycle();
+                }
+            }
+
+//            int nowHeight = (int) (bitmap.getHeight() * scale + 0.5f);
+
+            float baseHeight = bitmap.getHeight() * scale;
+            int nowHeight;
+            Integer integer = sizeTypeMap.get(appName);
+            int sizeType = integer == null ? SIZE_TYPE_NORMAL : integer;
+            switch (sizeType) {
+                case SIZE_TYPE_BIG:
+                    nowHeight = (int) (baseHeight + 0.5f);
+                    break;
+                case SIZE_TYPE_SUPER_BIG:
+                    nowHeight = (int) (baseHeight * 1.25f + 0.5f);
+                    break;
+                default:
+                    nowHeight = (int) (baseHeight / 1.25f + 0.5f);
+                    break;
+            }
+
+            if (nowHeight != lastHeight) {
+                imageView.measure(View.MeasureSpec.makeMeasureSpec(screenWidth, View.MeasureSpec.EXACTLY),
+                        View.MeasureSpec.makeMeasureSpec(nowHeight + bottomPadding, View.MeasureSpec.EXACTLY));
+                imageView.layout(0, screenHeight - nowHeight - bottomPadding, screenWidth, screenHeight);
+
+                FrameLayout.LayoutParams layoutParams =
+                        (FrameLayout.LayoutParams) imageView.getLayoutParams();
+                layoutParams.height = nowHeight + bottomPadding;
+                imageView.setLayoutParams(layoutParams);
+
+                lastHeight = nowHeight;
+            }
+
+            imageView.setImageBitmap(bitmap.getBitmap());
+
+        } else {
+            if (tSEnble) {
+                Canvas canvas = tSHolder.lockCanvas();
+//                        canvas.drawColor(Color.RED);
+                canvas.drawBitmap(bitmap.getBitmap(), 0, 0, null);
+                tSHolder.unlockCanvasAndPost(canvas);
+            }
+        }
+    }
+
+    public void timedEnd() {
+        if (VIEW_TYPE == 0) {
+            ImageView imageView = (ImageView) imgContainerView;
+            // 先增加bitmap回收逻辑（不一定有效果），有时间再尝试把bitmap绘制到surfaceView上
+            Drawable drawable = imageView.getDrawable();
+            if (drawable instanceof BitmapDrawable) {
+                Bitmap bitmapBefore = ((BitmapDrawable) drawable).getBitmap();
+                if (bitmapBefore != null) {
+                    bitmapBefore.recycle();
+                }
+            }
+            imageView.setImageBitmap(null);
+        } else {
+            Canvas canvas = tSHolder.lockCanvas();
+            canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
+            tSHolder.unlockCanvasAndPost(canvas);
+        }
+
+    }
+
+    public static void setIjkOption(IjkMediaPlayer ijkMediaPlayer, Settings settings) {
+
+        int timedType = settings.getTimedType();
+
+        // 内嵌字幕总开关
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "subtitle",
+                timedType > IjkMediaPlayer.TIMED_CLOSE ? 1 : 0);
+        // 图形字幕开关
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "subtitle-bitmap",
+                timedType > IjkMediaPlayer.TIMED_ONLY_TEXT ? 1 : 0);
+        // 文本字幕开关
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "subtitle-text",
+                (timedType > IjkMediaPlayer.TIMED_CLOSE && timedType < IjkMediaPlayer.TIMED_ONLY_BITMAP) ? 1 : 0);
+
+        // 处理字幕默认选择参数
+        int subIndex = settings.getSubIndex();
+        boolean subChinese = settings.getSubChinese();
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER,
+                "subtitle-default-index", subIndex);
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER,
+                "subtitle-default-chi", subChinese ? 1 : 0);
+
+        // 处理音轨默认选择参数
+        int audioIndex = settings.getAudioIndex();
+        boolean audioChinese = settings.getAudioChinese();
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER,
+                "audio-default-index", audioIndex);
+        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER,
+                "audio-default-chi", audioChinese ? 1 : 0);
+
+    }
+
+    public static String formatTimedText(String input) {
+        if (TextUtils.isEmpty(input))
+            return input;
+        String pattern = "\\{.*?\\}";
+        Pattern regex = Pattern.compile(pattern);
+        Matcher matcher = regex.matcher(input);
+        return matcher.replaceAll("");
+    }
+
+    public static void setBitmapSubSizeType(String appName, int type) {
+        if (type >= 0 && type <= 2) {
+            sizeTypeMap.put(appName, type);
+        }
+    }
+}

package/rules/.source/sdk/support/player-manager/src/main/java/com/quicktvui/support/player/manager/Constants.java

@@ -0,0 +1,6 @@
+package com.quicktvui.support.player.manager;
+
+public class Constants {
+
+    public static final String TAG = "PlayerManager";
+}