j2me学习十一_jsr256的应用

 jsr256是感应器的api，现在手机中比较常见是中立感应Sensor，有了这个api之后，我们可以多了很多玩法，这次，我要用它来完成一个利用重力感应控制的小球。
开发环境：javaME Platform SDK3.0（Eclipse存在ClassDefNotFound错误，至今未解决。。。。）
四个java文件，
主midlet，画布，小球，辅助向量。下面是每个类得代码：

主midlet，主要用于控制游戏进度，接受传感器信息

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import javax.microedition.io.Connector;
import java.io.IOException;
import java.util.Vector;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;
import javax.microedition.sensor.ChannelInfo;
import javax.microedition.sensor.Data;
import javax.microedition.sensor.DataListener;
import javax.microedition.sensor.SensorConnection;
import javax.microedition.sensor.SensorInfo;
import javax.microedition.sensor.SensorManager;
/**
 * @author Administrator
 */
public class BallMidlet extends MIDlet  implements DataListener{

    private BallCanvas ballCanvas;
    private SensorConnection sensor;
    private String[] channelNames;
    private boolean sensorSelected;
    private SensorInfo[] sensorInfos;
    public BallMidlet() throws IOException {
        
        if (System.getProperty("microedition.sensor.version") == null) {
            Display.getDisplay(this).setCurrent(
                    new Alert("JSR256 is not supported!"),
                    new TextBox("ERROR", "JSR256 is not supported!", 255, 0));
            return;
            // throw new IllegalArgumentException("JSR256 is not supported!");
        }
        ballCanvas = new BallCanvas();
        sensorInfos = getSensorInfos();
        System.out.println("sensorInfos.length:  "+sensorInfos.length);
        if (sensorInfos == null) {
            Display.getDisplay(this).setCurrent(
                    new Alert("Valid accelerometer sensor not found"),
                    new TextBox("ERROR",
                            "Valid accelerometer sensor not found", 255, 0));
            return;
        }
     
    new Thread() {
                    public void run() {

                        channelNames =
                                getSensorInfoChannelsNames(sensorInfos[0]);

                        try {
                            sensor =
                                    (SensorConnection) Connector
                                            .open(sensorInfos[0].getUrl());
                            ballCanvas.start();
                            sensor.setDataListener(BallMidlet.this, 1);
                            sensorSelected = true;
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
}
                }.start();
    }
private SensorInfo[] getSensorInfos() {
        // Find all device accelerometers
        SensorInfo[] sensorInfos = SensorManager.findSensors("acceleration", null);
        Vector validInfos = new Vector();
        for (int i = 0; i < sensorInfos.length; i++) {
            if (getSensorInfoChannelsNames(sensorInfos[i]).length > 2) {
                validInfos.addElement(sensorInfos[i]);
            }
        }
        SensorInfo[] ret = null;
        if (validInfos.size() > 0) {
            ret = new SensorInfo[validInfos.size()];
            validInfos.copyInto(ret);
        }
        return ret;
    }
private String[] getSensorInfoChannelsNames(SensorInfo sensorInfo) {
        Vector channelNames = new Vector();
        ChannelInfo[] channelInfos = sensorInfo.getChannelInfos();
        // Accelerometer must support at least 3 channels
        if (channelInfos.length > 2) {
            for (int i = 0; i < channelInfos.length; i++) {
                // The channel type must be double
                if (ChannelInfo.TYPE_DOUBLE == channelInfos[i].getDataType()
                        || ChannelInfo.TYPE_INT == channelInfos[i]
                                .getDataType()) {
                    channelNames.addElement(channelInfos[i].getName());
                }
            }
            // We found at least 3 double channels
            if (channelNames.size() > 2) {
                String[] names = new String[3];
                names[0] = (String) channelNames.elementAt(0);
                names[1] = (String) channelNames.elementAt(1);
                names[2] = (String) channelNames.elementAt(2);
                return names;
            }
        }
        return new String[0];
    }
public void dataReceived(SensorConnection sensor, Data[] data,
            boolean isDataLost) {
        double[] accel = new double[3];
        for (int i = 0; i < data.length; i++) {
            for (int c = 0; c < 3; c++) {
                if (channelNames[c].equals(data[i].getChannelInfo().getName())) {
                    double val;
                    switch (data[i].getChannelInfo().getDataType()) {
                    case ChannelInfo.TYPE_DOUBLE:
                        val = data[i].getDoubleValues()[0];
                        break;
                    case ChannelInfo.TYPE_INT:
                        val = data[i].getIntValues()[0];
                        break;
                    default:
                        val = 0;
                    }
                    accel[c] =
                            unscaleValue(val, data[i].getChannelInfo()
                                    .getScale());
                    break;
                }
            }

        }
        ballCanvas.accelerate(accel[0], accel[1], accel[2]);
    }
   private final double unscaleValue(double scaledValue, int scale) {
        double mult = 1.0;
        for (int i = 0; i < Math.abs(scale); i++) {
            mult *= 10.0;
        }
        return (scale > 0) ? scaledValue * mult : scaledValue / mult;
    }
  public void startApp() {
            ballCanvas.resetBoard();   
            Display.getDisplay(BallMidlet.this).setCurrent(ballCanvas);
            //sensor.setDataListener(BallMidlet.this, 1);
             System.out.println("Come here~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
    }

    public void pauseApp() {
        sensor.removeDataListener();
    }

    public void destroyApp(boolean unconditional) {
        if (sensor != null) {
            try {
                sensor.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        notifyDestroyed();
    }
   
}

小球类：

import java.io.IOException;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
public class Ball {

        private Image img;
        private Vector lastPos;
        private Vector pos;
        private Vector speed;
        final static double ROLLING_FRICTION = 0.001;
        private double bounceFriction;
        private double radius;

        public Ball() throws IOException {
            this(0, 0);
        }

        public Ball(double x, double y) throws IOException {
            img = Image.createImage("/black_marble.png");
            pos = new Vector(x, y);
            lastPos = new Vector(x, y);
            speed = new Vector(0, 0);
            radius = img.getWidth() / 2.0;
            bounceFriction = 0.5;
        }

        public void resetPosition(double x, double y) {
            speed = new Vector(0, 0);
            pos.setX(x - getRadius());
            pos.setY(y - getRadius());
        }

        public void paint(Graphics g) {
            lastPos = new Vector(pos);
            g.drawImage(img, (int) pos.getX(), (int) pos.getY(),
                    Graphics.HCENTER | Graphics.VCENTER);
        }

        public void clear(Graphics g) {
            g.setColor(0xbbbbff);
            g.fillRect((int) (lastPos.getX() - getRadius()), (int) (lastPos
                    .getY() - getRadius()), (int) (getRadius() * 2),
                    (int) (getRadius() * 2));
        }

        public void accelerate(double accelX, double accelY, double accelZ) {
            double frictionF = (Math.max(0, accelZ) * ROLLING_FRICTION * 2);
            speed.add(accelX, accelY);
            if (frictionF > 0 && speed.getLen2() > 0) {
                Vector friction = speed.inv().norm().mul(Math.sqrt(frictionF));
                speed.add(friction);
            }
        }

        public void calcNewPosition() {
            pos.add(speed);
        }

        public double getRadius() {
            return radius;
        }

        public void collideBorders(Canvas canvas) {
            Vector newPos = Vector.add(pos, speed);
            if (newPos.getY() - getRadius() < 0) {
                speed.setY(speed.getY() * (bounceFriction - 1));
                pos.setY(getRadius());
            } else if (newPos.getY() + getRadius() > canvas.getHeight()) {
                speed.setY(speed.getY() * (bounceFriction - 1));
                pos.setY(canvas.getHeight() - getRadius());
            }
            if (newPos.getX() - getRadius() < 0) {
                speed.setX(speed.getX() * (bounceFriction - 1));
                pos.setX(getRadius());
            } else if (newPos.getX() + getRadius() > canvas.getWidth()) {
                speed.setX(speed.getX() * (bounceFriction - 1));
                pos.setX(canvas.getWidth() - getRadius());
            }
        }

}

主Canvas，继承的是Canvas，实现Runnable接口

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Administrator
 */
import java.io.IOException;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
public class BallCanvas extends Canvas implements Runnable {
      private static final double PPCM = 80 * 100; // pixels per meter
    public static final long TICK_SLEEP_MILLIS = 5;
    /**
     * Marble mass in kg. This demo is optimized for marbles with equal masses.
     */
    final static double MARBLE_MASS = 0.000742179;

    /**
     * Multipliers convert m/s^2 to pixel/tick^2.
     */
    private final double accelMultX;
    private final double accelMultY;
    private final double accelMultZ;

    private Ball ball;
    private volatile boolean stop;

    private double accelX;
    private double accelY;
    private double accelZ;
    volatile boolean firstPaint = true;
        public BallCanvas() throws IOException {
       
        // Tick cycles per s^2
         setFullScreenMode(true);
        double d = (1000 / TICK_SLEEP_MILLIS) * (1000 / TICK_SLEEP_MILLIS);
        accelMultX = -1.0 * PPCM / d;
        accelMultY = 1.0 * PPCM / d;
        accelMultZ = -1.0 * PPCM / d;

        ball = new Ball();
    }
    public synchronized void resetBoard() {
        accelX = 0;
        accelY = 0;
        ball.resetPosition(getWidth() * 0.5, getHeight() * 0.5);
        firstPaint = true;
    }

    public void start() {
        stop = false;
        resetBoard();
         System.out.println("this.isDoubleBuffered()~~~~~~~~~~~~~~~~~~~~~~~~~~~~"+this.isDoubleBuffered());
        new Thread(this).start();
    }

    public void stop() {
        stop = true;
    }

    public void run() {
        long st=0,et=0,diff=0;
        int rate=50;//16-17 frame per second
            while (!stop)
            {
                st=System.currentTimeMillis();
                calculatePositions();
                repaint();
                et=System.currentTimeMillis();
                diff=et-st;
                if(diff<rate){
        //System.out.println("Sleep "+(rate-diff));
        try {
          Thread.sleep(rate - diff);
        }
        catch (InterruptedException ex) {}

        }
        }
       
       
    }
    public void paint(Graphics g) {
        if (firstPaint) {
            g.setColor(0xbbbbff);
            g.fillRect(0, 0, getWidth(), getHeight());
            firstPaint = false;
        }
            ball.clear(g);
            ball.paint(g);
    }
    private static final int SMOOTH_CNT = 2;
    double avgX[] = new double[SMOOTH_CNT];
    double avgY[] = new double[SMOOTH_CNT];
    double avgZ[] = new double[SMOOTH_CNT];
    public synchronized void accelerate(double x, double y, double z) {
        double xx = x;
        double yy = y;
        double zz = z;
        for (int i = 0; i < avgX.length - 1; i++) {
            xx += avgX[i];
            yy += avgY[i];
            zz += avgZ[i];
            avgX[i] = avgX[i + 1];
            avgY[i] = avgY[i + 1];
            avgZ[i] = avgZ[i + 1];
        }
        avgX[avgX.length - 1] = x;
        avgY[avgY.length - 1] = y;
        avgZ[avgZ.length - 1] = z;
        xx /= avgX.length + 1;
        yy /= avgY.length + 1;
        zz /= avgZ.length + 1;

        accelX = xx * accelMultX;
        accelY = yy * accelMultY;
        accelZ = zz * accelMultZ;
    }
        private synchronized void calculatePositions() {
           ball.accelerate(accelX, accelY, accelZ);
           System.out.println("calculatePositions~~~~~~~~~~~~~~~~");
            ball.collideBorders(this);
           ball.calcNewPosition();

    }
}

向量类，类似辅助计算：

public class Vector {

    private double x;
    private double y;

    public Vector(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public Vector(Vector v) {
        this(v.getX(), v.getY());
    }

    public static Vector add(Vector a, Vector b) {
        return new Vector(a.getX() + b.getX(), a.getY() + b.getY());
    }

    public static Vector mul(Vector v, double d) {
        return new Vector(v.getX() * d, v.getY() * d);
    }

    public static double dot(Vector a, Vector b) {
        return a.getX() * b.getX() + a.getY() * b.getY();
    }

    public static Vector sub(Vector v1, Vector v2) {
        return new Vector(v1.getX() - v2.getX(), v1.getY() - v2.getY());
    }

    public Vector inv() {
        return new Vector(getX() * -1.0, getY() * -1.0);
    }

    public Vector norm() {
        double l = Math.sqrt(getX() * getX() + getY() * getY());
        return new Vector(getX() / l, getY() / l);
    }

    public double getY() {
        return y;
    }

    public double getX() {
        return x;
    }

    public Vector mul(double d) {
        return new Vector(getX() * d, getY() * d);
    }

    public void add(Vector vector) {
        add(vector.x, vector.y);
    }

    public void add(double d) {
        add(d, d);
    }

    public void add(double x, double y) {
        this.x += x;
        this.y += y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getLen2() {
        return getX() * getX() + getY() * getY();
    }

    public double getLen() {
        return Math.sqrt(getLen2());
    }

    public String toString() {
        return "[" + getX() + ";" + getY() + "]";
    }
}