package com.seewo.sdk;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.hardware.display.DisplayManager;
import android.media.MediaScannerConnection;
import android.os.AsyncTask;
import android.os.Build;
import android.os.IBinder;
import android.os.SystemProperties;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.SurfaceControl;
import android.view.WindowManager;
import com.droidlogic.app.ScreenControlManager;
import com.seewo.sdk.interfaces.ISDKPictureHelper;
import com.seewo.sdk.interfaces.ISDKSnapshotHelper;
import com.seewo.sdk.interfaces.ISDKSourceHelper;
import com.seewo.sdk.model.SDKShotType;
import com.seewo.sdk.util.BoardTypeUtils;
import com.seewo.sdk.util.ConfigUtils;
import com.seewo.sdk.util.PlatformUtils;
import com.seewo.sdk.util.RLog;
import com.seewo.sdk.virtualdisplay.SDKVirtualDisplay;
import com.seewo.vcommons.constants.SeewoConstants;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;

/* JADX INFO: loaded from: classes.dex */
class InternalScreenShotHelper {
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
    private static final SimpleDateFormat DAY_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
    private static final int PICTURE_QUALITY = 100;
    private static final String SCREENSHOT_FILE_EXTENSION_JPG = ".jpg";
    private static final String SCREENSHOT_FILE_EXTENSION_PNG = ".png";
    private static final String SYSTEM_PROPERTY_SCREENSHOT_MODE = "persist.sys.screencap.mode";
    private static final String SYSTEM_PROPERTY_SHOT_TYPE = "persist.sys.shot_type";
    private static final String SYSTEM_PROPERTY_SHOT_TYPE_9950 = "vendor.sys.hwc.vss.source";
    private static final String TAG = "InternalScreenShotHelper";
    private static final String VALUE_OSD_ONLY_MTK_9950 = "1";
    private static final String VALUE_SCREENSHOT_DEFAULT = "1";
    private static final String VALUE_SCREENSHOT_UI_VIDEO = "2";
    private static final String VALUE_VIDEO_AND_OSD_MTK_9950 = "0";
    private static final String VALUE_VIDEO_ONLY_MTK_9950 = "2";
    private ScreenshotAsyncTask mCurrentTask;
    private Bitmap.CompressFormat mCompressFormat = Bitmap.CompressFormat.PNG;
    private boolean mWillGenerateDirector = true;

    InternalScreenShotHelper() {
    }

    public void setCompressFormat(Bitmap.CompressFormat compressFormat) {
        if (compressFormat == Bitmap.CompressFormat.PNG || compressFormat == Bitmap.CompressFormat.JPEG) {
            this.mCompressFormat = compressFormat;
            return;
        }
        throw new IllegalArgumentException("Compress format must PNG or JPEG");
    }

    public void setWillGenerateDirector(boolean z) {
        this.mWillGenerateDirector = z;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public String getFileExtension(Bitmap.CompressFormat compressFormat) {
        return (compressFormat != Bitmap.CompressFormat.PNG && compressFormat == Bitmap.CompressFormat.JPEG) ? SCREENSHOT_FILE_EXTENSION_JPG : SCREENSHOT_FILE_EXTENSION_PNG;
    }

    public void saveScreen(Context context, String str, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        saveScreen(context, str, null, true, SDKShotType.VIDEO_AND_OSD, onSaveComplete);
    }

    public void saveScreen(Context context, String str, boolean z, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        saveScreen(context, str, null, z, SDKShotType.VIDEO_AND_OSD, onSaveComplete);
    }

    public void saveScreen(Context context, String str, Rect rect, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        saveScreen(context, str, rect, true, SDKShotType.VIDEO_AND_OSD, onSaveComplete);
    }

    public void saveScreen(Context context, String str, Rect rect, SDKShotType sDKShotType, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        saveScreen(context, str, rect, true, sDKShotType, onSaveComplete);
    }

    private void saveScreen(Context context, String str, Rect rect, boolean z, SDKShotType sDKShotType, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        if (this.mCurrentTask == null) {
            ScreenshotAsyncTask screenshotAsyncTask = new ScreenshotAsyncTask(context, str, rect, z, sDKShotType, onSaveComplete);
            this.mCurrentTask = screenshotAsyncTask;
            screenshotAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
        }
    }

    private class ScreenshotAsyncTask extends AsyncTask<String, Void, String> {
        private Context mContext;
        private boolean mForceOsdAndVideo;
        private ISDKSnapshotHelper.OnSaveComplete mListener;
        private String mPath;
        private Rect mRegion;
        private SDKShotType mShotType;

        ScreenshotAsyncTask(Context context, String str, Rect rect, boolean z, SDKShotType sDKShotType, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
            this.mContext = context;
            this.mPath = str;
            this.mRegion = rect;
            this.mListener = onSaveComplete;
            this.mShotType = sDKShotType;
            this.mForceOsdAndVideo = z;
        }

        /* JADX INFO: Access modifiers changed from: protected */
        /* JADX WARN: Multi-variable type inference failed */
        /* JADX WARN: Removed duplicated region for block: B:93:0x01a7 A[EXC_TOP_SPLITTER, SYNTHETIC] */
        /* JADX WARN: Type inference failed for: r2v1 */
        /* JADX WARN: Type inference failed for: r2v2, types: [java.io.OutputStream] */
        /* JADX WARN: Type inference failed for: r2v3 */
        @Override // android.os.AsyncTask
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public java.lang.String doInBackground(java.lang.String... r10) throws java.lang.Throwable {
            /*
                Method dump skipped, instruction units count: 432
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: com.seewo.sdk.InternalScreenShotHelper.ScreenshotAsyncTask.doInBackground(java.lang.String[]):java.lang.String");
        }

        private boolean isIllegalRect(Rect rect, Bitmap bitmap) {
            return (rect.width() == 0) | (rect.height() == 0) | (rect.right > bitmap.getWidth()) | (rect.bottom > bitmap.getHeight());
        }

        /* JADX INFO: Access modifiers changed from: protected */
        @Override // android.os.AsyncTask
        public void onPostExecute(String str) {
            ISDKSnapshotHelper.OnSaveComplete onSaveComplete = this.mListener;
            if (onSaveComplete != null) {
                if (str != null) {
                    MediaScannerConnection.scanFile(this.mContext, new String[]{str}, null, null);
                    this.mListener.onSaveComplete(true, str);
                } else {
                    onSaveComplete.onSaveComplete(false, this.mPath);
                }
            }
            InternalScreenShotHelper.this.mCurrentTask = null;
        }
    }

    public Bitmap screenShot(Context context) {
        return screenShot(context, true);
    }

    public Bitmap screenShot(Context context, boolean z) {
        return screenShot(context, z, true);
    }

    public Bitmap screenShot(Context context, boolean z, boolean z2) {
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        return screenshotInner(context, displayMetrics.widthPixels, displayMetrics.heightPixels, z, z2);
    }

    public Bitmap screenShot(Context context, boolean z, boolean z2, SDKShotType sDKShotType) {
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        return screenshotInner(context, displayMetrics.widthPixels, displayMetrics.heightPixels, z, z2, sDKShotType);
    }

    private Bitmap screenshotInner(Context context, int i, int i2, boolean z, boolean z2) {
        return screenshotInner(context, i, i2, z, z2, SDKShotType.VIDEO_AND_OSD);
    }

    private void set9950ShotTypeProp(String str) {
        try {
            SystemProperties.set(SYSTEM_PROPERTY_SHOT_TYPE_9950, str);
        } catch (Exception unused) {
            if (PlatformUtils.isOpenSdkSystemService()) {
                return;
            }
            RLog.d(TAG, "set shot type by service : " + str);
            str.hashCode();
            switch (str) {
                case "0":
                    InternalPictureHelper.INSTANCE.setShotType(SDKShotType.VIDEO_AND_OSD);
                    break;
                case "1":
                    InternalPictureHelper.INSTANCE.setShotType(SDKShotType.OSD_ONLY);
                    break;
                case "2":
                    InternalPictureHelper.INSTANCE.setShotType(SDKShotType.VIDEO_ONLY);
                    break;
            }
        }
    }

    private boolean screenShotByJNI() {
        return PlatformUtils.isMLGChip() || BoardTypeUtils.is982Machine() || BoardTypeUtils.is972Machine();
    }

    /* JADX INFO: renamed from: com.seewo.sdk.InternalScreenShotHelper$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$com$seewo$sdk$model$SDKShotType;
        static final /* synthetic */ int[] $SwitchMap$com$seewo$sdk$util$ConfigUtils$ScreenshotMethod;

        static {
            int[] iArr = new int[ConfigUtils.ScreenshotMethod.values().length];
            $SwitchMap$com$seewo$sdk$util$ConfigUtils$ScreenshotMethod = iArr;
            try {
                iArr[ConfigUtils.ScreenshotMethod.NATIVE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$seewo$sdk$util$ConfigUtils$ScreenshotMethod[ConfigUtils.ScreenshotMethod.VIRTUAL_DISPLAY.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            int[] iArr2 = new int[SDKShotType.values().length];
            $SwitchMap$com$seewo$sdk$model$SDKShotType = iArr2;
            try {
                iArr2[SDKShotType.VIDEO_ONLY.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$com$seewo$sdk$model$SDKShotType[SDKShotType.OSD_ONLY.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$com$seewo$sdk$model$SDKShotType[SDKShotType.VIDEO_AND_OSD.ordinal()] = 3;
            } catch (NoSuchFieldError unused5) {
            }
        }
    }

    private Bitmap screenshotInner(Context context, int i, int i2, boolean z, boolean z2, SDKShotType sDKShotType) {
        Bitmap bitmapInvokeScreenshotSDK28;
        int i3 = AnonymousClass1.$SwitchMap$com$seewo$sdk$util$ConfigUtils$ScreenshotMethod[ConfigUtils.getScreenshotMethod().ordinal()];
        if (i3 == 1) {
            return invokeScreenshotSDK34(context, i, i2, z, z2);
        }
        if (i3 == 2) {
            return SDKVirtualDisplay.getInstance().screenShot(context);
        }
        if (ConfigUtils.isCaptureFromVds() || (!screenShotByJNI() && Build.VERSION.SDK_INT > 31)) {
            if (sDKShotType != SDKShotType.OSD_ONLY) {
                return SDKVirtualDisplay.getInstance().screenShot(context);
            }
            return invokeScreenshotOverSDK31(context, i, i2, z, z2);
        }
        InternalPictureHelper.INSTANCE.setShotType(sDKShotType);
        InternalPictureHelper.INSTANCE.setGalleryType();
        if (screenShotByJNI()) {
            int i4 = SystemProperties.getInt("persist.sys.shot_type", sDKShotType.ordinal());
            RLog.i(TAG, "screenshotInner:972 outType:" + i4);
            bitmapInvokeScreenshotSDK28 = ScreenControlManager.captureAmlogic(context, i, i2, i4);
        } else if (Build.VERSION.SDK_INT == 31) {
            bitmapInvokeScreenshotSDK28 = invokeScreenshotSDK31(context, i, i2);
        } else {
            if (BoardTypeUtils.is9950Machine()) {
                RLog.i(TAG, "setScreenShotType: ");
                int i5 = AnonymousClass1.$SwitchMap$com$seewo$sdk$model$SDKShotType[sDKShotType.ordinal()];
                if (i5 == 1) {
                    set9950ShotTypeProp(SeewoConstants.KEY_SECOND_BUTTON);
                } else if (i5 == 2) {
                    set9950ShotTypeProp("1");
                } else if (i5 == 3) {
                    set9950ShotTypeProp("0");
                }
            }
            bitmapInvokeScreenshotSDK28 = invokeScreenshotSDK28(i, i2);
        }
        InternalPictureHelper.INSTANCE.restoreShotType();
        InternalPictureHelper.INSTANCE.restoreGalleryType();
        if (bitmapInvokeScreenshotSDK28 != null && z2 && bitmapInvokeScreenshotSDK28.getWidth() > i) {
            bitmapInvokeScreenshotSDK28 = compressBitmap(bitmapInvokeScreenshotSDK28);
        }
        return (!z && z2 && isNeedResize()) ? resizeBitmap(bitmapInvokeScreenshotSDK28) : bitmapInvokeScreenshotSDK28;
    }

    private Bitmap invokeScreenshotOverSDK31(Context context, int i, int i2, boolean z, boolean z2) {
        if (Build.VERSION.SDK_INT >= 34) {
            return invokeScreenshotSDK34(context, i, i2, z, z2);
        }
        return invokeScreenshotSDK33(context, i, i2, z, z2);
    }

    private Bitmap invokeScreenshotSDK34(Context context, int i, int i2, boolean z, boolean z2) {
        try {
            RLog.i(TAG, "invokeScreenshotSDK34");
            Class<?> cls = Class.forName("android.window.ScreenCapture$CaptureArgs$Builder");
            Object objNewInstance = cls.getConstructor(new Class[0]).newInstance(new Object[0]);
            cls.getMethod("setSourceCrop", Rect.class).invoke(objNewInstance, new Rect(0, 0, i, i2));
            Object objInvoke = cls.getMethod("build", new Class[0]).invoke(objNewInstance, new Object[0]);
            Method declaredMethod = Class.forName("android.window.ScreenCapture").getDeclaredMethod("createSyncCaptureListener", new Class[0]);
            declaredMethod.setAccessible(true);
            Object objInvoke2 = declaredMethod.invoke(null, new Object[0]);
            Method declaredMethod2 = Class.forName("android.view.IWindowManager").getDeclaredMethod("captureDisplay", Integer.TYPE, Class.forName("android.window.ScreenCapture$CaptureArgs"), Class.forName("android.window.ScreenCapture$ScreenCaptureListener"));
            declaredMethod2.setAccessible(true);
            Method declaredMethod3 = Class.forName("android.view.WindowManagerGlobal").getDeclaredMethod("getWindowManagerService", new Class[0]);
            declaredMethod3.setAccessible(true);
            Object objInvoke3 = declaredMethod3.invoke(null, new Object[0]);
            Display defaultDisplay = getDefaultDisplay(context);
            declaredMethod2.invoke(objInvoke3, Integer.valueOf(defaultDisplay != null ? defaultDisplay.getDisplayId() : 0), objInvoke, objInvoke2);
            Method declaredMethod4 = objInvoke2.getClass().getDeclaredMethod("getBuffer", new Class[0]);
            declaredMethod4.setAccessible(true);
            Object objInvoke4 = declaredMethod4.invoke(objInvoke2, new Object[0]);
            Bitmap bitmapCompressBitmap = (Bitmap) objInvoke4.getClass().getMethod("asBitmap", new Class[0]).invoke(objInvoke4, new Object[0]);
            if (bitmapCompressBitmap != null && z2 && bitmapCompressBitmap.getWidth() > i) {
                bitmapCompressBitmap = compressBitmap(bitmapCompressBitmap);
            }
            return (!z && z2 && isNeedResize()) ? resizeBitmap(bitmapCompressBitmap) : bitmapCompressBitmap;
        } catch (Exception e) {
            RLog.e(TAG, "captureScreen failed", e);
            return null;
        }
    }

    public Display getDefaultDisplay(Context context) {
        WindowManager windowManager = (WindowManager) context.getSystemService("window");
        if (windowManager == null) {
            return null;
        }
        return windowManager.getDefaultDisplay();
    }

    private Bitmap invokeScreenshotSDK33(Context context, int i, int i2, boolean z, boolean z2) {
        try {
            Log.i(TAG, "invokeScreenshotSDK33");
            DisplayManager displayManager = (DisplayManager) context.getSystemService("display");
            Display defaultDisplay = getDefaultDisplay(context);
            if (defaultDisplay == null) {
                defaultDisplay = displayManager.getDisplay(0);
            }
            IBinder iBinder = (IBinder) SurfaceControl.class.getMethod("getPhysicalDisplayToken", Long.TYPE).invoke(null, Class.forName("android.view.DisplayAddress$Physical").getMethod("getPhysicalDisplayId", new Class[0]).invoke(defaultDisplay.getClass().getMethod("getAddress", new Class[0]).invoke(defaultDisplay, new Object[0]), new Object[0]));
            Class<?> cls = Class.forName("android.view.SurfaceControl$DisplayCaptureArgs$Builder");
            Object objNewInstance = cls.getConstructor(IBinder.class).newInstance(iBinder);
            cls.getMethod("setSourceCrop", Rect.class).invoke(objNewInstance, new Rect(0, 0, i, i2));
            cls.getMethod("setSize", Integer.TYPE, Integer.TYPE).invoke(objNewInstance, Integer.valueOf(i), Integer.valueOf(i2));
            Object objInvoke = cls.getMethod("build", new Class[0]).invoke(objNewInstance, new Object[0]);
            Object objInvoke2 = SurfaceControl.class.getMethod("captureDisplay", objInvoke.getClass()).invoke(null, objInvoke);
            Bitmap bitmapCompressBitmap = (Bitmap) objInvoke2.getClass().getMethod("asBitmap", new Class[0]).invoke(objInvoke2, new Object[0]);
            if (bitmapCompressBitmap != null && z2 && bitmapCompressBitmap.getWidth() > i) {
                bitmapCompressBitmap = compressBitmap(bitmapCompressBitmap);
            }
            return (!z && z2 && isNeedResize()) ? resizeBitmap(bitmapCompressBitmap) : bitmapCompressBitmap;
        } catch (Exception e) {
            Log.e(TAG, "captureScreen failed", e);
            return null;
        }
    }

    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 Bitmap invokeScreenshotSDK31(Context context, int i, int i2) {
        SystemProperties.set(SYSTEM_PROPERTY_SCREENSHOT_MODE, SeewoConstants.KEY_SECOND_BUTTON);
        Display display = ((DisplayManager) context.getSystemService("display")).getDisplay(0);
        DisplayMetrics displayMetrics = new DisplayMetrics();
        display.getRealMetrics(displayMetrics);
        int i3 = displayMetrics.widthPixels;
        int i4 = displayMetrics.heightPixels;
        Bitmap bitmap = null;
        try {
            Object objInvoke = Class.forName("android.view.Display").getDeclaredMethod("getAddress", new Class[0]).invoke(display, new Object[0]);
            Class<?> cls = Class.forName("android.view.DisplayAddress$Physical");
            if (!cls.isInstance(objInvoke)) {
                Log.e(TAG, "Skipping Screenshot - Default display does not have a physical address: " + display);
            } else {
                long jLongValue = ((Long) cls.getDeclaredMethod("getPhysicalDisplayId", new Class[0]).invoke(objInvoke, new Object[0])).longValue();
                Class<?> cls2 = Class.forName("android.view.SurfaceControl");
                IBinder iBinder = (IBinder) cls2.getDeclaredMethod("getPhysicalDisplayToken", Long.TYPE).invoke(null, Long.valueOf(jLongValue));
                Class<?> cls3 = Class.forName("android.view.SurfaceControl$DisplayCaptureArgs$Builder");
                Object objInvoke2 = cls3.getDeclaredMethod("build", new Class[0]).invoke(cls3.getDeclaredMethod("setSize", Integer.TYPE, Integer.TYPE).invoke(cls3.getDeclaredMethod("setSourceCrop", Rect.class).invoke(cls3.getDeclaredConstructor(IBinder.class).newInstance(iBinder), new Rect(0, 0, i3, i4)), Integer.valueOf(i), Integer.valueOf(i2)), new Object[0]);
                Object objInvoke3 = cls2.getDeclaredMethod("captureDisplay", objInvoke2.getClass()).invoke(null, objInvoke2);
                if (objInvoke3 != null) {
                    bitmap = (Bitmap) Class.forName("android.view.SurfaceControl$ScreenshotHardwareBuffer").getDeclaredMethod("asBitmap", new Class[0]).invoke(objInvoke3, new Object[0]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        SystemProperties.set(SYSTEM_PROPERTY_SCREENSHOT_MODE, "1");
        return bitmap;
    }

    private Bitmap compressBitmap(Bitmap bitmap) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        Matrix matrix = new Matrix();
        matrix.postScale(1920.0f / width, 1080.0f / height);
        if (SDKPictureHelper.I.is4k2kResolution()) {
            return Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
        }
        return Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, false);
    }

    private static Bitmap resizeBitmap(Bitmap bitmap) {
        RectF rectF = new RectF();
        rectF.left = 240.0f;
        rectF.top = 0.0f;
        rectF.right = 1920.0f - rectF.left;
        rectF.bottom = 1080.0f;
        Bitmap bitmapCreateBitmap = Bitmap.createBitmap(1920, 1080, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmapCreateBitmap);
        canvas.drawColor(-16777216);
        canvas.drawBitmap(bitmap, (Rect) null, rectF, (Paint) null);
        canvas.setBitmap(null);
        return bitmapCreateBitmap;
    }

    private static boolean isNeedResize() {
        return SDKSourceHelper.I.getCurrentSource() != ISDKSourceHelper.SDKSourceItem.ANDROID && SDKPictureHelper.I.isSolution4x3SupportedInCurrentSource() && SDKPictureHelper.I.getSolution() == ISDKPictureHelper.SDKSolution.SOLUTION_4_3 && BoardTypeUtils.isHISIMachine();
    }
}