package cn.com.magnity.magnitycx;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PaintFlagsDrawFilter;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import cn.com.magnity.magnitycx.FragmentMainCenter;
import cn.com.magnity.magnitycx.log.Logging;
import cn.com.magnity.magnitycx.sdk.DeviceController;
import cn.com.magnity.magnitycx.sdk.MagParameter;
import cn.com.magnity.magnitycx.sdk.SharedPreferencesManager;
import cn.com.magnity.magnitycx.sdk.State;
import cn.com.magnity.magnitycx.sdk.TimerHelper;
import cn.com.magnity.magnitycx.sdk.UsbCommunication;
import cn.com.magnity.magnitycx.sdk.WaitCondition;
import com.baidu.mobstat.Config;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/* loaded from: classes.dex */
public class ImageViewer extends SurfaceView implements SurfaceHolder.Callback, UsbCommunication.DelegateNewFrame, FragmentMainCenter.DelegateCapture {
    private static final int MAX_ROI_NUM = 1;
    private int aimOrientation_;
    private int aimX_;
    private int aimY_;
    private Bitmap bmpIr_;
    private Canvas cachedCanvas_;
    private Bitmap cachedbmp_;
    private WaitCondition condRecording_;
    private int dx_;
    private int dy_;
    private volatile int fpaHeight_;
    private volatile int fpaWidth_;
    private int frameIndex_;
    private int height_;
    private SurfaceHolder holder_;
    private volatile int imageStableCounter_;
    private boolean isAimDrag_;
    private volatile boolean isExitThreadRecording_;
    private volatile boolean isExitThreadRender_;
    private volatile boolean isTempStable_;
    private ArrayList<ROIInfo> listRoi_;
    private Matrix matrixVGA_;
    private Matrix matrix_;
    private Paint paintROIVGA_;
    private Paint paintROI_;
    private Paint paintVGA_;
    private Paint paint_;
    private PaintFlagsDrawFilter pfd_;
    private AtomicLong recordingTimeElapsed_;
    private volatile ThreadLocalParam threadLocalParam_;
    private ThreadRecording threadRecording_;
    private ThreadRender threadRender_;
    private TimerHelper timerHelper_;
    private WaitCondition waitCondition_;
    private int width_;
    private static volatile Lock lock_ = new ReentrantLock();
    private static volatile long[] ticks_ = new long[20];
    private static Object syncNotifyNewFrame_ = new Object();
    private static ArrayList<ImageViewer> imgViewerList_ = new ArrayList<>();

    private class ThreadLocalParam implements Cloneable {
        int centerTemp;
        State state;

        private ThreadLocalParam() {
        }

        public Object clone() throws CloneNotSupportedException {
            ThreadLocalParam param = (ThreadLocalParam) super.clone();
            if (this.state != null) {
                param.state = (State) this.state.clone();
            }
            return param;
        }
    }

    private class OSDParam {
        private Bitmap crossLogo_;
        private Bitmap laserLogo_;
        private Bitmap maxTrace_;
        private Bitmap minTrace_;
        private Bitmap moveingCrossLogo_;
        private Bitmap waterMark_;

        private OSDParam() {
        }

        public Bitmap getCrossLogo() {
            return this.crossLogo_;
        }

        public Bitmap getWaterMark() {
            return this.waterMark_;
        }

        public Bitmap getMinTrace() {
            return this.minTrace_;
        }

        public Bitmap getMaxTrace() {
            return this.maxTrace_;
        }

        public Bitmap getMovingCrossLogo() {
            return this.moveingCrossLogo_;
        }

        public Bitmap getLaserLogo() {
            return this.laserLogo_;
        }

        public void setCrossLogo(int id) {
            this.crossLogo_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        public void setWaterMark(int id) {
            this.waterMark_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        public void setMinTrace(int id) {
            this.minTrace_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        public void setMaxTrace(int id) {
            this.maxTrace_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        public void setMovingCrossLogo(int id) {
            this.moveingCrossLogo_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        public void setLaserLogo(int id) {
            this.laserLogo_ = BitmapFactory.decodeResource(ImageViewer.this.getResources(), id);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public void reset() {
            if (this.crossLogo_ != null && !this.crossLogo_.isRecycled()) {
                this.crossLogo_.recycle();
                this.crossLogo_ = null;
            }
            if (this.waterMark_ != null && !this.waterMark_.isRecycled()) {
                this.waterMark_.recycle();
                this.waterMark_ = null;
            }
            if (this.minTrace_ != null && !this.minTrace_.isRecycled()) {
                this.minTrace_.recycle();
                this.minTrace_ = null;
            }
            if (this.maxTrace_ != null && !this.maxTrace_.isRecycled()) {
                this.maxTrace_.recycle();
                this.maxTrace_ = null;
            }
            if (this.moveingCrossLogo_ != null && !this.moveingCrossLogo_.isRecycled()) {
                this.moveingCrossLogo_.recycle();
                this.moveingCrossLogo_ = null;
            }
            if (this.laserLogo_ != null && !this.laserLogo_.isRecycled()) {
                this.laserLogo_.recycle();
                this.laserLogo_ = null;
            }
        }
    }

    public void setTempStableFlag(boolean isStable) {
        this.isTempStable_ = isStable;
    }

    public boolean getTempStableFlag() {
        return this.isTempStable_;
    }

    public void setImageStableCounter(int counter) {
        this.imageStableCounter_ = counter;
    }

    public int getImageStableCounter() {
        return this.imageStableCounter_;
    }

    public ImageViewer(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.waitCondition_ = new WaitCondition();
        this.condRecording_ = new WaitCondition();
        this.threadLocalParam_ = new ThreadLocalParam();
        this.paint_ = new Paint(1);
        this.matrix_ = new Matrix();
        this.matrixVGA_ = new Matrix();
        this.paintVGA_ = new Paint(1);
        this.paintROI_ = new Paint(1);
        this.paintROIVGA_ = new Paint(1);
        this.listRoi_ = new ArrayList<>();
        this.recordingTimeElapsed_ = new AtomicLong(0L);
        this.holder_ = getHolder();
        this.holder_.setFormat(-2);
        this.holder_.addCallback(this);
        this.timerHelper_ = new TimerHelper() { // from class: cn.com.magnity.magnitycx.ImageViewer.1
            @Override // cn.com.magnity.magnitycx.sdk.TimerHelper
            public void run() {
                ImageViewer.this.recordingTimeElapsed_.getAndIncrement();
            }
        };
    }

    private void invalidate_() {
        synchronized (this.waitCondition_.cond) {
            this.waitCondition_.notified = true;
            this.waitCondition_.cond.notify();
        }
    }

    private void recordingOneFrame() {
        synchronized (this.condRecording_.cond) {
            this.condRecording_.notified = true;
            this.condRecording_.cond.notify();
        }
    }

    private void updateUiTemps(int fpaWidth, int fpaHeight) {
        int pos;
        switch (DeviceController.getPreviewOrientation()) {
            case 0:
            case 180:
                pos = ((fpaHeight + 1) * fpaWidth) / 2;
                break;
            default:
                pos = ((fpaWidth + 1) * fpaHeight) / 2;
                break;
        }
        this.threadLocalParam_.centerTemp = DeviceController.getTemperature(pos, 1, false);
        this.threadLocalParam_.state = DeviceController.getState();
        ROIInfo.lock();
        try {
            Iterator<ROIInfo> it = this.listRoi_.iterator();
            while (it.hasNext()) {
                ROIInfo roiInfo = it.next();
                switch (roiInfo.getType()) {
                    case 1:
                        int[] info = new int[5];
                        if (roiInfo.isBigEnouth() && DeviceController.getRectTemperatureInfo(roiInfo.getBeginPointX(), roiInfo.getBeginPointY(), roiInfo.getEndPointX(), roiInfo.getEndPointY(), info, false)) {
                            roiInfo.setTempInfo(info[0], info[1], info[2], info[3], info[4]);
                            break;
                        }
                        break;
                }
            }
        } finally {
            ROIInfo.unlock();
        }
    }

    public void initData(int fpaWidth, int fpaHeight) {
        this.fpaWidth_ = fpaWidth;
        this.fpaHeight_ = fpaHeight;
        if (this.bmpIr_ == null) {
            this.bmpIr_ = Bitmap.createBitmap(fpaWidth, fpaHeight, Bitmap.Config.ARGB_8888);
        } else if (this.bmpIr_.getWidth() != fpaWidth || this.bmpIr_.getHeight() != fpaHeight) {
            if (!this.bmpIr_.isRecycled()) {
                this.bmpIr_.recycle();
            }
            this.bmpIr_ = Bitmap.createBitmap(fpaWidth, fpaHeight, Bitmap.Config.ARGB_8888);
        }
    }

    @Override // cn.com.magnity.magnitycx.sdk.UsbCommunication.DelegateNewFrame
    public void onNewFrameReceived(int fpaTemp, int camTemp) {
        DeviceController.Lock();
        if (!DeviceController.getOutputBMPData(this.bmpIr_, this.fpaWidth_ * this.fpaHeight_ * 4)) {
            DeviceController.Unlock();
            return;
        }
        int i = this.frameIndex_;
        this.frameIndex_ = i + 1;
        if ((i & 7) == 0) {
            updateUiTemps(this.fpaWidth_, this.fpaHeight_);
        }
        DeviceController.Unlock();
        if (DeviceController.isRecording()) {
            recordingOneFrame();
        }
        invalidate_();
    }

    private void calculateScreenFit() {
        int width;
        int height;
        int width2 = getWidth();
        int height2 = getHeight();
        if (getResources().getConfiguration().orientation == 1) {
            if (width2 * 4 > height2 * 3) {
                height = (height2 / 12) * 12;
                width = (height * 3) / 4;
            } else {
                width = (width2 / 12) * 12;
                height = (width * 4) / 3;
            }
        } else if (width2 * 3 > height2 * 4) {
            height = (height2 / 12) * 12;
            width = (height * 4) / 3;
        } else {
            width = (width2 / 12) * 12;
            height = (width * 3) / 4;
        }
        this.dx_ = (getWidth() - width) / 2;
        this.dy_ = (getHeight() - height) / 2;
        this.width_ = width;
        this.height_ = height;
    }

    @Override // android.view.SurfaceHolder.Callback
    public void surfaceCreated(SurfaceHolder holder) {
        if (this.cachedbmp_ == null) {
            switch (DeviceController.getPreviewOrientation()) {
                case 0:
                case 180:
                    this.cachedbmp_ = Bitmap.createBitmap(640, 480, Bitmap.Config.ARGB_8888);
                    break;
                case 90:
                case 270:
                    this.cachedbmp_ = Bitmap.createBitmap(480, 640, Bitmap.Config.ARGB_8888);
                    break;
            }
        }
        if (this.cachedCanvas_ == null) {
            this.cachedCanvas_ = new Canvas();
            this.cachedCanvas_.setBitmap(this.cachedbmp_);
        }
        Canvas canvas = this.holder_.lockCanvas();
        if (canvas != null) {
            this.paint_.setTextSize(getResources().getDimensionPixelSize(R.dimen.liveTemperatureTextSize));
            this.paint_.setTypeface(Typeface.SANS_SERIF);
            this.paint_.setTextAlign(Paint.Align.LEFT);
            this.paint_.setColor(getResources().getColor(R.color.liveBackground));
            canvas.drawRect(0.0f, 0.0f, getWidth(), getHeight(), this.paint_);
            this.holder_.unlockCanvasAndPost(canvas);
            this.paint_.setColor(getResources().getColor(R.color.textColor));
            this.paint_.setStyle(Paint.Style.FILL_AND_STROKE);
            this.paint_.setStrokeWidth(2.0f);
            this.paint_.setShadowLayer(12.0f, 0.0f, 0.0f, getResources().getColor(R.color.black));
            this.paintVGA_.setTextSize(getResources().getDimensionPixelSize(R.dimen.recordingTemperatureTextSize));
            this.paintVGA_.setTypeface(Typeface.SANS_SERIF);
            this.paintVGA_.setTextAlign(Paint.Align.LEFT);
            this.paintVGA_.setColor(getResources().getColor(R.color.textColor));
            this.paintVGA_.setStyle(Paint.Style.FILL_AND_STROKE);
            this.paintVGA_.setStrokeWidth(1.0f);
            this.paintVGA_.setShadowLayer(6.0f, 0.0f, 0.0f, getResources().getColor(R.color.black));
            this.paintROI_.setColor(getResources().getColor(R.color.roiColor));
            this.paintROI_.setStyle(Paint.Style.STROKE);
            this.paintROI_.setStrokeWidth(4.0f);
            this.paintROI_.setShadowLayer(6.0f, 0.0f, 0.0f, getResources().getColor(R.color.black));
            this.paintROIVGA_.setColor(getResources().getColor(R.color.roiColor));
            this.paintROIVGA_.setStyle(Paint.Style.STROKE);
            this.paintROIVGA_.setStrokeWidth(2.0f);
            this.paintROIVGA_.setShadowLayer(2.0f, 0.0f, 0.0f, getResources().getColor(R.color.black));
        }
        this.pfd_ = new PaintFlagsDrawFilter(0, 3);
        synchronized (syncNotifyNewFrame_) {
            imgViewerList_.add(this);
        }
        calculateScreenFit();
        this.aimOrientation_ = getResources().getConfiguration().orientation;
        if (this.aimOrientation_ == 1) {
            this.aimX_ = SharedPreferencesManager.getInt("aimX_portrait", getWidth() / 2);
            this.aimY_ = SharedPreferencesManager.getInt("aimY_portrait", getHeight() / 2);
        } else {
            this.aimX_ = SharedPreferencesManager.getInt("aimX_landscape", getWidth() / 2);
            this.aimY_ = SharedPreferencesManager.getInt("aimY_landscape", getHeight() / 2);
        }
        DeviceController.setColorbarSize(100, 20);
        DeviceController.setColorPalette(SharedPreferencesManager.getInt("paletteIndex", 2));
        this.threadRender_ = new ThreadRender();
        this.isExitThreadRender_ = false;
        this.waitCondition_.notified = false;
        this.threadRender_.start();
        this.threadRecording_ = new ThreadRecording();
        this.isExitThreadRecording_ = false;
        this.condRecording_.notified = false;
        this.threadRecording_.start();
    }

    @Override // android.view.SurfaceHolder.Callback
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        calculateScreenFit();
    }

    @Override // android.view.SurfaceHolder.Callback
    public void surfaceDestroyed(SurfaceHolder holder) {
        if (this.aimOrientation_ == 1) {
            SharedPreferencesManager.putInt("aimX_portrait", this.aimX_);
            SharedPreferencesManager.putIntWithCommit("aimY_portrait", this.aimY_);
        } else {
            SharedPreferencesManager.putInt("aimX_landscape", this.aimX_);
            SharedPreferencesManager.putIntWithCommit("aimY_landscape", this.aimY_);
        }
        this.isExitThreadRender_ = true;
        synchronized (this.waitCondition_.cond) {
            this.waitCondition_.notified = true;
            this.waitCondition_.cond.notify();
        }
        try {
            this.threadRender_.join();
            this.threadRender_ = null;
        } catch (InterruptedException e) {
        }
        this.isExitThreadRecording_ = true;
        synchronized (this.condRecording_.cond) {
            this.condRecording_.notified = true;
            this.condRecording_.cond.notify();
        }
        try {
            this.threadRecording_.join();
            this.threadRecording_ = null;
        } catch (InterruptedException e2) {
        }
        synchronized (syncNotifyNewFrame_) {
            imgViewerList_.remove(this);
        }
        this.cachedCanvas_ = null;
        if (!this.cachedbmp_.isRecycled()) {
            this.cachedbmp_.recycle();
            this.cachedbmp_ = null;
        }
    }

    @Override // cn.com.magnity.magnitycx.FragmentMainCenter.DelegateCapture
    public boolean onStartRecording(String pathName) {
        boolean ret = DeviceController.startRecording(pathName, this.cachedbmp_.getWidth(), this.cachedbmp_.getHeight(), 2048, 20, 5);
        this.recordingTimeElapsed_.set(0L);
        this.timerHelper_.start(1000L, 1000L);
        return ret;
    }

    @Override // cn.com.magnity.magnitycx.FragmentMainCenter.DelegateCapture
    public void onStopRecording() {
        this.timerHelper_.stop();
        if (DeviceController.isRecording()) {
            DeviceController.stopRecording();
        }
    }

    @Override // cn.com.magnity.magnitycx.FragmentMainCenter.DelegateCapture
    public Bitmap onCapture() {
        OSDParam osdParam = new OSDParam();
        osdParam.setCrossLogo(R.mipmap.cross_capture);
        osdParam.setWaterMark(R.mipmap.water_mark);
        osdParam.setMinTrace(R.mipmap.min_trace_capture);
        osdParam.setMaxTrace(R.mipmap.max_trace_capture);
        DeviceController.Lock();
        updateUiTemps(this.fpaWidth_, this.fpaHeight_);
        DeviceController.Unlock();
        drawImage(this.cachedCanvas_, this.paintVGA_, this.paintROIVGA_, this.matrixVGA_, 0, 0, this.cachedbmp_.getWidth(), this.cachedbmp_.getHeight(), osdParam);
        return this.cachedbmp_;
    }

    @Override // cn.com.magnity.magnitycx.FragmentMainCenter.DelegateCapture
    public void onCaptureFinished(String pathName) {
    }

    @Override // android.view.View
    public boolean onTouchEvent(MotionEvent event) {
        boolean z = false;
        if (!DeviceController.isProcessImage()) {
            return false;
        }
        switch (event.getActionMasked()) {
            case 0:
                if (MagApplication.magParameter.isTraceRoi) {
                    int[] coor = DeviceController.screenXY2ClientXY(((int) event.getX()) - this.dx_, ((int) event.getY()) - this.dy_, this.width_, this.height_);
                    boolean isPointInROI = false;
                    ROIInfo.lock();
                    try {
                        Iterator<ROIInfo> it = this.listRoi_.iterator();
                        while (true) {
                            if (it.hasNext()) {
                                if (it.next().isPointIn(coor[0], coor[1])) {
                                    it.remove();
                                    isPointInROI = true;
                                }
                            }
                        }
                        if (!isPointInROI && this.listRoi_.size() > 0) {
                            this.listRoi_.remove(0);
                        }
                        ROIInfo.unlock();
                        ROIInfo roiInfo = new ROIInfo(1);
                        roiInfo.setBeginPoint(coor[0], coor[1]);
                        roiInfo.setEndPoint(coor[0], coor[1]);
                        ROIInfo.lock();
                        try {
                            this.listRoi_.add(roiInfo);
                            return true;
                        } finally {
                        }
                    } finally {
                    }
                }
                if (MagApplication.magParameter.basePara1.devType != 1 || !MagApplication.magParameter.isShowMovingCross || event.getX() <= this.aimX_ - 48 || event.getX() >= this.aimX_ + 48 || event.getY() <= this.aimY_ - 48 || event.getY() >= this.aimY_ + 48) {
                    return false;
                }
                this.isAimDrag_ = true;
                return true;
            case 1:
                if (MagApplication.magParameter.isTraceRoi) {
                    int num = this.listRoi_.size();
                    if (num < 1) {
                        return false;
                    }
                    ROIInfo roiInfo2 = this.listRoi_.get(num - 1);
                    int[] coor2 = DeviceController.screenXY2ClientXY(((int) event.getX()) - this.dx_, ((int) event.getY()) - this.dy_, this.width_, this.height_);
                    ROIInfo.lock();
                    try {
                        roiInfo2.setEndPoint(coor2[0], coor2[1]);
                        if (!roiInfo2.isBigEnouth()) {
                            this.listRoi_.remove(num - 1);
                        } else {
                            roiInfo2.setFinished();
                            ROIInfo.unlock();
                            invalidate_();
                            z = true;
                        }
                        return z;
                    } finally {
                    }
                }
                if (!this.isAimDrag_) {
                    return false;
                }
                this.isAimDrag_ = false;
                invalidate_();
                return true;
            case 2:
                if (MagApplication.magParameter.isTraceRoi) {
                    int num2 = this.listRoi_.size();
                    if (num2 < 1) {
                        return false;
                    }
                    ROIInfo roiInfo3 = this.listRoi_.get(num2 - 1);
                    int[] coor3 = DeviceController.screenXY2ClientXY(((int) event.getX()) - this.dx_, ((int) event.getY()) - this.dy_, this.width_, this.height_);
                    if (!roiInfo3.isFinished()) {
                        ROIInfo.lock();
                        try {
                            roiInfo3.setEndPoint(coor3[0], coor3[1]);
                        } finally {
                        }
                    }
                    return true;
                }
                if (!this.isAimDrag_) {
                    return false;
                }
                this.aimX_ = (int) event.getX();
                this.aimY_ = (int) event.getY();
                if (this.aimX_ < this.dx_) {
                    this.aimX_ = this.dx_;
                } else if (this.aimX_ > this.dx_ + this.width_) {
                    this.aimX_ = this.dx_ + this.width_;
                }
                if (this.aimY_ < this.dy_) {
                    this.aimY_ = this.dy_;
                } else if (this.aimY_ > this.dy_ + this.height_) {
                    this.aimY_ = this.dy_ + this.height_;
                }
                invalidate_();
                return true;
            default:
                return false;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doDraw(OSDParam param) {
        Bitmap crossLogo;
        Canvas canvas = this.holder_.lockCanvas();
        if (canvas != null) {
            drawImage(canvas, this.paint_, this.paintROI_, this.matrix_, this.dx_, this.dy_, this.width_, this.height_, param);
            drawMarginBackground(canvas, this.paint_, this.dx_, this.dy_, this.width_, this.height_);
            if (DeviceController.isRecording()) {
                drawRecordingTime(canvas, this.paint_, this.dx_, this.dy_, this.width_, this.height_, this.recordingTimeElapsed_.get());
            }
            if (MagApplication.magParameter.basePara1.devType == 1 && (crossLogo = param.getMovingCrossLogo()) != null && MagApplication.magParameter.isShowMovingCross) {
                canvas.drawBitmap(crossLogo, this.aimX_ - (crossLogo.getWidth() / 2), this.aimY_ - (crossLogo.getHeight() / 2), (Paint) null);
            }
            this.holder_.unlockCanvasAndPost(canvas);
        }
    }

    private void drawFps(Canvas canvas, Paint paint, int dx, int dy, int width, int height, int recvFps, int showFps) {
        Paint p = new Paint();
        p.setColor(-16711936);
        p.setTextSize(20.0f);
        String s = String.format("接收帧率:%s", Integer.valueOf(recvFps));
        Rect rect = new Rect();
        p.getTextBounds(s, 0, s.length(), rect);
        canvas.drawText(s, dx + 2, rect.height() + dy + 2, p);
        canvas.drawText(String.format("显示帧率:%s", Integer.valueOf(showFps)), dx + 2, ((rect.height() + 2) * 2) + dy, p);
    }

    private void drawRecordingTime(Canvas canvas, Paint paint, int dx, int dy, int width, int height, long seconds) {
        long hour = seconds / 3600;
        long min = (seconds - (3600 * hour)) / 60;
        long sec = (seconds - (3600 * hour)) - (60 * min);
        String hms = String.format("%02d", Long.valueOf(hour)) + Config.TRACE_TODAY_VISIT_SPLIT + String.format("%02d", Long.valueOf(min)) + Config.TRACE_TODAY_VISIT_SPLIT + String.format("%02d", Long.valueOf(sec));
        float oldFontSize = paint.getTextSize();
        paint.setTextSize(getResources().getDimensionPixelSize(R.dimen.recordingTimeTextSize));
        int oldFontColor = paint.getColor();
        paint.setColor(getResources().getColor(R.color.highlightText));
        Rect rect = new Rect();
        paint.getTextBounds(hms + "8", 0, hms.length() + 1, rect);
        canvas.drawText(hms, ((getWidth() - rect.width()) / 2) + dx, (dy + height) - 20, paint);
        paint.setTextSize(oldFontSize);
        paint.setColor(oldFontColor);
    }

    private void drawMarginBackground(Canvas canvas, Paint paint, int dx, int dy, int width, int height) {
        int oldColor = paint.getColor();
        paint.setColor(getResources().getColor(R.color.black));
        canvas.drawRect(0.0f, 0.0f, dx, getHeight(), paint);
        canvas.drawRect(0.0f, 0.0f, getWidth(), dy, paint);
        canvas.drawRect(dx + width, 0.0f, getWidth(), getHeight(), paint);
        canvas.drawRect(0.0f, dy + height, getWidth(), getHeight(), paint);
        paint.setColor(oldColor);
    }

    private void drawROIs(Canvas canvas, Paint paint, Paint paintROI, Rect rect, int dx, int dy, int width, int height, OSDParam osdParam) {
        String format;
        int[] coor;
        Bitmap maxTrace = osdParam.getMaxTrace();
        Bitmap minTrace = osdParam.getMinTrace();
        int traceType = MagApplication.magParameter.maxMinTrace;
        if (this.isTempStable_) {
            format = "%.1f℃";
        } else {
            format = "~%.1f℃";
        }
        int pad = maxTrace.getWidth() / 6;
        ROIInfo.lock();
        try {
            Iterator<ROIInfo> it = this.listRoi_.iterator();
            while (it.hasNext()) {
                ROIInfo roiInfo = it.next();
                switch (roiInfo.getType()) {
                    case 1:
                        int[] coor2 = DeviceController.clientXY2ScreenXY(roiInfo.getBeginPointX(), roiInfo.getBeginPointY(), width, height);
                        int[] coor22 = DeviceController.clientXY2ScreenXY(roiInfo.getEndPointX(), roiInfo.getEndPointY(), width, height);
                        canvas.drawRect(coor2[0] + dx, coor2[1] + dy, coor22[0] + dx, coor22[1] + dy, paintROI);
                        if (roiInfo.isBigEnouth() && roiInfo.isTempValid()) {
                            if ((traceType == 0 || traceType == 2 || traceType == -1) && (coor = DeviceController.clientPos2ScreenXY(roiInfo.getMaxPos(), width, height)) != null) {
                                canvas.drawBitmap(maxTrace, (coor[0] - (maxTrace.getWidth() / 2)) + dx, (coor[1] - (maxTrace.getHeight() / 2)) + dy, paint);
                                String str = String.format(format, Float.valueOf(roiInfo.getMaxTemp() * 0.001f));
                                paint.getTextBounds(str, 0, str.length(), rect);
                                int cx = rect.width();
                                int cy = rect.height();
                                int x = coor[0] + pad;
                                int y = coor[1] + cy + pad;
                                if (x > width - cx) {
                                    x = (coor[0] - pad) - cx;
                                }
                                if (y > height) {
                                    y = (coor[1] - pad) - cy;
                                }
                                canvas.drawText(str, x + dx, y + dy, paint);
                            }
                            if (traceType != 1 && traceType != 2) {
                                break;
                            } else {
                                int[] coor3 = DeviceController.clientPos2ScreenXY(roiInfo.getMinPos(), width, height);
                                if (coor3 == null) {
                                    break;
                                } else {
                                    canvas.drawBitmap(minTrace, (coor3[0] - (minTrace.getWidth() / 2)) + dx, (coor3[1] - (minTrace.getHeight() / 2)) + dy, paint);
                                    String str2 = String.format(format, Float.valueOf(roiInfo.getMinTemp() * 0.001f));
                                    paint.getTextBounds(str2, 0, str2.length(), rect);
                                    int cx2 = rect.width();
                                    int cy2 = rect.height();
                                    int x2 = coor3[0] + pad;
                                    int y2 = coor3[1] + cy2 + pad;
                                    if (x2 > width - cx2) {
                                        x2 = (coor3[0] - pad) - cx2;
                                    }
                                    if (y2 > height) {
                                        y2 = (coor3[1] - pad) - cy2;
                                    }
                                    canvas.drawText(str2, x2 + dx, y2 + dy, paint);
                                    break;
                                }
                            }
                        }
                        break;
                }
            }
        } finally {
            ROIInfo.unlock();
        }
    }

    private void drawMaxMin(Canvas canvas, Paint paint, State state, Rect rect, int dx, int dy, int width, int height, OSDParam osdParam) {
        String format;
        int[] coor;
        int[] coor2;
        Bitmap maxTrace = osdParam.getMaxTrace();
        Bitmap minTrace = osdParam.getMinTrace();
        if (this.isTempStable_) {
            format = "%.1f℃";
        } else {
            format = "~%.1f℃";
        }
        if (maxTrace != null && minTrace != null) {
            int pad = maxTrace.getWidth() / 6;
            int traceType = MagApplication.magParameter.maxMinTrace;
            if ((traceType == 0 || traceType == 2) && (coor = DeviceController.clientXY2ScreenXY(state.intMaxX, state.intMaxY, width, height)) != null) {
                canvas.drawBitmap(maxTrace, (coor[0] - (maxTrace.getWidth() / 2)) + dx, (coor[1] - (maxTrace.getHeight() / 2)) + dy, paint);
                String str = String.format(format, Float.valueOf(state.intMaxTemperature * 0.001f));
                paint.getTextBounds(str, 0, str.length(), rect);
                int cx = rect.width();
                int cy = rect.height();
                int x = coor[0] + pad;
                int y = coor[1] + cy + pad;
                if (x > width - cx) {
                    x = (coor[0] - pad) - cx;
                }
                if (y > height) {
                    y = (coor[1] - pad) - cy;
                }
                canvas.drawText(str, x + dx, y + dy, paint);
            }
            if ((traceType == 1 || traceType == 2) && (coor2 = DeviceController.clientXY2ScreenXY(state.intMinX, state.intMinY, width, height)) != null) {
                canvas.drawBitmap(minTrace, (coor2[0] - (minTrace.getWidth() / 2)) + dx, (coor2[1] - (minTrace.getHeight() / 2)) + dy, paint);
                String str2 = String.format(format, Float.valueOf(state.intMinTemperature * 0.001f));
                paint.getTextBounds(str2, 0, str2.length(), rect);
                int cx2 = rect.width();
                int cy2 = rect.height();
                int x2 = coor2[0] + pad;
                int y2 = coor2[1] + cy2 + pad;
                if (x2 > width - cx2) {
                    x2 = (coor2[0] - pad) - cx2;
                }
                if (y2 > height) {
                    y2 = (coor2[1] - pad) - cy2;
                }
                canvas.drawText(str2, x2 + dx, y2 + dy, paint);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void drawImage(Canvas canvas, Paint paint, Paint paintROI, Matrix matrix, int dx, int dy, int width, int height, OSDParam osdParam) {
        Bitmap laserLogo;
        Bitmap crossLogo;
        String str;
        matrix.reset();
        Rect rect = new Rect();
        ThreadLocalParam param = null;
        switch (DeviceController.getPreviewOrientation()) {
            case 0:
                float ratioX = width / this.fpaWidth_;
                float ratioY = height / this.fpaHeight_;
                matrix.postScale(ratioX, ratioY, 0.0f, 0.0f);
                matrix.postTranslate(dx, dy);
                break;
            case 90:
                float ratioX2 = width / this.fpaHeight_;
                float ratioY2 = height / this.fpaWidth_;
                matrix.postRotate(90.0f);
                matrix.postTranslate(this.fpaHeight_ + dx, dy);
                matrix.postScale(ratioX2, ratioY2, dx, dy);
                break;
            case 180:
                float ratioX3 = width / this.fpaWidth_;
                float ratioY3 = height / this.fpaHeight_;
                matrix.postRotate(180.0f, this.fpaWidth_ / 2, this.fpaHeight_ / 2);
                matrix.postTranslate(dx, dy);
                matrix.postScale(ratioX3, ratioY3, dx, dy);
                break;
            case 270:
                float ratioX4 = width / this.fpaHeight_;
                float ratioY4 = height / this.fpaWidth_;
                matrix.postRotate(-90.0f);
                matrix.postTranslate(dx, this.fpaWidth_ + dy);
                matrix.postScale(ratioX4, ratioY4, dx, dy);
                break;
        }
        canvas.setDrawFilter(this.pfd_);
        DeviceController.Lock();
        canvas.drawBitmap(this.bmpIr_, matrix, null);
        try {
            param = (ThreadLocalParam) this.threadLocalParam_.clone();
        } catch (CloneNotSupportedException e) {
        } finally {
            DeviceController.Unlock();
        }
        DeviceController.Unlock();
        MagParameter magParameter = MagApplication.magParameter;
        if (magParameter.isShowCross && (crossLogo = osdParam.getCrossLogo()) != null) {
            canvas.drawBitmap(crossLogo, ((width - crossLogo.getWidth()) / 2) + dx, ((height - crossLogo.getHeight()) / 2) + dy, (Paint) null);
            if (this.isTempStable_) {
                str = String.format("%.1f℃", Float.valueOf(param.centerTemp * 0.001f));
            } else {
                str = String.format("~%.1f℃", Float.valueOf(param.centerTemp * 0.001f));
            }
            paint.getTextBounds(str, 0, str.length(), rect);
            int offset = crossLogo.getWidth() / 6;
            canvas.drawText(str, (width / 2) + dx + offset, (height / 2) + dy + rect.height() + offset, paint);
        }
        if (magParameter.isLaserOn && (laserLogo = osdParam.getLaserLogo()) != null) {
            int laserPos = magParameter.basePara2.laserPos;
            int x = laserPos & 255;
            int y = laserPos >> 16;
            switch (magParameter.imageEX) {
                case 1:
                    x = ((x - (this.fpaWidth_ / 2)) * 2) + (this.fpaWidth_ / 2);
                    y = ((y - (this.fpaHeight_ / 2)) * 2) + (this.fpaHeight_ / 2);
                    break;
                case 2:
                    x = ((x - (this.fpaWidth_ / 2)) * 4) + (this.fpaWidth_ / 2);
                    y = ((y - (this.fpaHeight_ / 2)) * 4) + (this.fpaHeight_ / 2);
                    break;
                case 3:
                    x = ((x - (this.fpaWidth_ / 2)) * 8) + (this.fpaWidth_ / 2);
                    y = ((y - (this.fpaHeight_ / 2)) * 8) + (this.fpaHeight_ / 2);
                    break;
                case 4:
                    x = ((x - (this.fpaWidth_ / 2)) * 16) + (this.fpaWidth_ / 2);
                    y = ((y - (this.fpaHeight_ / 2)) * 16) + (this.fpaHeight_ / 2);
                    break;
            }
            int[] screenCoor = DeviceController.sensorXY2ScreenXY(x, y, width, height);
            if ((magParameter.imageFlip & 1) != 0) {
                screenCoor[0] = (width - 1) - screenCoor[0];
            }
            if ((magParameter.imageFlip & 2) != 0) {
                screenCoor[1] = (height - 1) - screenCoor[1];
            }
            canvas.drawBitmap(laserLogo, (screenCoor[0] - (laserLogo.getWidth() / 2)) + dx, (screenCoor[1] - (laserLogo.getHeight() / 2)) + dy, (Paint) null);
        }
        if (magParameter.maxMinTrace != -1 && magParameter.isTraceMaxMin && param.state != null) {
            drawMaxMin(canvas, paint, param.state, rect, dx, dy, width, height, osdParam);
        }
        if (magParameter.isTraceRoi) {
            drawROIs(canvas, paint, paintROI, rect, dx, dy, width, height, osdParam);
        }
        Bitmap waterMark = osdParam.getWaterMark();
        if (waterMark != null) {
            canvas.drawBitmap(waterMark, ((dx + width) - waterMark.getWidth()) - 8, dy + 8, (Paint) null);
        }
        if (MagApplication.isShowFps && this.frameIndex_ > 20) {
            drawFps(canvas, paint, dx, dy, width, height, UsbCommunication.getReceivedFps(), getShowFps());
        }
    }

    private class ThreadRecording extends Thread {
        private ThreadRecording() {
        }

        @Override // java.lang.Thread, java.lang.Runnable
        public void run() {
            Logging.trace("Enter ThreadRecording.");
            OSDParam osdParam = new OSDParam();
            osdParam.setCrossLogo(R.mipmap.cross_capture);
            osdParam.setWaterMark(R.mipmap.water_mark);
            osdParam.setMinTrace(R.mipmap.min_trace_capture);
            osdParam.setMaxTrace(R.mipmap.max_trace_capture);
            while (!ImageViewer.this.isExitThreadRecording_) {
                synchronized (ImageViewer.this.condRecording_.cond) {
                    while (!ImageViewer.this.condRecording_.notified) {
                        try {
                            ImageViewer.this.condRecording_.cond.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                    ImageViewer.this.condRecording_.notified = false;
                }
                if (ImageViewer.this.isExitThreadRecording_) {
                    break;
                } else if (DeviceController.isRecording()) {
                    ImageViewer.this.drawImage(ImageViewer.this.cachedCanvas_, ImageViewer.this.paintVGA_, ImageViewer.this.paintROIVGA_, ImageViewer.this.matrixVGA_, 0, 0, ImageViewer.this.cachedbmp_.getWidth(), ImageViewer.this.cachedbmp_.getHeight(), osdParam);
                    DeviceController.doRecording(ImageViewer.this.cachedbmp_);
                }
            }
            osdParam.reset();
            Logging.trace("Leave ThreadRecording.");
        }
    }

    private class ThreadRender extends Thread {
        private ThreadRender() {
        }

        @Override // java.lang.Thread, java.lang.Runnable
        public void run() {
            Logging.trace("Enter ThreadRender.");
            OSDParam osdParam = new OSDParam();
            osdParam.setCrossLogo(R.mipmap.cross);
            osdParam.setMinTrace(R.mipmap.min_trace);
            osdParam.setMaxTrace(R.mipmap.max_trace);
            osdParam.setLaserLogo(R.mipmap.laser);
            osdParam.setMovingCrossLogo(R.mipmap.moving_cross);
            int frameIndex = -1;
            long t1 = 0;
            while (!ImageViewer.this.isExitThreadRender_) {
                synchronized (ImageViewer.this.waitCondition_.cond) {
                    while (!ImageViewer.this.waitCondition_.notified) {
                        try {
                            ImageViewer.this.waitCondition_.cond.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                    ImageViewer.this.waitCondition_.notified = false;
                }
                if (ImageViewer.this.isExitThreadRender_) {
                    break;
                }
                if (DeviceController.isOutputDataReady()) {
                    ImageViewer.this.doDraw(osdParam);
                    if (MagApplication.isShowFps) {
                        if (t1 == 0) {
                            t1 = System.currentTimeMillis();
                        } else {
                            long t = System.currentTimeMillis();
                            ImageViewer.lock_.lock();
                            ImageViewer.ticks_[frameIndex % ImageViewer.ticks_.length] = t - t1;
                            ImageViewer.lock_.unlock();
                            t1 = t;
                        }
                    }
                    frameIndex++;
                } else {
                    Logging.trace("draw not ready.");
                }
            }
            osdParam.reset();
            Logging.trace("Leave ThreadRender.");
        }
    }

    private static int getShowFps() {
        long[] ticks = new long[ticks_.length];
        lock_.lock();
        System.arraycopy(ticks_, 0, ticks, 0, ticks_.length);
        lock_.unlock();
        int sum = 0;
        for (int i = ticks.length - 1; i != -1; i--) {
            sum = (int) (sum + ticks[i]);
        }
        return (ticks_.length * 1000) / sum;
    }
}