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.media.MediaScannerConnection;
import android.os.AsyncTask;
import android.os.SystemProperties;
import android.util.DisplayMetrics;
import android.util.Log;
import androidx.core.view.ViewCompat;
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.PlatformUtils;
import com.seewo.sdk.util.RLog;
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_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_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, onSaveComplete);
    }

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

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

    private void saveScreen(Context context, String str, Rect rect, boolean z, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
        if (this.mCurrentTask == null) {
            ScreenshotAsyncTask screenshotAsyncTask = new ScreenshotAsyncTask(context, str, rect, z, 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;

        ScreenshotAsyncTask(Context context, String str, Rect rect, boolean z, ISDKSnapshotHelper.OnSaveComplete onSaveComplete) {
            this.mContext = context;
            this.mPath = str;
            this.mRegion = rect;
            this.mListener = onSaveComplete;
            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:88:0x0194 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: 413
                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 Bitmap screenshotInner(Context context, int i, int i2, boolean z, boolean z2, SDKShotType sDKShotType) {
        Bitmap bitmapCaptureAmlogic;
        InternalPictureHelper.INSTANCE.setShotType(sDKShotType);
        InternalPictureHelper.INSTANCE.setGalleryType();
        if (PlatformUtils.isMLGChip() || BoardTypeUtils.is982Machine()) {
            int i3 = SystemProperties.getInt("persist.sys.shot_type", sDKShotType.ordinal());
            RLog.i(TAG, "screenshotInner:972 outType:" + i3);
            bitmapCaptureAmlogic = ScreenControlManager.captureAmlogic(i, i2, i3);
        } else {
            if (BoardTypeUtils.is9950Machine()) {
                RLog.i(TAG, "setScreenShotType: ");
                int i4 = AnonymousClass1.$SwitchMap$com$seewo$sdk$model$SDKShotType[sDKShotType.ordinal()];
                if (i4 == 1) {
                    set9950ShotTypeProp("2");
                } else if (i4 == 2) {
                    set9950ShotTypeProp("1");
                } else if (i4 == 3) {
                    set9950ShotTypeProp("0");
                }
            }
            bitmapCaptureAmlogic = invokeScreenshotSDK28(i, i2);
        }
        InternalPictureHelper.INSTANCE.restoreShotType();
        InternalPictureHelper.INSTANCE.restoreGalleryType();
        if (bitmapCaptureAmlogic != null && z2 && bitmapCaptureAmlogic.getWidth() > i) {
            bitmapCaptureAmlogic = compressBitmap(bitmapCaptureAmlogic);
        }
        return (!z && z2 && isNeedResize()) ? resizeBitmap(bitmapCaptureAmlogic) : bitmapCaptureAmlogic;
    }

    /* 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 {
            int[] iArr = new int[SDKShotType.values().length];
            $SwitchMap$com$seewo$sdk$model$SDKShotType = iArr;
            try {
                iArr[SDKShotType.VIDEO_ONLY.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$seewo$sdk$model$SDKShotType[SDKShotType.OSD_ONLY.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$com$seewo$sdk$model$SDKShotType[SDKShotType.VIDEO_AND_OSD.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    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 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(ViewCompat.MEASURED_STATE_MASK);
        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();
    }
}