package com.seewo.sdk;

import android.annotation.SuppressLint;
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;

    private Bitmap invokeScreenshot(int i2, int i3) {
        try {
            Class<?> cls = Class.forName("android.view.SurfaceControl");
            Class<?> cls2 = Integer.TYPE;
            return (Bitmap) cls.getMethod("screenshot", cls2, cls2).invoke(null, Integer.valueOf(i2), Integer.valueOf(i3));
        } catch (Exception e2) {
            Log.e(TAG, "screenshot error!", e2);
            return null;
        }
    }

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

    @SuppressLint({"BlockedPrivateApi"})
    public static Bitmap invokeScreenshotSDK32(int i2, int i3) {
        Log.i(TAG, "invokeScreenshotSDK32: " + i2 + "x" + i3);
        try {
            Class<?> cls = Class.forName("android.view.SurfaceControl");
            Object objNewDisplayCaptureArgs = newDisplayCaptureArgs((IBinder) cls.getDeclaredMethod("getInternalDisplayToken", new Class[0]).invoke(null, new Object[0]), i2, i3);
            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 boolean isGalleryVisible(Context context) {
        return isPackageVisible(context, PACKAGE_HISI_GALLERY);
    }

    private boolean isInAndroid(Context context) {
        return !isPackageVisible(context, PACKAGE_TV_SETTING);
    }

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

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

    @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 SDKScreenRecordConfig getScreenRecordConfig() {
        return ((RespGetScreenRecordConfig) ParseUtil.decodeJSON(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.GET_SCREEN_RECORD_CONFIG)), RespGetScreenRecordConfig.class)).getConfig();
    }

    @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 boolean isScreenRecording() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.IS_SCREEN_RECORDING)));
    }

    @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 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 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 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 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 Bitmap screenShot(Context context) {
        if (this.mContext == null) {
            this.mContext = context.getApplicationContext();
        }
        return screenShot(2);
    }

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

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

    @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 stopScreenRecord() {
        return ParseUtil.decodeBooleanResponse(OpenSDK.getInstance().sendCommand(CmdMedia.obtain(SDKMediaType.STOP_SCREEN_RECORD)));
    }

    @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))));
    }

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

    @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 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 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));
                }
            }
        });
    }
}