Initial commit

sources/com/baidu/cloud/media/player/AbstractMediaPlayer.java

@@ -0,0 +1,138 @@
+package com.baidu.cloud.media.player;
+
+import android.os.Bundle;
+import com.baidu.cloud.media.player.IMediaPlayer;
+import com.baidu.cloud.media.player.misc.IMediaDataSource;
+
+/* loaded from: classes.dex */
+public abstract class AbstractMediaPlayer implements IMediaPlayer {
+    private IMediaPlayer.OnPreparedListener a;
+    private IMediaPlayer.OnCompletionListener b;
+    private IMediaPlayer.OnBufferingUpdateListener c;
+    private IMediaPlayer.OnSeekCompleteListener d;
+    private IMediaPlayer.OnVideoSizeChangedListener e;
+    private IMediaPlayer.OnErrorListener f;
+    private IMediaPlayer.OnInfoListener g;
+    private IMediaPlayer.OnTimedTextListener h;
+    private IMediaPlayer.OnMetadataListener i;
+
+    protected final void a() {
+        IMediaPlayer.OnPreparedListener onPreparedListener = this.a;
+        if (onPreparedListener != null) {
+            onPreparedListener.onPrepared(this);
+        }
+    }
+
+    protected final void a(int i) {
+        IMediaPlayer.OnBufferingUpdateListener onBufferingUpdateListener = this.c;
+        if (onBufferingUpdateListener != null) {
+            onBufferingUpdateListener.onBufferingUpdate(this, i);
+        }
+    }
+
+    protected final void a(int i, int i2, int i3, int i4) {
+        IMediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener = this.e;
+        if (onVideoSizeChangedListener != null) {
+            onVideoSizeChangedListener.onVideoSizeChanged(this, i, i2, i3, i4);
+        }
+    }
+
+    protected final void a(Bundle bundle) {
+        IMediaPlayer.OnMetadataListener onMetadataListener = this.i;
+        if (onMetadataListener != null) {
+            onMetadataListener.onMetadata(this, bundle);
+        }
+    }
+
+    protected final void a(BDTimedText bDTimedText) {
+        IMediaPlayer.OnTimedTextListener onTimedTextListener = this.h;
+        if (onTimedTextListener != null) {
+            onTimedTextListener.onTimedText(this, bDTimedText);
+        }
+    }
+
+    protected final boolean a(int i, int i2) {
+        IMediaPlayer.OnErrorListener onErrorListener = this.f;
+        return onErrorListener != null && onErrorListener.onError(this, i, i2);
+    }
+
+    protected final void b() {
+        IMediaPlayer.OnCompletionListener onCompletionListener = this.b;
+        if (onCompletionListener != null) {
+            onCompletionListener.onCompletion(this);
+        }
+    }
+
+    protected final boolean b(int i, int i2) {
+        IMediaPlayer.OnInfoListener onInfoListener = this.g;
+        return onInfoListener != null && onInfoListener.onInfo(this, i, i2);
+    }
+
+    protected final void c() {
+        IMediaPlayer.OnSeekCompleteListener onSeekCompleteListener = this.d;
+        if (onSeekCompleteListener != null) {
+            onSeekCompleteListener.onSeekComplete(this);
+        }
+    }
+
+    public void resetListeners() {
+        this.a = null;
+        this.c = null;
+        this.b = null;
+        this.d = null;
+        this.e = null;
+        this.f = null;
+        this.g = null;
+        this.h = null;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public void setDataSource(IMediaDataSource iMediaDataSource) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnBufferingUpdateListener(IMediaPlayer.OnBufferingUpdateListener onBufferingUpdateListener) {
+        this.c = onBufferingUpdateListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnCompletionListener(IMediaPlayer.OnCompletionListener onCompletionListener) {
+        this.b = onCompletionListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnErrorListener(IMediaPlayer.OnErrorListener onErrorListener) {
+        this.f = onErrorListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnInfoListener(IMediaPlayer.OnInfoListener onInfoListener) {
+        this.g = onInfoListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnMetadataListener(IMediaPlayer.OnMetadataListener onMetadataListener) {
+        this.i = onMetadataListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnPreparedListener(IMediaPlayer.OnPreparedListener onPreparedListener) {
+        this.a = onPreparedListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnSeekCompleteListener(IMediaPlayer.OnSeekCompleteListener onSeekCompleteListener) {
+        this.d = onSeekCompleteListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnTimedTextListener(IMediaPlayer.OnTimedTextListener onTimedTextListener) {
+        this.h = onTimedTextListener;
+    }
+
+    @Override // com.baidu.cloud.media.player.IMediaPlayer
+    public final void setOnVideoSizeChangedListener(IMediaPlayer.OnVideoSizeChangedListener onVideoSizeChangedListener) {
+        this.e = onVideoSizeChangedListener;
+    }
+}

sources/com/baidu/cloud/media/player/BDCloudLibLoader.java

@@ -0,0 +1,6 @@
+package com.baidu.cloud.media.player;
+
+/* loaded from: classes.dex */
+public interface BDCloudLibLoader {
+    void loadLibrary(String str) throws UnsatisfiedLinkError, SecurityException;
+}

sources/com/baidu/cloud/media/player/BDTimedText.java

@@ -0,0 +1,24 @@
+package com.baidu.cloud.media.player;
+
+import android.graphics.Rect;
+
+/* loaded from: classes.dex */
+public final class BDTimedText {
+    private Rect a;
+    private String b;
+
+    public BDTimedText(Rect rect, String str) {
+        this.a = null;
+        this.b = null;
+        this.a = rect;
+        this.b = str;
+    }
+
+    public Rect getBounds() {
+        return this.a;
+    }
+
+    public String getText() {
+        return this.b;
+    }
+}

sources/com/baidu/cloud/media/player/IMediaPlayer.java

@@ -0,0 +1,165 @@
+package com.baidu.cloud.media.player;
+
+import android.content.Context;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import com.baidu.cloud.media.player.misc.IMediaDataSource;
+import com.baidu.cloud.media.player.misc.ITrackInfo;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public interface IMediaPlayer {
+    public static final int MEDIA_ERROR_AUTH_FAILURE = -1000;
+    public static final int MEDIA_ERROR_IO = -1004;
+    public static final int MEDIA_ERROR_MALFORMED = -1007;
+    public static final int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200;
+    public static final int MEDIA_ERROR_SERVER_DIED = 100;
+    public static final int MEDIA_ERROR_TIMED_OUT = -110;
+    public static final int MEDIA_ERROR_UNKNOWN = 1;
+    public static final int MEDIA_ERROR_UNSUPPORTED = -1010;
+    public static final int MEDIA_INFO_AUDIO_RENDERING_START = 10002;
+    public static final int MEDIA_INFO_BAD_INTERLEAVING = 800;
+    public static final int MEDIA_INFO_BUFFERING_END = 702;
+    public static final int MEDIA_INFO_BUFFERING_START = 701;
+    public static final int MEDIA_INFO_FRAMECHASING_END = 10004;
+    public static final int MEDIA_INFO_FRAMECHASING_START = 10003;
+    public static final int MEDIA_INFO_MEDIA_CHANGE_END = 10006;
+    public static final int MEDIA_INFO_MEDIA_CHANGE_START = 10005;
+    public static final int MEDIA_INFO_METADATA_UPDATE = 802;
+    public static final int MEDIA_INFO_NETWORK_BANDWIDTH = 703;
+    public static final int MEDIA_INFO_NOT_SEEKABLE = 801;
+    public static final int MEDIA_INFO_STARTED_AS_NEXT = 2;
+    public static final int MEDIA_INFO_SUBTITLE_TIMED_OUT = 902;
+    public static final int MEDIA_INFO_TIMED_TEXT_ERROR = 900;
+    public static final int MEDIA_INFO_UNKNOWN = 1;
+    public static final int MEDIA_INFO_UNSUPPORTED_SUBTITLE = 901;
+    public static final int MEDIA_INFO_VIDEO_RENDERING_START = 3;
+    public static final int MEDIA_INFO_VIDEO_ROTATION_CHANGED = 10001;
+    public static final int MEDIA_INFO_VIDEO_TRACK_LAGGING = 700;
+
+    public interface OnBufferingUpdateListener {
+        void onBufferingUpdate(IMediaPlayer iMediaPlayer, int i);
+    }
+
+    public interface OnCompletionListener {
+        void onCompletion(IMediaPlayer iMediaPlayer);
+    }
+
+    public interface OnErrorListener {
+        boolean onError(IMediaPlayer iMediaPlayer, int i, int i2);
+    }
+
+    public interface OnInfoListener {
+        boolean onInfo(IMediaPlayer iMediaPlayer, int i, int i2);
+    }
+
+    public interface OnMetadataListener {
+        void onMetadata(IMediaPlayer iMediaPlayer, Bundle bundle);
+    }
+
+    public interface OnPreparedListener {
+        void onPrepared(IMediaPlayer iMediaPlayer);
+    }
+
+    public interface OnSeekCompleteListener {
+        void onSeekComplete(IMediaPlayer iMediaPlayer);
+    }
+
+    public interface OnTimedTextListener {
+        void onTimedText(IMediaPlayer iMediaPlayer, BDTimedText bDTimedText);
+    }
+
+    public interface OnVideoSizeChangedListener {
+        void onVideoSizeChanged(IMediaPlayer iMediaPlayer, int i, int i2, int i3, int i4);
+    }
+
+    int getAudioSessionId();
+
+    long getCurrentPosition();
+
+    String getDataSource();
+
+    long getDuration();
+
+    c getMediaInfo();
+
+    ITrackInfo[] getTrackInfo();
+
+    int getVideoHeight();
+
+    int getVideoSarDen();
+
+    int getVideoSarNum();
+
+    int getVideoWidth();
+
+    boolean isLooping();
+
+    boolean isPlayable();
+
+    boolean isPlaying();
+
+    void pause() throws IllegalStateException;
+
+    void prepareAsync() throws IllegalStateException;
+
+    void release();
+
+    void reset();
+
+    void seekTo(long j) throws IllegalStateException;
+
+    void setAudioStreamType(int i);
+
+    void setDataSource(Context context, Uri uri) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException;
+
+    void setDataSource(Context context, Uri uri, Map<String, String> map) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException;
+
+    void setDataSource(IMediaDataSource iMediaDataSource);
+
+    void setDataSource(FileDescriptor fileDescriptor) throws IOException, IllegalArgumentException, IllegalStateException;
+
+    void setDataSource(String str) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException;
+
+    void setDisplay(SurfaceHolder surfaceHolder);
+
+    void setKeepInBackground(boolean z);
+
+    void setLogEnabled(boolean z);
+
+    void setLooping(boolean z);
+
+    void setOnBufferingUpdateListener(OnBufferingUpdateListener onBufferingUpdateListener);
+
+    void setOnCompletionListener(OnCompletionListener onCompletionListener);
+
+    void setOnErrorListener(OnErrorListener onErrorListener);
+
+    void setOnInfoListener(OnInfoListener onInfoListener);
+
+    void setOnMetadataListener(OnMetadataListener onMetadataListener);
+
+    void setOnPreparedListener(OnPreparedListener onPreparedListener);
+
+    void setOnSeekCompleteListener(OnSeekCompleteListener onSeekCompleteListener);
+
+    void setOnTimedTextListener(OnTimedTextListener onTimedTextListener);
+
+    void setOnVideoSizeChangedListener(OnVideoSizeChangedListener onVideoSizeChangedListener);
+
+    void setScreenOnWhilePlaying(boolean z);
+
+    void setSurface(Surface surface);
+
+    void setVolume(float f, float f2);
+
+    void setWakeMode(Context context, int i);
+
+    void start() throws IllegalStateException;
+
+    void stop() throws IllegalStateException;
+}

sources/com/baidu/cloud/media/player/a.java

@@ -0,0 +1,193 @@
+package com.baidu.cloud.media.player;
+
+import android.media.MediaCodecInfo;
+import android.os.Build;
+import android.text.TextUtils;
+import android.util.Log;
+import com.ijm.dataencryption.de.DataDecryptTool;
+import com.ubt.jimu.base.util.FileUtil;
+import com.ubt.jimu.unity.bluetooth.UnityActivity;
+import com.ubtrobot.jimu.robotapi.PeripheralType;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class a {
+    private static Map<String, Integer> d;
+    public MediaCodecInfo a;
+    public int b = 0;
+    public String c;
+
+    public static a a(MediaCodecInfo mediaCodecInfo, String str) {
+        if (mediaCodecInfo == null || Build.VERSION.SDK_INT < 16) {
+            return null;
+        }
+        String name = mediaCodecInfo.getName();
+        if (TextUtils.isEmpty(name)) {
+            return null;
+        }
+        String lowerCase = name.toLowerCase(Locale.US);
+        int i = 600;
+        if (!lowerCase.startsWith("omx.")) {
+            i = 100;
+        } else if (lowerCase.startsWith("omx.pv") || lowerCase.startsWith("omx.google.") || lowerCase.startsWith("omx.ffmpeg.") || lowerCase.startsWith("omx.k3.ffmpeg.") || lowerCase.startsWith("omx.avcodec.")) {
+            i = 200;
+        } else {
+            if (!lowerCase.startsWith("omx.ittiam.")) {
+                if (!lowerCase.startsWith("omx.mtk.")) {
+                    Integer num = a().get(lowerCase);
+                    if (num != null) {
+                        i = num.intValue();
+                    } else {
+                        try {
+                            if (mediaCodecInfo.getCapabilitiesForType(str) != null) {
+                                i = IMediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING;
+                            }
+                        } catch (Throwable unused) {
+                        }
+                    }
+                } else if (Build.VERSION.SDK_INT >= 18 && !lowerCase.endsWith("decoder.mpeg4")) {
+                    i = 800;
+                }
+            }
+            i = 0;
+        }
+        a aVar = new a();
+        aVar.a = mediaCodecInfo;
+        aVar.b = i;
+        aVar.c = str;
+        return aVar;
+    }
+
+    public static String a(int i) {
+        return i != 1 ? i != 2 ? i != 4 ? i != 8 ? i != 16 ? i != 32 ? i != 64 ? "Unknown" : "High444" : "High422" : "High10" : "High" : "Extends" : "Main" : "Baseline";
+    }
+
+    public static String a(int i, int i2) {
+        return String.format(Locale.US, " %s Profile Level %s (%d,%d)", a(i), b(i2), Integer.valueOf(i), Integer.valueOf(i2));
+    }
+
+    private static synchronized Map<String, Integer> a() {
+        synchronized (a.class) {
+            if (d != null) {
+                return d;
+            }
+            d = new TreeMap(String.CASE_INSENSITIVE_ORDER);
+            d.put("OMX.Nvidia.h264.decode", 800);
+            d.put("OMX.Nvidia.h264.decode.secure", 300);
+            d.put("OMX.Intel.hw_vd.h264", Integer.valueOf(IMediaPlayer.MEDIA_INFO_NOT_SEEKABLE));
+            d.put("OMX.Intel.VideoDecoder.AVC", 800);
+            d.put("OMX.qcom.video.decoder.avc", 800);
+            d.put("OMX.ittiam.video.decoder.avc", 0);
+            d.put("OMX.SEC.avc.dec", 800);
+            d.put("OMX.SEC.AVC.Decoder", 799);
+            d.put("OMX.SEC.avcdec", 798);
+            d.put("OMX.SEC.avc.sw.dec", 200);
+            d.put("OMX.Exynos.avc.dec", 800);
+            d.put("OMX.Exynos.AVC.Decoder", 799);
+            d.put("OMX.k3.video.decoder.avc", 800);
+            d.put("OMX.IMG.MSVDX.Decoder.AVC", 800);
+            d.put("OMX.TI.DUCATI1.VIDEO.DECODER", 800);
+            d.put("OMX.rk.video_decoder.avc", 800);
+            d.put("OMX.amlogic.avc.decoder.awesome", 800);
+            d.put("OMX.MARVELL.VIDEO.HW.CODA7542DECODER", 800);
+            d.put("OMX.MARVELL.VIDEO.H264DECODER", 200);
+            d.remove("OMX.Action.Video.Decoder");
+            d.remove("OMX.allwinner.video.decoder.avc");
+            d.remove("OMX.BRCM.vc4.decoder.avc");
+            d.remove("OMX.brcm.video.h264.hw.decoder");
+            d.remove("OMX.brcm.video.h264.decoder");
+            d.remove("OMX.cosmo.video.decoder.avc");
+            d.remove("OMX.duos.h264.decoder");
+            d.remove("OMX.hantro.81x0.video.decoder");
+            d.remove("OMX.hantro.G1.video.decoder");
+            d.remove("OMX.hisi.video.decoder");
+            d.remove("OMX.LG.decoder.video.avc");
+            d.remove("OMX.MS.AVC.Decoder");
+            d.remove("OMX.RENESAS.VIDEO.DECODER.H264");
+            d.remove("OMX.RTK.video.decoder");
+            d.remove("OMX.sprd.h264.decoder");
+            d.remove("OMX.ST.VFM.H264Dec");
+            d.remove("OMX.vpu.video_decoder.avc");
+            d.remove("OMX.WMT.decoder.avc");
+            d.remove("OMX.bluestacks.hw.decoder");
+            d.put("OMX.google.h264.decoder", 200);
+            d.put("OMX.google.h264.lc.decoder", 200);
+            d.put("OMX.k3.ffmpeg.decoder", 200);
+            d.put("OMX.ffmpeg.video.decoder", 200);
+            d.put("OMX.sprd.soft.h264.decoder", 200);
+            return d;
+        }
+    }
+
+    public static String b(int i) {
+        if (i == 1) {
+            return "1";
+        }
+        if (i == 2) {
+            return "1b";
+        }
+        switch (i) {
+            case 4:
+                return "11";
+            case 8:
+                return "12";
+            case 16:
+                return "13";
+            case 32:
+                return "2";
+            case 64:
+                return "21";
+            case PeripheralType.SERVO /* 128 */:
+                return "22";
+            case DataDecryptTool.DECRYPT_ALL_FILE /* 256 */:
+                return "3";
+            case DataDecryptTool.DECRYPT_DB_FILE /* 512 */:
+                return "31";
+            case DataDecryptTool.DECRYPT_SP_FILE /* 1024 */:
+                return "32";
+            case 2048:
+                return "4";
+            case FileUtil.ZIP_BUFFER_SIZE /* 4096 */:
+                return "41";
+            case UnityActivity.BLOCKLY_TYPE_NONE /* 8192 */:
+                return "42";
+            case 16384:
+                return "5";
+            case 32768:
+                return "51";
+            case 65536:
+                return "52";
+            default:
+                return "0";
+        }
+    }
+
+    public void a(String str) {
+        int i;
+        int i2;
+        if (Build.VERSION.SDK_INT < 16) {
+            return;
+        }
+        try {
+            MediaCodecInfo.CodecCapabilities capabilitiesForType = this.a.getCapabilitiesForType(str);
+            if (capabilitiesForType == null || capabilitiesForType.profileLevels == null) {
+                i = 0;
+                i2 = 0;
+            } else {
+                i = 0;
+                i2 = 0;
+                for (MediaCodecInfo.CodecProfileLevel codecProfileLevel : capabilitiesForType.profileLevels) {
+                    if (codecProfileLevel != null) {
+                        i = Math.max(i, codecProfileLevel.profile);
+                        i2 = Math.max(i2, codecProfileLevel.level);
+                    }
+                }
+            }
+            Log.i("BDCloudMediaCodecInfo", String.format(Locale.US, "%s", a(i, i2)));
+        } catch (Throwable unused) {
+            Log.i("BDCloudMediaCodecInfo", "profile-level: exception");
+        }
+    }
+}

sources/com/baidu/cloud/media/player/a/a.java

@@ -0,0 +1,89 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.util.Log;
+import com.baidu.cloud.media.player.BDCloudMediaPlayer;
+import java.util.Random;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+class a {
+    private String a;
+    private String b;
+    private String c = "";
+    private String d = BDCloudMediaPlayer.SDK_VERSION;
+    private String e = "sw";
+    private String f = "";
+    private e g;
+    private f h;
+    private c i;
+    private JSONObject j;
+
+    public a(Context context, String str) {
+        this.g = new e(context, str);
+        this.h = new f(context);
+        this.i = new c(context);
+    }
+
+    private String a(int i) {
+        Random random = new Random();
+        StringBuffer stringBuffer = new StringBuffer();
+        for (int i2 = 0; i2 < i; i2++) {
+            stringBuffer.append("abcdefghijklmnopqrstuvwxyz".charAt(random.nextInt(26)));
+        }
+        return stringBuffer.toString();
+    }
+
+    private String c() {
+        return ("" + System.currentTimeMillis()) + a(8);
+    }
+
+    public JSONObject a() {
+        if (this.j == null) {
+            this.j = new JSONObject();
+            try {
+                this.j.put("url", this.a);
+                this.j.put("vvid", this.b);
+                this.j.put("isLive", true);
+                this.j.put("playerVersion", this.d);
+                this.j.put("decodeMode", this.e);
+                this.j.put("ak", this.f);
+                this.j.put("bitrate", 0);
+            } catch (Exception e) {
+                Log.d("BaseInfo", "" + e.getMessage());
+            }
+        }
+        try {
+            this.j.put("playID", this.c);
+        } catch (JSONException e2) {
+            e2.printStackTrace();
+        }
+        return this.j;
+    }
+
+    public void a(String str) {
+        if (str == null || str.equals("")) {
+            return;
+        }
+        this.a = str;
+        this.b = c();
+        Log.i("BaseInfo", "Current vvid is:" + this.b);
+        this.j = null;
+    }
+
+    public void a(String str, String str2, String str3) {
+        this.d = str;
+        this.e = str2;
+        this.f = str3;
+        this.j = null;
+    }
+
+    public String b() {
+        return this.b;
+    }
+
+    public void b(String str) {
+        this.c = str;
+    }
+}

sources/com/baidu/cloud/media/player/a/b.java

@@ -0,0 +1,398 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import com.baidu.cloud.media.player.BDCloudMediaPlayer;
+import com.baidu.uaq.agent.android.AgentConfig;
+import com.baidu.uaq.agent.android.UAQ;
+import com.baidu.uaq.agent.android.customtransmission.APMAgent;
+import com.baidu.uaq.agent.android.customtransmission.APMUploadConfigure;
+import com.baidu.uaq.agent.android.customtransmission.APMUploadHandler;
+import com.baidu.uaq.agent.android.customtransmission.MergeBlockCallBack;
+import com.ubt.jimu.course.view.fragment.JimuMissionListFragment;
+import java.util.HashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes.dex */
+public class b {
+    private static String a = "";
+    private static boolean b = false;
+    private static b h;
+    private a c;
+    private APMAgent i;
+    private final APMUploadHandler j;
+    private APMUploadHandler k;
+    private long d = 0;
+    private boolean e = false;
+    private long f = 0;
+    private ExecutorService g = null;
+    private MergeBlockCallBack l = new MergeBlockCallBack() { // from class: com.baidu.cloud.media.player.a.b.3
+    };
+    private MergeBlockCallBack m = new MergeBlockCallBack() { // from class: com.baidu.cloud.media.player.a.b.4
+    };
+
+    private b(Context context) {
+        this.c = new a(context, a);
+        d.a().a(context);
+        this.i = UAQ.getInstance().setConfig(new AgentConfig.Builder().APIKey("6ab8e94e75b94316ae7cf4bfb6bd46e7").usePersistentUUID(true).reportCrashes(true).thingsMonitor(true).build()).startAPM(context.getApplicationContext());
+        APMUploadConfigure aPMUploadConfigure = new APMUploadConfigure(APMUploadConfigure.APMUPLOADNAME, null, this.m);
+        long j = 60;
+        aPMUploadConfigure.setInterval4g(j);
+        long j2 = 15;
+        aPMUploadConfigure.setIntervalWifi(j2);
+        long j3 = 204800;
+        long j4 = 86400;
+        aPMUploadConfigure.setMaxbytes4g(j3, j4);
+        long j5 = 0;
+        aPMUploadConfigure.setMaxbyteswifi(j5, j4);
+        aPMUploadConfigure.enableRetransmission(true);
+        HashMap<String, String> hashMap = new HashMap<>();
+        hashMap.put("Content-Type", "application/json");
+        hashMap.put("Content-Encoding", "deflate");
+        aPMUploadConfigure.setHeaderMap(hashMap);
+        this.j = this.i.addUploadConfigure(aPMUploadConfigure);
+        if (b) {
+            APMUploadConfigure aPMUploadConfigure2 = new APMUploadConfigure("userOperation", "https://drm.media.baidubce.com:8888/v2/sdk/player", this.l);
+            aPMUploadConfigure2.setInterval4g(j);
+            aPMUploadConfigure2.setIntervalWifi(j2);
+            aPMUploadConfigure2.setMaxbytes4g(j3, j4);
+            aPMUploadConfigure2.setMaxbyteswifi(j5, j4);
+            aPMUploadConfigure2.enableRetransmission(true);
+            HashMap<String, String> hashMap2 = new HashMap<>();
+            hashMap2.put("Content-Type", "application/json");
+            hashMap2.put("Content-Encoding", "gzip");
+            aPMUploadConfigure2.setHeaderMap(hashMap2);
+            this.k = this.i.addUploadConfigure(aPMUploadConfigure2);
+        }
+    }
+
+    public static b a(Context context) {
+        if (h == null) {
+            h = new b(context);
+        }
+        return h;
+    }
+
+    public static void a(String str) {
+        a = str;
+    }
+
+    private void a(String str, JSONObject jSONObject) throws JSONException {
+        if (!b || this.k == null) {
+            return;
+        }
+        jSONObject.put("type", str);
+        jSONObject.put("time", System.currentTimeMillis());
+        if (!TextUtils.isEmpty(this.c.b())) {
+            jSONObject.put("session", this.c.b());
+        }
+        final String jSONObject2 = jSONObject.toString();
+        Runnable runnable = new Runnable() { // from class: com.baidu.cloud.media.player.a.b.1
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    b.this.i.addLogWithHandler(b.this.k, jSONObject2);
+                } catch (Exception e) {
+                    Log.d("APMEventHandle", "" + e.getMessage());
+                }
+            }
+        };
+        ExecutorService executorService = this.g;
+        if (executorService == null || executorService.isShutdown()) {
+            this.g = Executors.newSingleThreadExecutor();
+        }
+        this.g.execute(runnable);
+    }
+
+    public static void a(boolean z) {
+        b = z;
+    }
+
+    private void d(JSONObject jSONObject) {
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            jSONObject2.put("TraceId", this.c.b());
+            jSONObject2.put("CommData", this.c.a());
+            jSONObject2.put("Event", jSONObject);
+            JSONObject jSONObject3 = new JSONObject();
+            jSONObject3.put("Trace", jSONObject2);
+            final String jSONObject4 = jSONObject3.toString();
+            Runnable runnable = new Runnable() { // from class: com.baidu.cloud.media.player.a.b.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    try {
+                        b.this.i.addLogWithHandler(b.this.j, jSONObject4);
+                    } catch (Exception e) {
+                        Log.d("APMEventHandle", "" + e.getMessage());
+                    }
+                }
+            };
+            if (this.g == null || this.g.isShutdown()) {
+                this.g = Executors.newSingleThreadExecutor();
+            }
+            this.g.execute(runnable);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "" + e.getMessage());
+        }
+    }
+
+    public void a() {
+        try {
+            a("dealloc", new JSONObject());
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "release " + e.getMessage());
+        }
+        this.i.stopAPM();
+        h = null;
+    }
+
+    public void a(float f) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put(JimuMissionListFragment.POSITION, f);
+            a("pause", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onUserPause " + e.getMessage());
+        }
+    }
+
+    public void a(int i) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "domainIPFound");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            jSONObject.put("Duration", i);
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void a(int i, int i2, int i3) {
+        JSONObject jSONObject = new JSONObject();
+        JSONObject jSONObject2 = new JSONObject();
+        try {
+            jSONObject.put(BDCloudMediaPlayer.OnNativeInvokeListener.ARG_ERROR, i);
+            jSONObject.put("errorInfo", i2);
+            jSONObject2.put("Name", "playEnd");
+            jSONObject2.put("StartTime", System.currentTimeMillis());
+            jSONObject2.put("Code", i3);
+            JSONObject jSONObject3 = new JSONObject();
+            jSONObject3.put("detail", "what=" + i + ";extra=" + i2);
+            jSONObject2.put("EventData", jSONObject3);
+            a(BDCloudMediaPlayer.OnNativeInvokeListener.ARG_ERROR, jSONObject);
+            d(jSONObject2);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onPlayFail " + e.getMessage());
+        }
+    }
+
+    public void a(long j) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "httpConnected");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            jSONObject.put("Duration", j);
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void a(String str, String str2, String str3) {
+        this.c.a(str, str2, str3);
+    }
+
+    public void a(JSONObject jSONObject) {
+        try {
+            a("play", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onUserPlay " + e.getMessage());
+        }
+    }
+
+    public void b() {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "playerCreated");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void b(int i) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "networkSpeed");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            JSONObject jSONObject2 = new JSONObject();
+            jSONObject2.put("speed", i);
+            jSONObject.put("EventData", jSONObject2);
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onNetworkSpeedReport " + e.getMessage());
+        }
+    }
+
+    public void b(long j) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "firstFrameRendered");
+            long currentTimeMillis = System.currentTimeMillis();
+            jSONObject.put("StartTime", currentTimeMillis);
+            jSONObject.put("Duration", currentTimeMillis - j);
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void b(String str) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("videoUrl", str);
+            a("init", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "release " + e.getMessage());
+        }
+        this.c.a(str);
+    }
+
+    public void b(JSONObject jSONObject) {
+        try {
+            a("end", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onUserPlayEnd " + e.getMessage());
+        }
+    }
+
+    public void c() {
+        this.e = true;
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "frameChasingStart");
+            this.f = System.currentTimeMillis();
+            jSONObject.put("StartTime", this.f);
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void c(long j) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "firstBufferingEnd");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            jSONObject.put("Duration", j);
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onFirstBufferEnd " + e.getMessage());
+        }
+    }
+
+    public void c(String str) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "updateCdn");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            JSONObject jSONObject2 = new JSONObject();
+            jSONObject2.put("cdnIp", str);
+            jSONObject.put("EventData", jSONObject2);
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onUpdateCdn " + e.getMessage());
+        }
+    }
+
+    public void c(JSONObject jSONObject) {
+        try {
+            a("seek", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onUserSeek " + e.getMessage());
+        }
+    }
+
+    public void d() {
+        this.e = false;
+        JSONObject jSONObject = new JSONObject();
+        try {
+            if (this.f <= 0) {
+                Log.d("APMEventHandle", "onFrameCharingEnd error: need invoke onFrameChasingStart first");
+                return;
+            }
+            jSONObject.put("Name", "frameChasingEnd");
+            long currentTimeMillis = System.currentTimeMillis();
+            jSONObject.put("StartTime", currentTimeMillis);
+            jSONObject.put("Duration", currentTimeMillis - this.f);
+            this.f = 0L;
+            d(jSONObject);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void d(String str) {
+        this.c.b(str);
+    }
+
+    public void e() {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "bufferingStart");
+            this.d = System.currentTimeMillis();
+            jSONObject.put("StartTime", this.d);
+            JSONObject jSONObject2 = new JSONObject();
+            jSONObject2.put("isFrameChasing", this.e);
+            jSONObject.put("EventData", jSONObject2);
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onBufferingStart " + e.getMessage());
+        }
+    }
+
+    void e(String str) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("crashInfo", str);
+            a("crash", jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onPlayerCrash " + e.getMessage());
+        }
+    }
+
+    public void f() {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            if (this.d <= 0) {
+                Log.d("APMEventHandle", "onBufferingEnd error: need invoke onBufferingStart first");
+                return;
+            }
+            jSONObject.put("Name", "bufferingEnd");
+            long currentTimeMillis = System.currentTimeMillis();
+            jSONObject.put("StartTime", currentTimeMillis);
+            jSONObject.put("Duration", currentTimeMillis - this.d);
+            this.d = 0L;
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onBufferingEnd " + e.getMessage());
+        }
+    }
+
+    public void g() {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            jSONObject.put("Name", "keepPlaying");
+            jSONObject.put("StartTime", System.currentTimeMillis());
+            d(jSONObject);
+        } catch (Exception e) {
+            Log.d("APMEventHandle", "onPlayCount " + e.getMessage());
+        }
+    }
+}

sources/com/baidu/cloud/media/player/a/c.java

@@ -0,0 +1,31 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.util.Log;
+
+/* loaded from: classes.dex */
+class c {
+    private String a;
+    private String b;
+    private String c;
+    private String d;
+
+    public c(Context context) {
+        a(context);
+    }
+
+    private void a(Context context) {
+        try {
+            this.b = context.getPackageName();
+            PackageManager packageManager = context.getPackageManager();
+            PackageInfo packageInfo = packageManager.getPackageInfo(this.b, 0);
+            this.d = packageInfo.versionName;
+            this.c = "" + packageInfo.versionCode;
+            this.a = (String) packageManager.getApplicationLabel(packageInfo.applicationInfo);
+        } catch (Exception e) {
+            Log.d("BaseInfo", "" + e.getMessage());
+        }
+    }
+}

sources/com/baidu/cloud/media/player/a/d.java

@@ -0,0 +1,51 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.util.Log;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.Thread;
+
+/* loaded from: classes.dex */
+class d implements Thread.UncaughtExceptionHandler {
+    private static d a = new d();
+    private Thread.UncaughtExceptionHandler b = null;
+    private Context c = null;
+
+    private d() {
+    }
+
+    public static d a() {
+        return a;
+    }
+
+    public void a(Context context) {
+        if (this.b == null) {
+            this.b = Thread.getDefaultUncaughtExceptionHandler();
+            Thread.setDefaultUncaughtExceptionHandler(this);
+        }
+        if (this.c == null) {
+            this.c = context.getApplicationContext();
+        }
+    }
+
+    @Override // java.lang.Thread.UncaughtExceptionHandler
+    public void uncaughtException(Thread thread, Throwable th) {
+        try {
+            StringWriter stringWriter = new StringWriter();
+            PrintWriter printWriter = new PrintWriter(stringWriter);
+            th.printStackTrace(printWriter);
+            printWriter.close();
+            String obj = stringWriter.toString();
+            if (obj.contains("com.baidu.cloud.media")) {
+                b.a(this.c).e(obj);
+            }
+        } catch (Exception e) {
+            Log.d("SDKCrashHandler", "" + e.getMessage());
+        }
+        if (this.b.equals(this)) {
+            return;
+        }
+        this.b.uncaughtException(thread, th);
+    }
+}

sources/com/baidu/cloud/media/player/a/e.java

@@ -0,0 +1,65 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.os.Build;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.WindowManager;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+class e {
+    private String b;
+    private int c;
+    private String d;
+    private String e;
+    private String f;
+    private int g;
+    private int h;
+    private String i;
+    private String j;
+    private String k;
+    private String l;
+    private String a = "android";
+    private String m = "";
+
+    public e(Context context, String str) {
+        a(context, str);
+    }
+
+    private void a(Context context, String str) {
+        int i;
+        try {
+            this.b = Build.VERSION.RELEASE;
+            this.c = Build.VERSION.SDK_INT;
+            this.d = Build.MODEL;
+            this.e = Build.BRAND;
+            this.f = Build.CPU_ABI;
+            this.i = Locale.getDefault().getLanguage();
+            this.l = Settings.Secure.getString(context.getContentResolver(), "android_id");
+            this.j = this.l;
+            DisplayMetrics displayMetrics = new DisplayMetrics();
+            if (Build.VERSION.SDK_INT >= 17) {
+                ((WindowManager) context.getSystemService("window")).getDefaultDisplay().getRealMetrics(displayMetrics);
+            } else {
+                ((WindowManager) context.getSystemService("window")).getDefaultDisplay().getMetrics(displayMetrics);
+            }
+            if (displayMetrics.widthPixels > displayMetrics.heightPixels) {
+                this.g = displayMetrics.heightPixels;
+                i = displayMetrics.widthPixels;
+            } else {
+                this.g = displayMetrics.widthPixels;
+                i = displayMetrics.heightPixels;
+            }
+            this.h = i;
+            if (context.checkCallingOrSelfPermission("android.permission.READ_PHONE_STATE") != -1) {
+                this.k = ((TelephonyManager) context.getSystemService("phone")).getDeviceId();
+            }
+            this.m = str;
+        } catch (Exception e) {
+            Log.d("BaseInfo", "" + e.getMessage());
+        }
+    }
+}

sources/com/baidu/cloud/media/player/a/f.java

@@ -0,0 +1,75 @@
+package com.baidu.cloud.media.player.a;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+/* loaded from: classes.dex */
+class f {
+    private String a;
+    private String b;
+    private String c;
+
+    public f(Context context) {
+        b(context);
+    }
+
+    private void b(Context context) {
+        try {
+            this.c = a(context);
+            this.a = ((TelephonyManager) context.getSystemService("phone")).getNetworkOperator();
+            this.b = ((TelephonyManager) context.getSystemService("phone")).getNetworkOperatorName();
+        } catch (Exception e) {
+            Log.d("BaseInfo", "" + e.getMessage());
+        }
+    }
+
+    public String a(Context context) {
+        NetworkInfo activeNetworkInfo;
+        NetworkInfo.State state;
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
+        if (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isAvailable()) {
+            return "NONE";
+        }
+        NetworkInfo networkInfo = connectivityManager.getNetworkInfo(1);
+        if (networkInfo != null && (state = networkInfo.getState()) != null && (state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING)) {
+            return "WIFI";
+        }
+        NetworkInfo networkInfo2 = connectivityManager.getNetworkInfo(0);
+        if (networkInfo2 == null) {
+            return "";
+        }
+        NetworkInfo.State state2 = networkInfo2.getState();
+        networkInfo2.getSubtypeName();
+        if (state2 == null) {
+            return "";
+        }
+        if (state2 != NetworkInfo.State.CONNECTED && state2 != NetworkInfo.State.CONNECTING) {
+            return "";
+        }
+        switch (activeNetworkInfo.getSubtype()) {
+            case 1:
+            case 2:
+            case 4:
+            case 7:
+            case 11:
+                return "2G";
+            case 3:
+            case 5:
+            case 6:
+            case 8:
+            case 9:
+            case 10:
+            case 12:
+            case 14:
+            case 15:
+                return "3G";
+            case 13:
+                return "4G";
+            default:
+                return "UNKNOWN";
+        }
+    }
+}

sources/com/baidu/cloud/media/player/annotations/AccessedByNative.java

@@ -0,0 +1,5 @@
+package com.baidu.cloud.media.player.annotations;
+
+/* loaded from: classes.dex */
+public @interface AccessedByNative {
+}

sources/com/baidu/cloud/media/player/annotations/CalledByNative.java

@@ -0,0 +1,6 @@
+package com.baidu.cloud.media.player.annotations;
+
+/* loaded from: classes.dex */
+public @interface CalledByNative {
+    String value();
+}

sources/com/baidu/cloud/media/player/b.java

@@ -0,0 +1,193 @@
+package com.baidu.cloud.media.player;
+
+import android.os.Bundle;
+import android.text.TextUtils;
+import com.baidu.cloud.media.player.misc.IMediaFormat;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+public class b {
+    public Bundle a;
+    public String b;
+    public long c;
+    public long d;
+    public long e;
+    public final ArrayList<a> f = new ArrayList<>();
+    public a g;
+    public a h;
+
+    public static class a {
+        public Bundle a;
+        public final int b;
+        public String c;
+        public String d;
+        public String e;
+        public String f;
+        public String g;
+        public long h;
+        public int i;
+        public int j;
+        public int k;
+        public int l;
+        public int m;
+        public int n;
+        public int o;
+        public int p;
+        public int q;
+        public long r;
+
+        public a(int i) {
+            this.b = i;
+        }
+
+        public int a(String str, int i) {
+            String a = a(str);
+            if (TextUtils.isEmpty(a)) {
+                return i;
+            }
+            try {
+                return Integer.parseInt(a);
+            } catch (NumberFormatException unused) {
+                return i;
+            }
+        }
+
+        public long a(String str, long j) {
+            String a = a(str);
+            if (TextUtils.isEmpty(a)) {
+                return j;
+            }
+            try {
+                return Long.parseLong(a);
+            } catch (NumberFormatException unused) {
+                return j;
+            }
+        }
+
+        public String a() {
+            return !TextUtils.isEmpty(this.e) ? this.e : "N/A";
+        }
+
+        public String a(String str) {
+            return this.a.getString(str);
+        }
+
+        public int b(String str) {
+            return a(str, 0);
+        }
+
+        public String b() {
+            int i = this.i;
+            return (i <= 0 || this.j <= 0) ? "N/A" : (this.o <= 0 || this.p <= 0) ? String.format(Locale.US, "%d x %d", Integer.valueOf(this.i), Integer.valueOf(this.j)) : String.format(Locale.US, "%d x %d [SAR %d:%d]", Integer.valueOf(i), Integer.valueOf(this.j), Integer.valueOf(this.o), Integer.valueOf(this.p));
+        }
+
+        public long c(String str) {
+            return a(str, 0L);
+        }
+
+        public String c() {
+            long j = this.h;
+            return j <= 0 ? "N/A" : j < 1000 ? String.format(Locale.US, "%d bit/s", Long.valueOf(j)) : String.format(Locale.US, "%d kb/s", Long.valueOf(j / 1000));
+        }
+
+        public String d() {
+            int i = this.q;
+            return i <= 0 ? "N/A" : String.format(Locale.US, "%d Hz", Integer.valueOf(i));
+        }
+    }
+
+    public static b a(Bundle bundle) {
+        if (bundle == null) {
+            return null;
+        }
+        b bVar = new b();
+        bVar.a = bundle;
+        bVar.b = bVar.a("format");
+        bVar.c = bVar.b("duration_us");
+        bVar.d = bVar.b("start_us");
+        bVar.e = bVar.b("bitrate");
+        int i = -1;
+        int a2 = bVar.a("video", -1);
+        int a3 = bVar.a("audio", -1);
+        ArrayList<Bundle> c = bVar.c("streams");
+        if (c == null) {
+            return bVar;
+        }
+        Iterator<Bundle> it = c.iterator();
+        while (it.hasNext()) {
+            Bundle next = it.next();
+            i++;
+            if (next != null) {
+                a aVar = new a(i);
+                aVar.a = next;
+                aVar.c = aVar.a("type");
+                aVar.d = aVar.a("language");
+                if (!TextUtils.isEmpty(aVar.c)) {
+                    aVar.e = aVar.a("codec_name");
+                    aVar.f = aVar.a("codec_profile");
+                    aVar.g = aVar.a("codec_long_name");
+                    aVar.h = aVar.b("bitrate");
+                    if (aVar.c.equalsIgnoreCase("video")) {
+                        aVar.i = aVar.b(IMediaFormat.KEY_WIDTH);
+                        aVar.j = aVar.b(IMediaFormat.KEY_HEIGHT);
+                        aVar.k = aVar.b("fps_num");
+                        aVar.l = aVar.b("fps_den");
+                        aVar.m = aVar.b("tbr_num");
+                        aVar.n = aVar.b("tbr_den");
+                        aVar.o = aVar.b("sar_num");
+                        aVar.p = aVar.b("sar_den");
+                        if (a2 == i) {
+                            bVar.g = aVar;
+                        }
+                    } else if (aVar.c.equalsIgnoreCase("audio")) {
+                        aVar.q = aVar.b("sample_rate");
+                        aVar.r = aVar.c("channel_layout");
+                        if (a3 == i) {
+                            bVar.h = aVar;
+                        }
+                    }
+                    bVar.f.add(aVar);
+                }
+            }
+        }
+        return bVar;
+    }
+
+    public int a(String str, int i) {
+        String a2 = a(str);
+        if (TextUtils.isEmpty(a2)) {
+            return i;
+        }
+        try {
+            return Integer.parseInt(a2);
+        } catch (NumberFormatException unused) {
+            return i;
+        }
+    }
+
+    public long a(String str, long j) {
+        String a2 = a(str);
+        if (TextUtils.isEmpty(a2)) {
+            return j;
+        }
+        try {
+            return Long.parseLong(a2);
+        } catch (NumberFormatException unused) {
+            return j;
+        }
+    }
+
+    public String a(String str) {
+        return this.a.getString(str);
+    }
+
+    public long b(String str) {
+        return a(str, 0L);
+    }
+
+    public ArrayList<Bundle> c(String str) {
+        return this.a.getParcelableArrayList(str);
+    }
+}

sources/com/baidu/cloud/media/player/b/a.java

@@ -0,0 +1,57 @@
+package com.baidu.cloud.media.player.b;
+
+import android.util.Log;
+import java.util.Locale;
+
+/* loaded from: classes.dex */
+public class a {
+    public static boolean a = true;
+    public static boolean b = false;
+    public static boolean c = true;
+    public static boolean d = false;
+    public static boolean e = false;
+
+    public static void a(String str, String str2) {
+        if (a) {
+            Log.e(str, str2);
+        }
+    }
+
+    public static void a(String str, String str2, Object... objArr) {
+        if (b) {
+            Log.i(str, String.format(Locale.US, str2, objArr));
+        }
+    }
+
+    public static void a(boolean z) {
+        a = true;
+        c = true;
+        if (z) {
+            b = true;
+            d = true;
+            e = true;
+        } else {
+            b = false;
+            d = false;
+            e = false;
+        }
+    }
+
+    public static void b(String str, String str2) {
+        if (b) {
+            Log.i(str, str2);
+        }
+    }
+
+    public static void c(String str, String str2) {
+        if (c) {
+            Log.w(str, str2);
+        }
+    }
+
+    public static void d(String str, String str2) {
+        if (d) {
+            Log.d(str, str2);
+        }
+    }
+}

sources/com/baidu/cloud/media/player/c.java

@@ -0,0 +1,11 @@
+package com.baidu.cloud.media.player;
+
+/* loaded from: classes.dex */
+public class c {
+    public String a;
+    public String b;
+    public String c;
+    public String d;
+    public String e;
+    public b f;
+}

sources/com/baidu/cloud/media/player/ffmpeg/FFmpegApi.java

@@ -0,0 +1,6 @@
+package com.baidu.cloud.media.player.ffmpeg;
+
+/* loaded from: classes.dex */
+public class FFmpegApi {
+    public static native String av_base64_encode(byte[] bArr);
+}

sources/com/baidu/cloud/media/player/misc/AndroidMediaFormat.java

@@ -0,0 +1,41 @@
+package com.baidu.cloud.media.player.misc;
+
+import android.media.MediaFormat;
+import com.ubtrobot.jimu.robotapi.PeripheralType;
+
+/* loaded from: classes.dex */
+public class AndroidMediaFormat implements IMediaFormat {
+    private final MediaFormat a;
+
+    public AndroidMediaFormat(MediaFormat mediaFormat) {
+        this.a = mediaFormat;
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.IMediaFormat
+    public int getInteger(String str) {
+        MediaFormat mediaFormat = this.a;
+        if (mediaFormat == null) {
+            return 0;
+        }
+        return mediaFormat.getInteger(str);
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.IMediaFormat
+    public String getString(String str) {
+        MediaFormat mediaFormat = this.a;
+        if (mediaFormat == null) {
+            return null;
+        }
+        return mediaFormat.getString(str);
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder(PeripheralType.SERVO);
+        sb.append(AndroidMediaFormat.class.getName());
+        sb.append('{');
+        MediaFormat mediaFormat = this.a;
+        sb.append(mediaFormat != null ? mediaFormat.toString() : "null");
+        sb.append('}');
+        return sb.toString();
+    }
+}

sources/com/baidu/cloud/media/player/misc/BDCloudMediaFormat.java

@@ -0,0 +1,199 @@
+package com.baidu.cloud.media.player.misc;
+
+import android.text.TextUtils;
+import com.baidu.cloud.media.player.b;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class BDCloudMediaFormat implements IMediaFormat {
+    public static final String CODEC_NAME_H264 = "h264";
+    public static final String KEY_IJK_BIT_RATE_UI = "ijk-bit-rate-ui";
+    public static final String KEY_IJK_CHANNEL_UI = "ijk-channel-ui";
+    public static final String KEY_IJK_CODEC_LONG_NAME_UI = "ijk-codec-long-name-ui";
+    public static final String KEY_IJK_CODEC_NAME_UI = "ijk-codec-name-ui";
+    public static final String KEY_IJK_CODEC_PIXEL_FORMAT_UI = "ijk-pixel-format-ui";
+    public static final String KEY_IJK_CODEC_PROFILE_LEVEL_UI = "ijk-profile-level-ui";
+    public static final String KEY_IJK_FRAME_RATE_UI = "ijk-frame-rate-ui";
+    public static final String KEY_IJK_RESOLUTION_UI = "ijk-resolution-ui";
+    public static final String KEY_IJK_SAMPLE_RATE_UI = "ijk-sample-rate-ui";
+    private static final Map<String, a> b = new HashMap();
+    public final b.a a;
+
+    private static abstract class a {
+        private a() {
+        }
+
+        protected String a() {
+            return "N/A";
+        }
+
+        protected abstract String a(BDCloudMediaFormat bDCloudMediaFormat);
+
+        public String b(BDCloudMediaFormat bDCloudMediaFormat) {
+            String a = a(bDCloudMediaFormat);
+            return TextUtils.isEmpty(a) ? a() : a;
+        }
+    }
+
+    public BDCloudMediaFormat(b.a aVar) {
+        b.put(KEY_IJK_CODEC_LONG_NAME_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.1
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            public String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                return BDCloudMediaFormat.this.a.a("codec_long_name");
+            }
+        });
+        b.put(KEY_IJK_CODEC_NAME_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.2
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            public String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                return BDCloudMediaFormat.this.a.a("codec_name");
+            }
+        });
+        b.put(KEY_IJK_BIT_RATE_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.3
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                int integer = bDCloudMediaFormat.getInteger("bitrate");
+                if (integer <= 0) {
+                    return null;
+                }
+                return integer < 1000 ? String.format(Locale.US, "%d bit/s", Integer.valueOf(integer)) : String.format(Locale.US, "%d kb/s", Integer.valueOf(integer / 1000));
+            }
+        });
+        b.put(KEY_IJK_CODEC_PROFILE_LEVEL_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.4
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                String str;
+                switch (bDCloudMediaFormat.getInteger("codec_profile_id")) {
+                    case 44:
+                        str = "CAVLC 4:4:4";
+                        break;
+                    case 66:
+                        str = "Baseline";
+                        break;
+                    case 77:
+                        str = "Main";
+                        break;
+                    case 88:
+                        str = "Extended";
+                        break;
+                    case 100:
+                        str = "High";
+                        break;
+                    case 110:
+                        str = "High 10";
+                        break;
+                    case 122:
+                        str = "High 4:2:2";
+                        break;
+                    case 144:
+                        str = "High 4:4:4";
+                        break;
+                    case 244:
+                        str = "High 4:4:4 Predictive";
+                        break;
+                    case 578:
+                        str = "Constrained Baseline";
+                        break;
+                    case 2158:
+                        str = "High 10 Intra";
+                        break;
+                    case 2170:
+                        str = "High 4:2:2 Intra";
+                        break;
+                    case 2292:
+                        str = "High 4:4:4 Intra";
+                        break;
+                    default:
+                        return null;
+                }
+                StringBuilder sb = new StringBuilder();
+                sb.append(str);
+                String string = bDCloudMediaFormat.getString("codec_name");
+                if (!TextUtils.isEmpty(string) && string.equalsIgnoreCase(BDCloudMediaFormat.CODEC_NAME_H264)) {
+                    int integer = bDCloudMediaFormat.getInteger("codec_level");
+                    if (integer < 10) {
+                        return sb.toString();
+                    }
+                    sb.append(" Profile Level ");
+                    sb.append((integer / 10) % 10);
+                    int i = integer % 10;
+                    if (i != 0) {
+                        sb.append(".");
+                        sb.append(i);
+                    }
+                }
+                return sb.toString();
+            }
+        });
+        b.put(KEY_IJK_CODEC_PIXEL_FORMAT_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.5
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                return bDCloudMediaFormat.getString("codec_pixel_format");
+            }
+        });
+        b.put(KEY_IJK_RESOLUTION_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.6
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                int integer = bDCloudMediaFormat.getInteger(IMediaFormat.KEY_WIDTH);
+                int integer2 = bDCloudMediaFormat.getInteger(IMediaFormat.KEY_HEIGHT);
+                int integer3 = bDCloudMediaFormat.getInteger("sar_num");
+                int integer4 = bDCloudMediaFormat.getInteger("sar_den");
+                if (integer <= 0 || integer2 <= 0) {
+                    return null;
+                }
+                return (integer3 <= 0 || integer4 <= 0) ? String.format(Locale.US, "%d x %d", Integer.valueOf(integer), Integer.valueOf(integer2)) : String.format(Locale.US, "%d x %d [SAR %d:%d]", Integer.valueOf(integer), Integer.valueOf(integer2), Integer.valueOf(integer3), Integer.valueOf(integer4));
+            }
+        });
+        b.put(KEY_IJK_FRAME_RATE_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.7
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                int integer = bDCloudMediaFormat.getInteger("fps_num");
+                int integer2 = bDCloudMediaFormat.getInteger("fps_den");
+                if (integer <= 0 || integer2 <= 0) {
+                    return null;
+                }
+                return String.valueOf(integer / integer2);
+            }
+        });
+        b.put(KEY_IJK_SAMPLE_RATE_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.8
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                int integer = bDCloudMediaFormat.getInteger("sample_rate");
+                if (integer <= 0) {
+                    return null;
+                }
+                return String.format(Locale.US, "%d Hz", Integer.valueOf(integer));
+            }
+        });
+        b.put(KEY_IJK_CHANNEL_UI, new a() { // from class: com.baidu.cloud.media.player.misc.BDCloudMediaFormat.9
+            @Override // com.baidu.cloud.media.player.misc.BDCloudMediaFormat.a
+            protected String a(BDCloudMediaFormat bDCloudMediaFormat) {
+                int integer = bDCloudMediaFormat.getInteger("channel_layout");
+                if (integer <= 0) {
+                    return null;
+                }
+                long j = integer;
+                return j == 4 ? "mono" : j == 3 ? "stereo" : String.format(Locale.US, "%x", Integer.valueOf(integer));
+            }
+        });
+        this.a = aVar;
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.IMediaFormat
+    public int getInteger(String str) {
+        b.a aVar = this.a;
+        if (aVar == null) {
+            return 0;
+        }
+        return aVar.b(str);
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.IMediaFormat
+    public String getString(String str) {
+        if (this.a == null) {
+            return null;
+        }
+        return b.containsKey(str) ? b.get(str).b(this) : this.a.a(str);
+    }
+}

sources/com/baidu/cloud/media/player/misc/IAndroidIO.java

@@ -0,0 +1,14 @@
+package com.baidu.cloud.media.player.misc;
+
+import java.io.IOException;
+
+/* loaded from: classes.dex */
+public interface IAndroidIO {
+    int close() throws IOException;
+
+    int open(String str) throws IOException;
+
+    int read(byte[] bArr, int i) throws IOException;
+
+    long seek(long j, int i) throws IOException;
+}

sources/com/baidu/cloud/media/player/misc/IMediaDataSource.java

@@ -0,0 +1,12 @@
+package com.baidu.cloud.media.player.misc;
+
+import java.io.IOException;
+
+/* loaded from: classes.dex */
+public interface IMediaDataSource {
+    void close() throws IOException;
+
+    long getSize() throws IOException;
+
+    int readAt(long j, byte[] bArr, int i, int i2) throws IOException;
+}

sources/com/baidu/cloud/media/player/misc/IMediaFormat.java

@@ -0,0 +1,12 @@
+package com.baidu.cloud.media.player.misc;
+
+/* loaded from: classes.dex */
+public interface IMediaFormat {
+    public static final String KEY_HEIGHT = "height";
+    public static final String KEY_MIME = "mime";
+    public static final String KEY_WIDTH = "width";
+
+    int getInteger(String str);
+
+    String getString(String str);
+}

sources/com/baidu/cloud/media/player/misc/ITrackInfo.java

@@ -0,0 +1,19 @@
+package com.baidu.cloud.media.player.misc;
+
+/* loaded from: classes.dex */
+public interface ITrackInfo {
+    public static final int MEDIA_TRACK_TYPE_AUDIO = 2;
+    public static final int MEDIA_TRACK_TYPE_METADATA = 5;
+    public static final int MEDIA_TRACK_TYPE_SUBTITLE = 4;
+    public static final int MEDIA_TRACK_TYPE_TIMEDTEXT = 3;
+    public static final int MEDIA_TRACK_TYPE_UNKNOWN = 0;
+    public static final int MEDIA_TRACK_TYPE_VIDEO = 1;
+
+    IMediaFormat getFormat();
+
+    String getInfoInline();
+
+    String getLanguage();
+
+    int getTrackType();
+}

sources/com/baidu/cloud/media/player/misc/a.java

@@ -0,0 +1,67 @@
+package com.baidu.cloud.media.player.misc;
+
+import android.text.TextUtils;
+import com.baidu.cloud.media.player.b;
+import com.ubtrobot.jimu.robotapi.PeripheralType;
+
+/* loaded from: classes.dex */
+public class a implements ITrackInfo {
+    private int a = 0;
+    private b.a b;
+
+    public a(b.a aVar) {
+        this.b = aVar;
+    }
+
+    public void a(int i) {
+        this.a = i;
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.ITrackInfo
+    public IMediaFormat getFormat() {
+        return new BDCloudMediaFormat(this.b);
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.ITrackInfo
+    public String getInfoInline() {
+        String b;
+        StringBuilder sb = new StringBuilder(PeripheralType.SERVO);
+        int i = this.a;
+        if (i == 1) {
+            sb.append("VIDEO");
+            sb.append(", ");
+            sb.append(this.b.a());
+            sb.append(", ");
+            sb.append(this.b.c());
+            sb.append(", ");
+            b = this.b.b();
+        } else if (i != 2) {
+            b = i != 3 ? i != 4 ? "UNKNOWN" : "SUBTITLE" : "TIMEDTEXT";
+        } else {
+            sb.append("AUDIO");
+            sb.append(", ");
+            sb.append(this.b.a());
+            sb.append(", ");
+            sb.append(this.b.c());
+            sb.append(", ");
+            b = this.b.d();
+        }
+        sb.append(b);
+        return sb.toString();
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.ITrackInfo
+    public String getLanguage() {
+        b.a aVar = this.b;
+        return (aVar == null || TextUtils.isEmpty(aVar.d)) ? "und" : this.b.d;
+    }
+
+    @Override // com.baidu.cloud.media.player.misc.ITrackInfo
+    public int getTrackType() {
+        return this.a;
+    }
+
+    public String toString() {
+        return a.class.getSimpleName() + '{' + getInfoInline() + "}";
+    }
+}