[原创] Tslib Manual Calibrate On Android ——android 电阻屏幕触摸屏校准方法探讨

* Copyright (C) 2007 The Android Open Source Project

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package com.android.server;

import android.util.Log;

import android.view.Display;

import android.view.MotionEvent;

import android.view.Surface;

import android.view.WindowManagerPolicy;

import java.io.FileInputStream;

import java.util.StringTokenizer;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import android.os.SystemProperties;

public class InputDevice {

    /** Amount that trackball needs to move in order to generate a key event. */

    static final int TRACKBALL_MOVEMENT_THRESHOLD = 6;

    //once edit

    static final String CALIBRATION_FILE = "/data/etc/pointercal";

    //edit ends

    final int id;

    final int classes;

    final String name;

    final AbsoluteInfo absX;

    final AbsoluteInfo absY;

    final AbsoluteInfo absPressure;

    final AbsoluteInfo absSize;

       //once edit

    static TransformInfo tInfo;

    //edit ends

    long mDownTime = 0;

    int mMetaKeysState = 0;

    static File desFile;   

    final MotionState mAbs = new MotionState(0, 0);

    final MotionState mRel = new MotionState(TRACKBALL_MOVEMENT_THRESHOLD,

            TRACKBALL_MOVEMENT_THRESHOLD);

    static class MotionState {

        int xPrecision;

        int yPrecision;

        float xMoveScale;

        float yMoveScale;

        MotionEvent currentMove = null;

        boolean changed = false;

        boolean down = false;

        boolean lastDown = false;

        long downTime = 0;

        int x = 0;

        int y = 0;

        int pressure = 1;

        int size = 0;

        MotionState(int mx, int my) {

            xPrecision = mx;

            yPrecision = my;

            xMoveScale = mx != 0 ? (1.0f/mx) : 1.0f;

            yMoveScale = my != 0 ? (1.0f/my) : 1.0f;

        }

        MotionEvent generateMotion(InputDevice device, long curTime,

                boolean isAbs, Display display, int orientation,

                int metaState) {

            if (!changed) {

                return null;

            }

           //once edit

        //String prop = System.getProperty("ts.config.calibrate", "noset");

        String prop = SystemProperties.get("ts.config.calibrate", "noset");

        if (prop.equalsIgnoreCase("start")){

            Log.i("XXW prop", prop);

            Log.i("XXW", "prop.equalsIgnoreCase start");

            device.tInfo = null;

        }else if (prop.equalsIgnoreCase("done")){

            Log.i("XXW prop", prop);

            Log.i("XXW", "prop.equalsIgnoreCase done");

            readCalibrate();

            SystemProperties.set("ts.config.calibrate", "end");

        }else{

            Log.i("XXW prop", prop);

            Log.i("XXW", "prop.equalsIgnoreCase else");

        }

        //edit ends

            float scaledX = x;

            float scaledY = y;

            float temp;

            float scaledPressure = 1.0f;

            float scaledSize = 0;

            int edgeFlags = 0;

            if (isAbs) {

                int w = display.getWidth()-1;

                int h = display.getHeight()-1;

                if (orientation == Surface.ROTATION_90

                        || orientation == Surface.ROTATION_270) {

                    int tmp = w;

                    w = h;

                    h = tmp;

                }

                if (device.absX != null) {

                      //once edit

                    if (device.tInfo != null){

                        scaledX = (device.tInfo.x1 * x + device.tInfo.y1 * y + device.tInfo.z1)/ device.tInfo.s;

                     Log.i("XXW","x: "+x);

                     Log.i("XXW","trans x: "+scaledX);

                    }

                    else

                    //edit ends

                      scaledX = ((scaledX-device.absX.minValue)

                                / device.absX.range) * w;

                }

                if (device.absY != null) {

                    //once edit

                    if (device.tInfo != null){

                        scaledY = (device.tInfo.x2 * x + device.tInfo.y2 * y + device.tInfo.z2) / device.tInfo.s;

                    Log.i("XXW","y: "+y);

                    Log.i("XXW","trans y: "+scaledY);

                    }

                    else

                    //edit ends

                       scaledY = ((scaledY-device.absY.minValue)

                                / device.absY.range) * h;

                }

                if (device.absPressure != null) {

                    scaledPressure =

                        ((pressure-device.absPressure.minValue)

                                / (float)device.absPressure.range);

                }

                if (device.absSize != null) {

                    scaledSize =

                        ((size-device.absSize.minValue)

                                / (float)device.absSize.range);

                }

                switch (orientation) {

                    case Surface.ROTATION_90:

                        temp = scaledX;

                        scaledX = scaledY;

                        scaledY = w-temp;

                        break;

                    case Surface.ROTATION_180:

                        scaledX = w-scaledX;

                        scaledY = h-scaledY;

                        break;

                    case Surface.ROTATION_270:

                        temp = scaledX;

                        scaledX = h-scaledY;

                        scaledY = temp;

                        break;

                }

                if (scaledX == 0) {

                    edgeFlags += MotionEvent.EDGE_LEFT;

                } else if (scaledX == display.getWidth() - 1.0f) {

                    edgeFlags += MotionEvent.EDGE_RIGHT;

                }

                if (scaledY == 0) {

                    edgeFlags += MotionEvent.EDGE_TOP;

                } else if (scaledY == display.getHeight() - 1.0f) {

                    edgeFlags += MotionEvent.EDGE_BOTTOM;

                }

            } else {

                scaledX *= xMoveScale;

                scaledY *= yMoveScale;

                switch (orientation) {

                    case Surface.ROTATION_90:

                        temp = scaledX;

                        scaledX = scaledY;

                        scaledY = -temp;

                        break;

                    case Surface.ROTATION_180:

                        scaledX = -scaledX;

                        scaledY = -scaledY;

                        break;

                    case Surface.ROTATION_270:

                        temp = scaledX;

                        scaledX = -scaledY;

                        scaledY = temp;

                        break;

                }

            }

            changed = false;

            if (down != lastDown) {

                int action;

                lastDown = down;

                if (down) {

                    action = MotionEvent.ACTION_DOWN;

                    downTime = curTime;

                } else {

                    action = MotionEvent.ACTION_UP;

                }

                currentMove = null;

                if (!isAbs) {

                    x = y = 0;

                }

                return MotionEvent.obtain(downTime, curTime, action,

                        scaledX, scaledY, scaledPressure, scaledSize, metaState,

                        xPrecision, yPrecision, device.id, edgeFlags);

            } else {

                if (currentMove != null) {

                    if (false) Log.i("InputDevice", "Adding batch x=" + scaledX

                            + " y=" + scaledY + " to " + currentMove);

                    currentMove.addBatch(curTime, scaledX, scaledY,

                            scaledPressure, scaledSize, metaState);

                    if (WindowManagerPolicy.WATCH_POINTER) {

                        Log.i("KeyInputQueue", "Updating: " + currentMove);

                    }

                    return null;

                }

                MotionEvent me = MotionEvent.obtain(downTime, curTime,

                        MotionEvent.ACTION_MOVE, scaledX, scaledY,

                        scaledPressure, scaledSize, metaState,

                        xPrecision, yPrecision, device.id, edgeFlags);

                currentMove = me;

                return me;

            }

        }

    }

    static class AbsoluteInfo {

        int minValue;

        int maxValue;

        int range;

        int flat;

        int fuzz;

    };

       //once edit

    static class TransformInfo {

       float x1;

       float y1;

       float z1;

       float x2;

       float y2;

       float z2;

       float s;

    };

    //edit ends

    InputDevice(int _id, int _classes, String _name,

            AbsoluteInfo _absX, AbsoluteInfo _absY,

            AbsoluteInfo _absPressure, AbsoluteInfo _absSize) {

        id = _id;

        classes = _classes;

        name = _name;

        absX = _absX;

        absY = _absY;

        absPressure = _absPressure;

        absSize = _absSize;

        //once edit

        desFile = new File(CALIBRATION_FILE);

        readCalibrate();

        //edit ends

    }

    static void readCalibrate(){

        //xxw added

        Log.i("XXW","readCalibrate!");

        TransformInfo t = null;

        try {

            FileInputStream is = new FileInputStream(CALIBRATION_FILE);

            byte[] mBuffer = new byte[64];

            int len = is.read(mBuffer);

            is.close();

            if (len > 0) {

                int i;

                for (i = 0 ; i < len ; i++) {

                    if (mBuffer == '\n' || mBuffer == 0) {

                        break;

                    }

                }

                len = i;

            }

package com.android.calibrate;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import android.util.Log;

public class Calibrate {

    private calibration cal;

    public Calibrate() {

        cal = new calibration();

    }

    class calibration {

        int x[] = new int[5];

        int xfb[] = new int[5];

        int y[] = new int[5];

        int yfb[] = new int[5];

        int a[] = new int[7];

    };

    boolean perform_calibration() {

        Log.i("XXW", "perform_calibration");

        int j;

        float n, x, y, x2, y2, xy, z, zx, zy;

        float det, a, b, c, e, f, i;

        float scaling = (float)65536.0;

        // Get sums for matrix

        n = x = y = x2 = y2 = xy = 0;

        for (j = 0; j < 5; j++) {

            n += 1.0;

            x += (float)cal.x[j];

            y += (float)cal.y[j];

            x2 += (float)(cal.x[j] * cal.x[j]);

            y2 += (float)(cal.y[j] * cal.y[j]);

            xy += (float)(cal.x[j] * cal.y[j]);

        }

        // Get determinant of matrix -- check if determinant is too small

        det = n * (x2 * y2 - xy * xy) + x * (xy * y - x * y2) + y * (x * xy - y * x2);

        if (det < 0.1 && det > -0.1) {

            Log.i("ts_calibrate: determinant is too small -- %f\n", "" + det);

            return false;

        }

        // Get elements of inverse matrix

        a = (x2 * y2 - xy * xy) / det;

        b = (xy * y - x * y2) / det;

        c = (x * xy - y * x2) / det;

        e = (n * y2 - y * y) / det;

        f = (x * y - n * xy) / det;

        i = (n * x2 - x * x) / det;

        // Get sums for x calibration

        z = zx = zy = 0;

        for (j = 0; j < 5; j++) {

            z += (float)cal.xfb[j];

            zx += (float)(cal.xfb[j] * cal.x[j]);

            zy += (float)(cal.xfb[j] * cal.y[j]);

        }

        // Now multiply out to get the calibration for framebuffer x coord

        cal.a[0] = (int)((a * z + b * zx + c * zy) * (scaling));

        cal.a[1] = (int)((b * z + e * zx + f * zy) * (scaling));

        cal.a[2] = (int)((c * z + f * zx + i * zy) * (scaling));

        System.out.printf("%f %f %f\n", (a * z + b * zx + c * zy), (b * z + e * zx + f * zy), (c

                * z + f * zx + i * zy));

        // Get sums for y calibration

        z = zx = zy = 0;

        for (j = 0; j < 5; j++) {

            z += (float)cal.yfb[j];

            zx += (float)(cal.yfb[j] * cal.x[j]);

            zy += (float)(cal.yfb[j] * cal.y[j]);

        }

        // Now multiply out to get the calibration for framebuffer y coord

        cal.a[3] = (int)((a * z + b * zx + c * zy) * (scaling));

        cal.a[4] = (int)((b * z + e * zx + f * zy) * (scaling));

        cal.a[5] = (int)((c * z + f * zx + i * zy) * (scaling));

        System.out.printf("%f %f %f\n", (a * z + b * zx + c * zy), (b * z + e * zx + f * zy), (c

                * z + f * zx + i * zy));

        // If we got here, we're OK, so assign scaling to a[6] and return

        cal.a[6] = (int)scaling;

        return true;

        /*

         * // This code was here originally to just insert default values

         * for(j=0;j<7;j++) { c->a[j]=0; } c->a[1] = c->a[5] = c->a[6] = 1;

         * return 1;

         */

    }

    void get_sample(int index, int x1, int y1, int x, int y) {

        Log.i("XXW", "get_sample");

        cal.x[index] = x1;

        cal.y[index] = y1;

        cal.xfb[index] = x;

        cal.yfb[index] = y;

    }

    int calibrate_main() {

        int result = 0;

        Log.i("XXW", "calibrate_main");

        if (perform_calibration()) {

            String strPara = String.format("%d %d %d %d %d %d %d", cal.a[1], cal.a[2], cal.a[0],

                    cal.a[4], cal.a[5], cal.a[3], cal.a[6]);

            boolean success = new File("/data/etc").mkdir();

            if (!success) {

                Log.i(this.toString(), "no success");

            }

            File desFile = new File("/data/etc/pointercal");

            if (!desFile.exists())

                try {

                    desFile.createNewFile();

                } catch (IOException e1) {

                    e1.printStackTrace();

                }

            FileOutputStream fos;

            try {

                fos = new FileOutputStream(desFile);

                byte[] buf = strPara.getBytes();

                int bytesRead = buf.length;

                try {

                    fos.write(buf, 0, bytesRead);

                    fos.flush();

                    fos.close();

                } catch (IOException e) {                  

                    e.printStackTrace();

                }

            } catch (FileNotFoundException e) {            

                e.printStackTrace();

            }

            result = 0;

        } else {

            result = -1;

        }

        return result;

    }

}

package com.android.calibrate;

import com.android.calibrate.R;

import android.app.Activity;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Paint;

import android.os.Bundle;

import android.util.Log;

import android.view.MotionEvent;

import android.view.View;

import android.view.Window;

import android.view.WindowManager;

import android.view.View.OnTouchListener;

import android.widget.Toast;

import android.os.SystemProperties;

public class AndroidCalibrate extends Activity {

    final String TAG = "ScreenCalibration";

    final int UI_SCREEN_WIDTH = 800;

    final int UI_SCREEN_HEIGHT = 480;

    CrossView myview;

    int direction;

    private Calibrate cal;

    int xList[] = {

            50, UI_SCREEN_WIDTH - 50, UI_SCREEN_WIDTH - 50, 50, UI_SCREEN_WIDTH / 2

    };

    int yList[] = {

            50, UI_SCREEN_HEIGHT - 50, UI_SCREEN_HEIGHT - 50, 50, UI_SCREEN_HEIGHT / 2

    };

    static void setNotTitle(Activity act) {

        act.requestWindowFeature(Window.FEATURE_NO_TITLE);

    }

    static void setFullScreen(Activity act) {

        setNotTitle(act);

        act.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

                WindowManager.LayoutParams.FLAG_FULLSCREEN);

    }

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setFullScreen(this);   

        myview = new CrossView(this);

        setContentView(myview);

        SystemProperties.set("ts.config.calibrate", "start");

        cal = new Calibrate();

        direction = 0;

        myview.setOnTouchListener(new OnTouchListener() {

            @Override

            public boolean onTouch(View v, MotionEvent event) {

                Log.i("OnTouch", event.getX() + "," + event.getY());

                v.invalidate();

                if (direction < 4) {

                    Log.i("XXW time onTouchListener", " " + direction);

                    cal.get_sample(direction, (int)event.getX(), (int)event.getY(),

                            xList[direction], yList[direction]);

                }

                if (direction == 4) {

                    cal.get_sample(direction, (int)event.getX(), (int)event.getY(),

                            xList[direction], yList[direction]);

                    Log.i("XXW", "calibrate_main");

                    cal.calibrate_main();

                    Toast.makeText(getBaseContext(), "Calibrate Done!", Toast.LENGTH_SHORT).show();

                    SystemProperties.set("ts.config.calibrate", "done");

                    AndroidCalibrate.this.finish();

                }

                direction++;

                return false;

            }

        });

    }

    public class CrossView extends View {

        public CrossView(Context context) {

            super(context);

        }

        public void onDraw(Canvas canvas) {

            Paint paint = new Paint();

            paint.setColor(Color.GREEN);

            if (direction == 0) {

                canvas.drawLine(40, 50, 60, 50, paint);

                canvas.drawLine(50, 40, 50, 60, paint);

                paint.setColor(Color.WHITE);

            } else if (direction == 1) {

                canvas.drawLine(UI_SCREEN_WIDTH - 60, 50, UI_SCREEN_WIDTH - 40, 50, paint);

                canvas.drawLine(UI_SCREEN_WIDTH - 50, 40, UI_SCREEN_WIDTH - 50, 60, paint);

                paint.setColor(Color.WHITE);

            } else if (direction == 2) {

                canvas.drawLine(UI_SCREEN_WIDTH - 60, UI_SCREEN_HEIGHT - 50, UI_SCREEN_WIDTH - 40,

                        UI_SCREEN_HEIGHT - 50, paint);

                canvas.drawLine(UI_SCREEN_WIDTH - 50, UI_SCREEN_HEIGHT - 60, UI_SCREEN_WIDTH - 50,

                        UI_SCREEN_HEIGHT - 40, paint);

                paint.setColor(Color.WHITE);

            } else if (direction == 3) {

                canvas.drawLine(40, UI_SCREEN_HEIGHT - 50, 60, UI_SCREEN_HEIGHT - 50, paint);

                canvas.drawLine(50, UI_SCREEN_HEIGHT - 60, 50, UI_SCREEN_HEIGHT - 40, paint);

                paint.setColor(Color.WHITE);

            } else if (direction == 4) {

                canvas.drawLine(UI_SCREEN_WIDTH / 2 - 10, UI_SCREEN_HEIGHT / 2,

                        UI_SCREEN_WIDTH / 2 + 10, UI_SCREEN_HEIGHT / 2, paint);

                canvas.drawLine(UI_SCREEN_WIDTH / 2, UI_SCREEN_HEIGHT / 2 - 10,

                        UI_SCREEN_WIDTH / 2, UI_SCREEN_HEIGHT / 2 + 10, paint);

                paint.setColor(Color.WHITE);

            } else {

            }

            // canvas.drawText(getResources().getString(R.string.

            // screen_calibration_content),

            // UI_SCREEN_WIDTH / 2 - 50, UI_SCREEN_HEIGHT / 2, paint);

            super.onDraw(canvas);

        }

    }

}