package com.seewo.sdk;

import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.os.Build;
import android.os.IBinder;
import android.os.SystemProperties;
import android.util.DisplayMetrics;
import android.util.Log;
import com.droidlogic.app.ScreenControlManager;
import com.seewo.sdk.interfaces.Callback;
import com.seewo.sdk.interfaces.ISDKMediaHelper;
import com.seewo.sdk.internal.command.media.CmdMedia;
import com.seewo.sdk.internal.command.media.RespGetScreenRecordConfig;
import com.seewo.sdk.internal.command.media.SDKMediaType;
import com.seewo.sdk.internal.model.ResponseCallback;
import com.seewo.sdk.internal.model.SDKResponse;
import com.seewo.sdk.model.SDKScreenRecordConfig;
import com.seewo.sdk.util.BoardTypeUtils;
import com.seewo.sdk.util.ConfigUtils;
import com.seewo.sdk.util.ParseUtil;
import com.seewo.sdk.util.PlatformUtils;
import com.seewo.sdk.util.RLog;
import com.seewo.sdk.virtualdisplay.SDKVirtualDisplay;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/* JADX INFO: loaded from: classes.dex */
public class SDKMediaHelper implements ISDKMediaHelper {
    public static final SDKMediaHelper I = new SDKMediaHelper();
    private static final String PACKAGE_HISI_GALLERY = "com.hisilicon.higallery";
    private static final String PACKAGE_TV_SETTING = "com.cvte.tv.setting";
    private static final String SYSTEM_PROPERTY_GALLERY_TYPE = "persist.sys.mark_type";
    private static final String SYSTEM_PROPERTY_SHOT_TYPE = "persist.sys.shot_type";
    private static final String TAG = "ScreenShotApi";
    private static final int VALUE_GALLERY_SHOT_OFF = 0;
    private static final int VALUE_GALLERY_SHOT_ON = 1;
    private static final int VALUE_SHOT_TYPE_VIDEO_AND_OSD = 2;
    private static final int VALUE_SHOT_TYPE_VIDEO_ONLY = 0;
    private Context mContext;

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public Bitmap screenShot(Context context) {
        if (this.mContext == null) {
            this.mContext = context.getApplicationContext();
        }
        return screenShot(2);
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveScreenShotEncrypt(String str, final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SNAPSHOT_ENCRYPT_WITH_PATH, str), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.1
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveScreenShotEncrypt(final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SNAPSHOT_ENCRYPT), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.2
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveScreenShot(String str, final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SNAPSHOT_WITH_PATH, str), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.3
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveScreenShot(final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SNAPSHOT), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.4
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public Bitmap sourceShot(Context context) {
        if (this.mContext == null) {
            this.mContext = context.getApplicationContext();
        }
        if (isInAndroid(context)) {
            return screenShot(2);
        }
        return screenShot(0);
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveSourceShot(String str, final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SOURCE_SHOT_WITH_PATH, str), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.5
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public void saveSourceShot(final Callback<String> callback) {
        OpenSDK.getInstance().postCommand(CmdMedia.obtain(SDKMediaType.SAVE_SOURCE_SHOT), new ResponseCallback() { // from class: com.seewo.sdk.SDKMediaHelper.6
            @Override // com.seewo.sdk.internal.model.ResponseCallback
            public void onCall(SDKResponse sDKResponse) {
                Callback callback2 = callback;
                if (callback2 != null) {
                    callback2.call(ParseUtil.decodeStringResponse(sDKResponse));
                }
            }
        });
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean startScreenRecord(String str) {
        return startScreenRecord(str, true, true);
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean startScreenRecord(String str, boolean z, boolean z2) {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.START_SCREEN_RECORD, new SDKScreenRecordConfig(str, z, z2))));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean startScreenRecordWithAllParams(SDKScreenRecordConfig sDKScreenRecordConfig) {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.START_SCREEN_RECORD_WITH_ALL_PARAMS, sDKScreenRecordConfig)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean pauseScreenRecord() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.PAUSE_SCREEN_RECORD)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean resumeScreenRecord() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.RESUME_SCREEN_RECORD)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean stopScreenRecord() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.STOP_SCREEN_RECORD)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean isScreenRecording() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.IS_SCREEN_RECORDING)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean isScreenRecordPausing() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.IS_SCREEN_RECORD_PAUSING)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public int[] getRecordResolutionOptions() {
        return ParseUtil.decodeIntArrayResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.GET_SCREEN_RECORD_RESOLUTION_OPTIONS)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public boolean obtainingScreenData() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.IS_OBTAINING_SCREEN_DATA)));
    }

    @Override // com.seewo.sdk.interfaces.ISDKMediaHelper
    public SDKScreenRecordConfig getScreenRecordConfig() {
        return ((RespGetScreenRecordConfig) ParseUtil.decodeJSON(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.GET_SCREEN_RECORD_CONFIG)), RespGetScreenRecordConfig.class)).getConfig();
    }

    private synchronized Bitmap screenShot(int i) {
        Bitmap bitmapInvokeScreenshotSDK28;
        if (ConfigUtils.getScreenshotMethod() != ConfigUtils.ScreenshotMethod.CUSTOM) {
            InternalScreenShotHelper internalScreenShotHelper = new InternalScreenShotHelper();
            RLog.i(TAG, "screenshot method select screenShot:Native ");
            return internalScreenShotHelper.screenShot(this.mContext);
        }
        if (ConfigUtils.isCaptureFromVds()) {
            RLog.i(TAG, "isCaptureFromVds select screenShot:SDKVirtualDisplay ");
            return SDKVirtualDisplay.getInstance().screenShot(this.mContext);
        }
        if (!PlatformUtils.isMLGChip() && !BoardTypeUtils.is972Machine() && !BoardTypeUtils.is982Machine()) {
            if (Build.VERSION.SDK_INT > 32) {
                RLog.i(TAG, "sdk > 32,screenShot:SDKVirtualDisplay ");
                return SDKVirtualDisplay.getInstance().screenShot(this.mContext);
            }
            int i2 = SystemProperties.getInt("persist.sys.shot_type", 2);
            Log.i(TAG, "Before the screenshot, set persist.sys.shot_type to " + i + " - " + this.mContext.getPackageName());
            SystemProperties.set("persist.sys.shot_type", Integer.toString(i));
            SystemProperties.set("persist.sys.mark_type", Integer.toString(isGalleryVisible(this.mContext) ? 1 : 0));
            try {
                DisplayMetrics displayMetrics = this.mContext.getResources().getDisplayMetrics();
                if (Build.VERSION.SDK_INT == 32) {
                    bitmapInvokeScreenshotSDK28 = invokeScreenshotSDK32(displayMetrics.widthPixels, displayMetrics.heightPixels);
                } else {
                    bitmapInvokeScreenshotSDK28 = invokeScreenshotSDK28(displayMetrics.widthPixels, displayMetrics.heightPixels);
                }
            } catch (Exception e) {
                Log.e(TAG, "Screen shot fail!", e);
                bitmapInvokeScreenshotSDK28 = null;
            }
            if (i != i2) {
                Log.i(TAG, "After the screenshot, set persist.sys.shot_type to " + i2 + " - " + this.mContext.getPackageName());
                SystemProperties.set("persist.sys.shot_type", Integer.toString(i2));
            }
            if (SystemProperties.getInt("persist.sys.mark_type", 0) != 0) {
                SystemProperties.set("persist.sys.mark_type", Integer.toString(0));
            }
            return bitmapInvokeScreenshotSDK28;
        }
        RLog.i(TAG, "screenShot:for972 ");
        int[] iArr = new int[2];
        ScreenControlManager.getScreenInfo(this.mContext, iArr);
        return ScreenControlManager.captureAmlogic(this.mContext, iArr[0], iArr[1], i);
    }

    public static Bitmap invokeScreenshotSDK32(int i, int i2) {
        Log.i(TAG, "invokeScreenshotSDK32: " + i + "x" + i2);
        try {
            Class<?> cls = Class.forName("android.view.SurfaceControl");
            Object objNewDisplayCaptureArgs = newDisplayCaptureArgs((IBinder) cls.getDeclaredMethod("getInternalDisplayToken", new Class[0]).invoke(null, new Object[0]), i, i2);
            Object objInvoke = cls.getDeclaredMethod("captureDisplay", objNewDisplayCaptureArgs.getClass()).invoke(null, objNewDisplayCaptureArgs);
            if (objInvoke != null) {
                return (Bitmap) objInvoke.getClass().getDeclaredMethod("asBitmap", new Class[0]).invoke(objInvoke, new Object[0]);
            }
        } catch (Throwable th) {
            Log.e(TAG, "invokeScreenshotSDK32 error!", th);
        }
        return null;
    }

    private static Object newDisplayCaptureArgs(IBinder iBinder, int i, int i2) throws Throwable {
        Class<?> cls = Class.forName("android.view.SurfaceControl$DisplayCaptureArgs$Builder");
        Constructor<?> constructor = cls.getConstructor(IBinder.class);
        Method declaredMethod = cls.getDeclaredMethod("setSize", Integer.TYPE, Integer.TYPE);
        Object objNewInstance = constructor.newInstance(iBinder);
        declaredMethod.invoke(objNewInstance, Integer.valueOf(i), Integer.valueOf(i2));
        return cls.getDeclaredMethod("build", new Class[0]).invoke(objNewInstance, new Object[0]);
    }

    private Bitmap invokeScreenshotSDK28(int i, int i2) {
        Log.i(TAG, "invokeScreenshotSDK28: ");
        try {
            return (Bitmap) Class.forName("android.view.SurfaceControl").getDeclaredMethod("screenshot", Rect.class, Integer.TYPE, Integer.TYPE, Integer.TYPE).invoke(null, new Rect(0, 0, 0, 0), Integer.valueOf(i), Integer.valueOf(i2), 0);
        } catch (Exception e) {
            Log.e(TAG, "screenshot error!", e);
            return null;
        }
    }

    private Bitmap invokeScreenshot(int i, int i2) {
        try {
            return (Bitmap) Class.forName("android.view.SurfaceControl").getMethod("screenshot", Integer.TYPE, Integer.TYPE).invoke(null, Integer.valueOf(i), Integer.valueOf(i2));
        } catch (Exception e) {
            Log.e(TAG, "screenshot error!", e);
            return null;
        }
    }

    private boolean isInAndroid(Context context) {
        return !isPackageVisible(context, "com.cvte.tv.setting");
    }

    private boolean isGalleryVisible(Context context) {
        return isPackageVisible(context, PACKAGE_HISI_GALLERY);
    }

    private boolean isPackageVisible(Context context, String str) {
        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses()) {
            if (runningAppProcessInfo.importance == 200 || runningAppProcessInfo.importance == 100) {
                if (str.equals(runningAppProcessInfo.processName)) {
                    return true;
                }
            }
        }
        return false;
    }
}