Android 仅在三星S8设备中获取锁定表面异常

我正在使用下面的类，并得到我粘贴在问题底部的错误。我在谷歌上搜索过很多次，很多人都有同样的问题，但这里的区别是，我只在三星S8（安卓V7.0）上发现了这个问题，而没有在任何其他版本的设备上发现。我怎样才能解决这个问题

类别：

public class ScratchView extends SurfaceView implements ScratchMethods, SurfaceHolder.Callback {
    // default value constants
    private final int DEFAULT_COLOR = 0xff444444; // default color is dark gray
    List<Path> mPathList = new ArrayList<Path>();
    private Context mContext;
    private WScratchViewThread mThread;
    private int mOverlayColor;
    private Paint mOverlayPaint;
    private boolean mIsScratchable = true;
    private boolean mIsAntiAlias = false;
    private Path path;
    private float startX = 0;
    private float startY = 0;
    private float startX_old = 0;
    private float startY_old = 0;
    private boolean mScratchStart = false;
    private boolean firstTouch = false;
    private boolean secondTouch = false;
    private float Y4suit = 0;

    private float X4value = 0;
    private float Y4value = 0;
    private float mScreenHeight = 0;
    private float mScreenWidth = 0;
    private int sizeFINGER;

    public ScratchView(Context ctx, AttributeSet attrs) {
        super(ctx, attrs);
        init(ctx, attrs);
    }

    public ScratchView(Context context) {
        super(context);
        init(context, null);
    }

    private void init(Context context, AttributeSet attrs) {
        mContext = context;

        // default value
        mOverlayColor = DEFAULT_COLOR;


        sizeFINGER = MagicTrickSharedPreference.getInstance(context).getScratchValue() + Constants.DEFAULT_SCRATCH_ADDITION;

        TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.WScratchView, 0, 0);


        final int indexCount = ta.getIndexCount();
        for (int i = 0; i < indexCount; i++) {
            int attr = ta.getIndex(i);
            switch (attr) {
                case R.styleable.WScratchView_overlayColor:
                    mOverlayColor = ta.getColor(attr, DEFAULT_COLOR);
                    break;
                case R.styleable.WScratchView_revealSize:
                    //sizeFINGER = ta.getDimensionPixelSize(attr, 50);
                    break;
                case R.styleable.WScratchView_antiAlias:
                    mIsAntiAlias = ta.getBoolean(attr, false);
                    break;
                case R.styleable.WScratchView_scratchable:
                    mIsScratchable = ta.getBoolean(attr, true);
                    break;
            }
        }

        setZOrderOnTop(true);
        SurfaceHolder holder = getHolder();
        holder.addCallback(this);
        holder.setFormat(PixelFormat.TRANSPARENT);


        mOverlayPaint = new Paint();
        mOverlayPaint.setXfermode(new PorterDuffXfermode(Mode.CLEAR));
        mOverlayPaint.setStyle(Paint.Style.STROKE);
        mOverlayPaint.setStrokeCap(Paint.Cap.ROUND);
        mOverlayPaint.setStrokeJoin(Paint.Join.ROUND);

        DisplayMetrics dm = getResources().getDisplayMetrics();
        mScreenHeight = dm.heightPixels;
        mScreenWidth = dm.widthPixels;

    }


    @Override
    public void onDraw(Canvas canvas) {

        canvas.drawColor(mOverlayColor);

        //Bitmap icon = BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher);
        //canvas.drawBitmap(icon, 100, 100, new Paint());

        for (Path path : mPathList) {
            mOverlayPaint.setAntiAlias(mIsAntiAlias);
            mOverlayPaint.setStrokeWidth(sizeFINGER);


            canvas.drawPath(path, mOverlayPaint);
        }

        //icon.recycle();
        //System.gc();


    }


    @Override
    public boolean onTouchEvent(MotionEvent me) {
        synchronized (mThread.getSurfaceHolder()) {
            if (!mIsScratchable) {
                return true;
            }


            switch (me.getAction()) {
                case MotionEvent.ACTION_DOWN:


                    path = new Path();
                    path.moveTo(me.getX(), me.getY());
                    startX = me.getX();
                    startY = me.getY();
                    startX_old = me.getX();
                    startY_old = me.getY();
                    mPathList.add(path);


                    break;
                case MotionEvent.ACTION_MOVE:

                    if (mScratchStart) {

                        if (isScratch(startX_old, me.getX(), startY_old, me.getY())) {
                            startX_old = me.getX();
                            startY_old = me.getY();
                            path.lineTo(me.getX(), me.getY());
                        }
                    } else {
                        if (isScratch(startX, me.getX(), startY, me.getY())) {
                            mScratchStart = true;

                            path.lineTo(me.getX(), me.getY());
                        }
                    }

                    break;
                case MotionEvent.ACTION_UP:

                    mScratchStart = false;

                    break;
            }
            return true;
        }
    }

    private boolean isScratch(float oldX, float x, float oldY, float y) {

        float distance = (float) Math.sqrt(Math.pow(oldX - x, 2) + Math.pow(oldY - y, 2));

        if (distance > 20) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
        // do nothing
    }

    @Override
    public void surfaceCreated(SurfaceHolder arg0) {
        mThread = new WScratchViewThread(getHolder(), this);
        mThread.setRunning(true);
        mThread.start();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder arg0) {
        boolean retry = true;
        mThread.setRunning(false);
        while (retry) {
            try {
                mThread.join();
                retry = false;
            } catch (InterruptedException e) {
                // do nothing but keep retry
            }
        }

    }

    @Override
    public void resetView() {
        synchronized (mThread.getSurfaceHolder()) {
            firstTouch = false;
            secondTouch = false;
            mPathList.clear();
        }
    }

    @Override
    public boolean isScratchable() {
        return mIsScratchable;
    }

    @Override
    public void setScratchable(boolean flag) {
        mIsScratchable = flag;
    }

    @Override
    public void setOverlayColor(int ResId) {
        mOverlayColor = ResId;
    }

    @Override
    public void setRevealSize(int size) {
        sizeFINGER = size;
    }

    @Override
    public void setAntiAlias(boolean flag) {
        mIsAntiAlias = flag;
    }

    class WScratchViewThread extends Thread {
        private SurfaceHolder mSurfaceHolder;
        private ScratchView mView;
        private boolean mRun = false;


        public WScratchViewThread(SurfaceHolder surfaceHolder, ScratchView view) {
            mSurfaceHolder = surfaceHolder;
            mView = view;
        }

        public void setRunning(boolean run) {
            mRun = run;
        }

        public SurfaceHolder getSurfaceHolder() {
            return mSurfaceHolder;
        }


        public void run() {


            Canvas c;

            while (mRun) {
                c = null;
                try {
                    //c = mSurfaceHolder.lockCanvas(null);
                    c = mSurfaceHolder.lockCanvas();
                    synchronized (mSurfaceHolder) {
                        if (c != null) {

                            mView.draw(c);
                        }
                    }
                } finally {
                    if (c != null) {
                        mSurfaceHolder.unlockCanvasAndPost(c);
                    }
                }    
            }


        }
    }

}

public类ScratchView扩展了SurfaceView实现了ScratchMethods，SurfaceHolder.Callback{
//默认值常量
private final int DEFAULT_COLOR=0xff444444；//默认颜色为深灰色
List mPathList=new ArrayList（）；
私有上下文；
私有WScratchViewThread mThread；
私有int mOverlayColor；
私人油漆厂；
私有布尔值miscratchable=true；
私有布尔值mIsAntiAlias=false；
专用路径；
专用浮点数startX=0；
私人浮动起始值=0；
专用浮点数startX_old=0；
私人浮动开始时间=0；
private boolean mscartchstart=false；
私有布尔值firstTouch=false；
私有布尔值secondTouch=false；
私人浮动Y4suit=0；
私有浮点值=0；
私有浮动Y4value=0；
私有浮动mScreenHeight=0；
私有浮点mScreenWidth=0；
私人互联网用户；
公共ScratchView（上下文ctx、属性集属性）{
超级（ctx、ATTR）；
初始（ctx，ATTR）；
}
公共ScratchView（上下文）{
超级（上下文）；
init（上下文，null）；
}
私有void init（上下文上下文、属性集属性）{
mContext=上下文；
//默认值
mOverlayColor=默认颜色；
sizeFINGER=MagicTrickSharedPreference.getInstance（context）.getScratchValue（）+常量.DEFAULT\u SCRATCH\u ADDITION；
TypedArray ta=context.ActainStyledAttributes（attrs，R.styleable.WScratchView，0,0）；
final int indexCount=ta.getIndexCount（）；
对于（int i=0；i20）{
返回true；
}否则{
返回false；
}
}
@凌驾
公共无效表面更改（表面更改arg0、int arg1、int arg2、int arg3）{
//无所事事
}
@凌驾
已创建公共空白表面（表面文件夹arg0）{
mThread=newwscratchviewthread（getHolder（），this）；
mThread.setRunning（true）；
mThread.start（）；
}
@凌驾
公共空间表面已覆盖（表面层arg0）{
布尔重试=真；
mThread.setRunning（false）；
while（重试）