[6.2.0][360环视] 修正线上崩溃

core/function-impl/mogo-core-function-hmi/src/main/java/com/mogo/eagle/core/function/hmi/ui/lookaround/M1LookAroundView.kt

@@ -95,7 +95,6 @@ class M1LookAroundView: SurfaceView, SurfaceHolder.Callback, Runnable, IMoGoChas
             handler.set(HandlerThread("look-around-drawer").let { it.start(); Handler(it.looper) })
         }
         handler.get()?.removeCallbacks(this)
-        handler.get()?.post(this)
         isSurfaceValid = true
     }
 
@@ -109,187 +108,171 @@ class M1LookAroundView: SurfaceView, SurfaceHolder.Callback, Runnable, IMoGoChas
     }
 
     override fun run() {
-        var isTimedBlock = false
+        if (!isSurfaceValid) {
+            return
+        }
+        if (this.surfaceWidth <= 0 || this.surfaceHeight <= 0) {
+            return
+        }
+        val data = this.data ?: return
+        val targetX = data.targetX
+        val targetY = data.targetY
+        val targetWidth = data.targetWidth
+        val targetHeight = data.targetHeight
+        val bitmapWidth = data.bitmapWidth
+        val bitmapHeight = data.bitmapHeight
+        val scaleX = this.surfaceWidth * 1.0f / bitmapWidth
+        val scaleY = this.surfaceHeight * 1.0f / bitmapHeight
+        val bytes = data.data ?: return
+        val canvas = holder.lockCanvas()
         try {
-            if (!isSurfaceValid) {
-                isTimedBlock = true
+            if (canvas == null) {
                 return
             }
-            if (this.surfaceWidth <= 0 || this.surfaceHeight <= 0) {
-                isTimedBlock = true
-                return
-            }
-            val data = this.data ?: return
-            val targetX = data.targetX
-            val targetY = data.targetY
-            val targetWidth = data.targetWidth
-            val targetHeight = data.targetHeight
-            val bitmapWidth = data.bitmapWidth
-            val bitmapHeight = data.bitmapHeight
-            val scaleX = this.surfaceWidth * 1.0f / bitmapWidth
-            val scaleY = this.surfaceHeight * 1.0f / bitmapHeight
-            val bytes = data.data
-            if (bytes == null) {
-                isTimedBlock = true
-                return
-            }
-            val canvas = holder.lockCanvas()
+            //1. 绘制图片
+            val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return
             try {
-                if (canvas == null) {
-                    isTimedBlock = true
-                    return
+                canvas.save()
+                canvas.scale(scaleX, scaleY)
+                canvas.drawBitmap(bitmap, 0f, 0f, bitmapPaint)
+            } finally {
+                canvas.restore()
+                if (!bitmap.isRecycled) {
+                    bitmap.recycle()
                 }
-                //1. 绘制图片
-                val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
-                if (bitmap == null) {
-                    isTimedBlock = true
-                    return
+            }
+            //2. 绘制车的信息
+            val newTargetX = targetX * scaleX
+            val newTargetY = targetY * scaleY
+            val newTargetWidth = targetWidth * scaleX
+            val newTargetHeight = targetHeight * scaleY
+            try {
+                //2.1 绘制车前的转向角
+                canvas.save()
+                var steering = this.steering
+                if (abs(steering) < 1) {
+                    steering = 0f
                 }
-                try {
-                    canvas.save()
-                    canvas.scale(scaleX, scaleY)
-                    canvas.drawBitmap(bitmap, 0f, 0f, bitmapPaint)
-                } finally {
-                    canvas.restore()
-                    if (!bitmap.isRecycled) {
-                        bitmap.recycle()
-                    }
-                }
-                //2. 绘制车的信息
-                val newTargetX = targetX * scaleX
-                val newTargetY = targetY * scaleY
-                val newTargetWidth = targetWidth * scaleX
-                val newTargetHeight = targetHeight * scaleY
-                try {
-                    //2.1 绘制车前的转向角
-                    canvas.save()
-                    var steering = this.steering
-                    if (abs(steering) < 1) {
-                       steering = 0f
-                    }
-                    if (steering == 0f) {
-                        canvas.translate(newTargetX + newTargetWidth * 0.5f, newTargetY)
-                        routerPath.reset()
-                        val halfX = newTargetWidth * 0.5f
-                        var startX = - halfX
-                        val startY= 0f
-                        routerPath.moveTo(startX, startY)
-                        var endX = startX
-                        val endY = - newTargetY
-                        routerPath.lineTo(endX, endY)
-                        canvas.drawPath(routerPath, routerPaint)
-                        startX += newTargetWidth
-                        endX += newTargetWidth
-                        routerPath.reset()
-                        routerPath.moveTo(startX, startY)
-                        routerPath.lineTo(endX, endY)
-                        canvas.drawPath(routerPath, routerPaint)
-                    } else {
-                        val outerAngle = abs(steering * 1.0 / VEHICLE_STEERING_RATIO)
-                        val radians = Math.toRadians(outerAngle)
-                        val d = (newTargetHeight / tan(radians)).toFloat()
-                        if (steering > 0) {
-                            // 左打轮
-                            // 将坐标原点平移到圆心
-                            canvas.translate(newTargetX - (d - newTargetWidth), newTargetY + newTargetHeight)
-                            //外圆半径
-                            val outerR = (newTargetHeight / sin(radians)).toFloat()
-                            //内圆半径
-                            val innerR = sqrt((newTargetHeight * 1.0).pow(2.0) + ((d - newTargetWidth) * 1.0).pow(2.0)).toFloat()
-                            val innerAngle = Math.toDegrees(asin(newTargetHeight / innerR) * 1.0)
-                            outerRect.set(-outerR, -outerR, outerR, outerR)
-                            innerRect.set(-innerR, -innerR, innerR, innerR)
-                            canvas.drawArc(outerRect, -outerAngle.toFloat(), -60f, false, routerPaint)
-                            canvas.drawArc(innerRect, -innerAngle.toFloat(), -60f, false, routerPaint)
-                        }
-
-                        if (steering < 0) {
-                            //右打轮
-                            // 将坐标原点平移到圆心
-                            canvas.translate(newTargetX + d, newTargetY + newTargetHeight)
-                            //外圆半径
-                            val outerR = (newTargetHeight / sin(radians)).toFloat()
-                            //内圆半径
-                            val innerR = sqrt((newTargetHeight * 1.0).pow(2.0) + ((d - newTargetWidth) * 1.0).pow(2.0)).toFloat()
-                            val innerAngle = Math.toDegrees(asin(newTargetHeight / innerR) * 1.0)
-                            outerRect.set(-outerR, -outerR, outerR, outerR)
-                            innerRect.set(-innerR, -innerR, innerR, innerR)
-                            canvas.drawArc(outerRect, 180f + outerAngle.toFloat(), 60f, false, routerPaint)
-                            canvas.drawArc(innerRect, 180f + innerAngle.toFloat(), 60f, false, routerPaint)
-                        }
-                    }
-                } finally {
-                    canvas.restore()
-                }
-
-                try {
-                    //2.2 绘制车周围盲区标定
-                    canvas.save()
+                if (steering == 0f) {
                     canvas.translate(newTargetX + newTargetWidth * 0.5f, newTargetY)
-                    val halfTargetWidth = newTargetWidth * 0.5f
-                    var startX = -halfTargetWidth
-                    var startY = BROKE_LINE_LENGTH
+                    routerPath.reset()
+                    val halfX = newTargetWidth * 0.5f
+                    var startX = - halfX
+                    val startY= 0f
+                    routerPath.moveTo(startX, startY)
                     var endX = startX
-                    var endY = 0f
-                    // 绘制左上角
-                    brokePath.reset()
-                    brokePath.moveTo(startX, startY)
-                    brokePath.lineTo(endX, endY)
-                    endX += BROKE_LINE_LENGTH
-                    brokePath.lineTo(endX, endY)
-                    canvas.drawPath(brokePath, brokePaint)
+                    val endY = - newTargetY
+                    routerPath.lineTo(endX, endY)
+                    canvas.drawPath(routerPath, routerPaint)
+                    startX += newTargetWidth
+                    endX += newTargetWidth
+                    routerPath.reset()
+                    routerPath.moveTo(startX, startY)
+                    routerPath.lineTo(endX, endY)
+                    canvas.drawPath(routerPath, routerPaint)
+                } else {
+                    val outerAngle = abs(steering * 1.0 / VEHICLE_STEERING_RATIO)
+                    val radians = Math.toRadians(outerAngle)
+                    val d = (newTargetHeight / tan(radians)).toFloat()
+                    if (steering > 0) {
+                        // 左打轮
+                        // 将坐标原点平移到圆心
+                        canvas.translate(newTargetX - (d - newTargetWidth), newTargetY + newTargetHeight)
+                        //外圆半径
+                        val outerR = (newTargetHeight / sin(radians)).toFloat()
+                        //内圆半径
+                        val innerR = sqrt((newTargetHeight * 1.0).pow(2.0) + ((d - newTargetWidth) * 1.0).pow(2.0)).toFloat()
+                        val innerAngle = Math.toDegrees(asin(newTargetHeight / innerR) * 1.0)
+                        outerRect.set(-outerR, -outerR, outerR, outerR)
+                        innerRect.set(-innerR, -innerR, innerR, innerR)
+                        canvas.drawArc(outerRect, -outerAngle.toFloat(), -60f, false, routerPaint)
+                        canvas.drawArc(innerRect, -innerAngle.toFloat(), -60f, false, routerPaint)
+                    }
 
-                    // 绘制右上角
-                    startX = halfTargetWidth - BROKE_LINE_LENGTH
-                    startY = 0f
-
-                    endX = halfTargetWidth
-                    endY = 0f
-                    brokePath.reset()
-                    brokePath.moveTo(startX, startY)
-                    brokePath.lineTo(endX, endY)
-                    endY += BROKE_LINE_LENGTH
-                    brokePath.lineTo(endX, endY)
-                    canvas.drawPath(brokePath, brokePaint)
-
-                    //绘制左下角
-                    startX = -halfTargetWidth
-                    startY = newTargetHeight - BROKE_LINE_LENGTH
-                    endX = startX
-                    endY = newTargetHeight
-                    brokePath.reset()
-                    brokePath.moveTo(startX, startY)
-                    brokePath.lineTo(endX, endY)
-                    endX += BROKE_LINE_LENGTH
-                    brokePath.lineTo(endX, endY)
-                    canvas.drawPath(brokePath, brokePaint)
-
-                    //绘制右下角
-                    startX = halfTargetWidth - BROKE_LINE_LENGTH
-                    startY = newTargetHeight
-                    endX = halfTargetWidth
-                    endY = startY
-                    brokePath.reset()
-                    brokePath.moveTo(startX, startY)
-                    brokePath.lineTo(endX, endY)
-                    endY -= BROKE_LINE_LENGTH
-                    brokePath.lineTo(endX, endY)
-                    canvas.drawPath(brokePath, brokePaint)
-                } finally {
-                    canvas.restore()
+                    if (steering < 0) {
+                        //右打轮
+                        // 将坐标原点平移到圆心
+                        canvas.translate(newTargetX + d, newTargetY + newTargetHeight)
+                        //外圆半径
+                        val outerR = (newTargetHeight / sin(radians)).toFloat()
+                        //内圆半径
+                        val innerR = sqrt((newTargetHeight * 1.0).pow(2.0) + ((d - newTargetWidth) * 1.0).pow(2.0)).toFloat()
+                        val innerAngle = Math.toDegrees(asin(newTargetHeight / innerR) * 1.0)
+                        outerRect.set(-outerR, -outerR, outerR, outerR)
+                        innerRect.set(-innerR, -innerR, innerR, innerR)
+                        canvas.drawArc(outerRect, 180f + outerAngle.toFloat(), 60f, false, routerPaint)
+                        canvas.drawArc(innerRect, 180f + innerAngle.toFloat(), 60f, false, routerPaint)
+                    }
                 }
             } finally {
-                if (canvas != null) {
-                    holder.unlockCanvasAndPost(canvas)
-                }
+                canvas.restore()
+            }
+
+            try {
+                //2.2 绘制车周围盲区标定
+                canvas.save()
+                canvas.translate(newTargetX + newTargetWidth * 0.5f, newTargetY)
+                val halfTargetWidth = newTargetWidth * 0.5f
+                var startX = -halfTargetWidth
+                var startY = BROKE_LINE_LENGTH
+                var endX = startX
+                var endY = 0f
+                // 绘制左上角
+                brokePath.reset()
+                brokePath.moveTo(startX, startY)
+                brokePath.lineTo(endX, endY)
+                endX += BROKE_LINE_LENGTH
+                brokePath.lineTo(endX, endY)
+                canvas.drawPath(brokePath, brokePaint)
+
+                // 绘制右上角
+                startX = halfTargetWidth - BROKE_LINE_LENGTH
+                startY = 0f
+
+                endX = halfTargetWidth
+                endY = 0f
+                brokePath.reset()
+                brokePath.moveTo(startX, startY)
+                brokePath.lineTo(endX, endY)
+                endY += BROKE_LINE_LENGTH
+                brokePath.lineTo(endX, endY)
+                canvas.drawPath(brokePath, brokePaint)
+
+                //绘制左下角
+                startX = -halfTargetWidth
+                startY = newTargetHeight - BROKE_LINE_LENGTH
+                endX = startX
+                endY = newTargetHeight
+                brokePath.reset()
+                brokePath.moveTo(startX, startY)
+                brokePath.lineTo(endX, endY)
+                endX += BROKE_LINE_LENGTH
+                brokePath.lineTo(endX, endY)
+                canvas.drawPath(brokePath, brokePaint)
+
+                //绘制右下角
+                startX = halfTargetWidth - BROKE_LINE_LENGTH
+                startY = newTargetHeight
+                endX = halfTargetWidth
+                endY = startY
+                brokePath.reset()
+                brokePath.moveTo(startX, startY)
+                brokePath.lineTo(endX, endY)
+                endY -= BROKE_LINE_LENGTH
+                brokePath.lineTo(endX, endY)
+                canvas.drawPath(brokePath, brokePaint)
+            } finally {
+                canvas.restore()
             }
         } finally {
-            if (isTimedBlock) {
-                try {
-                    Thread.sleep(2000)
-                } catch (ignore: Exception) { }
+            try {
+                if (canvas != null && holder.surface.isValid) {
+                    holder.unlockCanvasAndPost(canvas)
+                }
+                isSurfaceValid = holder.surface.isValid
+            } catch (t: Throwable) {
+                t.printStackTrace()
             }
-            handler.get().post(this)
         }
     }
 
@@ -304,6 +287,8 @@ class M1LookAroundView: SurfaceView, SurfaceHolder.Callback, Runnable, IMoGoChas
                     Log.d(TAG, "-- onEach ---:$it")
                     if (it.isValid()) {
                         data = it
+                        handler.get()?.removeCallbacks(this@M1LookAroundView)
+                        handler.get()?.post(this@M1LookAroundView)
                     }
                 }.collect()
             }