Java android上传感器管理和摄像头的正确组合

我写了一个android活动，作为一个简单的摄像头，但当我拍照时，活动会存储图像，并在旁边存储一个txt文件，记录手机的gps位置和方向（即加速度计和数字指南针读数）。该活动有效，但我不确定是否正确编写。我是android和java的新手，如果有人能检查一下，那就太好了。我很担心，因为当我第一次开始开发这个时，我的开发设备开始变得非常有趣、过热等等。虽然我不是100%确定，但这可能与编码错误有关。也许是因为我把所有的参考资料传递给每一个班级的方式，可能不是个好主意，但我想不出其他的方法， 谢谢你的帮助

这是主要活动代码：

包com.mobimm；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileOutputStream；
导入java.io.FileWriter；
导入java.io.IOException；
导入android.app.Activity；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.graphics.Paint；
导入android.graphics.PixelFormat；
导入android.hardware.Camera；
导入android.hardware.Camera.PictureCallback；
导入android.hardware.Camera.PreviewCallback；
导入android.hardware.Camera.ShutterCallback；
导入android.os.Bundle；
导入android.os.Handler；
导入android.text.format.Time；
导入android.util.Log；
导入android.view.MotionEvent；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.view；
导入android.view.Window；
导入android.view.ViewGroup.LayoutParams；
公共类CameraAct扩展活动{
私人审查；
私人提款权mDrawOnTop；
私人方向经理森喜朗；
私人经理人；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
//隐藏窗口标题。
requestWindowFeature（窗口。功能\u无\u标题）；
//创建预览视图并将其设置为活动的内容。
mOri=新方向管理器（）；
mPreview=新的CamCapture（此，mOri）；
mDrawOnTop=新的DrawOnTop（本，mPreview，mOri）；
setContentView（mPreview）；
addContentView（mDrawOnTop，新的LayoutParams（LayoutParams.WRAP_CONTENT，LayoutParams.WRAP_CONTENT））；
mHandler=新处理程序（）；
mHandler.postDelayed（mUpdateUI，1000）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
if（mOri.issupport（this.getApplicationContext（）））{
startListening（this.getApplicationContext（））；
}
mPreview.resume（）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
if（mOri.issupport（this.getApplicationContext（）））{
森喜朗，别再听了；
}
mPreview.pause（）；
}
private Runnable mUpdateUI=new Runnable（）{
公开募捐{
mDrawOnTop.invalidate（）；
mHandler.postDelayed（mUpdateUI，1000）；
}
};
}
// ----------------------------------------------------------------------
类DrawOnTop扩展了视图{
漆成白色；
字符串mStatus；
cam；
方向经理森喜朗；
公共DrawOnTop（上下文、CamCapture cam、方向管理器ori）{
超级（上下文）；
mCam=cam；
莫里=奥里；
mStatus=“等待”；
mPaintWhite=新油漆（）；
mPaintWhite.setStyle（油漆、样式、填充）；
mpainwhite.setColor（Color.WHITE）；
mPaintWhite.setTextSize（25）；
}
@凌驾
受保护的void onDraw（画布）{
int canvasHeight=canvas.getHeight（）；
//拉线
canvas.drawText（Math.round（mOri.getAximition（））+“”+Math.round（mOri.getPitch（））+“”+Math.round（mOri.getRoll（）），10，canvasHeight-30，mPaintWhite）；
if（mOri.getGPSAcc（）0）{
canvas.drawText（（Math.round（（mOri.getLat（）*100000））/100000.0）+“，”+（Math.round（（mOri.getLng（）*100000））/100000.0）+“+mOri.getGPSAcc（），10，canvasHeight-60，mPaintWhite）；
}否则{
drawText（“寻找讽刺”+mOri.getGPSAcc（），10，canvasHeight-60，mpainWhite）；
}
画布.drawText（mStatus，10，画布高度-90，mPaintWhite）；
}
@凌驾
公共布尔onTouchEvent（最终运动事件）{
mCam.setRecording（真）；
返回true；
}
} 
// ----------------------------------------------------------------------
类CamCapture扩展了SurfaceView实现了SurfaceHolder.Callback{
表面粗糙度；
麦克默拉照相机；
//字节[]mYUVData；
//int[]mRGBData；
位图mBitmap[]；
int mImageWidth，mImageHeight；
长扫描；
布尔mRecording；
字符串名称；
字符串mCSVStore；
方向经理森喜朗；
PictureCallback回调；
ShutterCallback mShutterCallback；
CamCapture（CameraAct上下文，方向管理器ori）{
超级（（上下文）上下文）；
莫里=奥里；
mRecording=false；
mCSVStore=“”；
//安装SurfaceHolder.Callback，以便在
//创建和破坏下垫面。
mHolder=getHolder（）；
mHolder.addCallback（this）；
mHolder.setType（SurfaceHolder.SURFACE\u TYPE\u PUSH\u缓冲区）；
mHolder.setFormat（像素格式.半透明）；
mImageWidth=0；
}
已创建的公共空白表面（表面持有人）{
//曲面已创建，获取摄影机并告知其位置
//画。
mCamera=Camera.open（）；
试一试{
mCamera.setPreviewDisplay（支架）；
//当新取景器框架可用时使用预览回调
package com.mobimm;
import java.util.List;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;

public class OrientationManager {
    private Sensor sensor;
    private SensorManager sensorManager;
    private LocationManager locationManager;
    private double lat;
    private double lng;
    private float gpsacc;
    private float[] mR = null;
    private float[] mI = null;
    private float[] mMag;
    private float[] mGrv;
    private float[] mAng;

    // you could use an OrientationListener array instead
    // if you plans to use more than one listener

    /** indicates whether or not Orientation Sensor is supported */
    private Boolean supported;
    /** indicates whether or not Orientation Sensor is running */
    private boolean running = false;

    public OrientationManager() {
        mMag = new float[3];
        mGrv = new float[3];
        mAng = new float[3];
        mR = new float[16];
        mI = new float[16];
    }
    /**
     * Returns true if the manager is listening to orientation changes
     */
    public boolean isListening() {
        return running;
    }

    /**
     * Returns Ori Matrix
     */
    public float[] getMatrix() {
        return mR;
    }

    /**
     * Returns Magnetic Vector
     */
    public Vec getMagVec() {
        return new Vec(mMag[0], mMag[1], mMag[2]);
    }
    /**
     * Returns Gravity Vector
     */
    public Vec getGravVec() {
        return new Vec(mGrv[0], mGrv[1], mGrv[2]);
    }

    /**
     * Returns azimuth
     */
    public float getAzimuth() {
        return mAng[0];
    }
    /**
     * Returns azimuth
     */
    public float getPitch() {
        return mAng[1];
    }
    /**
     * Returns azimuth
     */
    public float getRoll() {
        return mAng[2];
    }

    /**
     * Returns lat
     */
    public float getLat() {
        return (float) lat;
    }

    /**
     * Returns lng
     */
    public float getLng() {
        return (float) lng;
    }

    /**
     * Returns lng
     */
    public float getGPSAcc() {
        return (float) gpsacc;
    }

    public String getString() {
        // output format = time,lat,lng,GPS acc, Ori Azimuth, Ori Pitch, Ori Roll, Acc x, Acc y, Acc z, Mag x, Mag y, Mag z
        String rtn = System.currentTimeMillis()+"\n";
        rtn += "GPS,";
        rtn += lat+",";
        rtn += lng+",";
        rtn += gpsacc+"\n";
        rtn += "Angles,";
        rtn += mAng[0]+",";
        rtn += mAng[1]+",";
        rtn += mAng[2]+"\n";
        rtn += "Gravtiy,";
        rtn += mGrv[0]+",";
        rtn += mGrv[1]+",";
        rtn += mGrv[2]+",";
        rtn += "Magnet,";
        rtn += mMag[0]+",";
        rtn += mMag[1]+",";
        rtn += mMag[2]+"\n";
        rtn += "Matrix,";
        rtn += mR[0]+",";
        rtn += mR[1]+",";
        rtn += mR[2]+",";
        rtn += mR[3]+"\n";
        rtn += " ,";
        rtn += mR[4]+",";
        rtn += mR[5]+",";
        rtn += mR[6]+",";
        rtn += mR[7]+"\n";
        rtn += " ,";
        rtn += mR[8]+",";
        rtn += mR[9]+",";
        rtn += mR[10]+",";
        rtn += mR[11]+"\n";
        rtn += " ,";
        rtn += mR[12]+",";
        rtn += mR[13]+",";
        rtn += mR[14]+",";
        rtn += mR[15]+"\n";
        return rtn;
    }
    /**
     * Unregisters listeners
     */
    public void stopListening() {
        running = false;
        try {
            if (sensorManager != null && sensorEventListener != null) {
                sensorManager.unregisterListener(sensorEventListener);
            }
            if (locationManager != null && locListener != null) {
                locationManager.removeUpdates(locListener);
            }
        } catch (Exception e) {}
    }

    /**
     * Returns true if at least one Orientation sensor is available
     */
    public boolean isSupported(Context context) {
        if (supported == null) {
            if (context != null) {
                sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
                //List sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
                //sensors = sensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
                //supported = new Boolean(sensors.size() > 0);
                List sensors = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER);
                supported = new Boolean(sensors.size() > 0);
                sensors = sensorManager.getSensorList(Sensor.TYPE_MAGNETIC_FIELD);
                supported = (supported && new Boolean(sensors.size() > 0));
            } else {
                supported = Boolean.FALSE;
            }
        }
        return supported;
    }

    /**
     * Registers a listener and start listening
     */
    public void startListening(Context context) {
        sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
        /*
        List sensors = sensorManager.getSensorList(
                Sensor.TYPE_ORIENTATION);
        if (sensors.size() > 0) {
            sensor = sensors.get(0);
            running = sensorManager.registerListener(
                    sensorEventListener, sensor, 
                    SensorManager.SENSOR_DELAY_GAME);
        }
        */
        List sensors = sensorManager.getSensorList(
                Sensor.TYPE_ACCELEROMETER);
        if (sensors.size() > 0) {
            sensor = sensors.get(0);
            running = sensorManager.registerListener(
                    sensorEventListener, sensor, 
                    SensorManager.SENSOR_DELAY_GAME);
        }
        sensors = sensorManager.getSensorList(
                Sensor.TYPE_MAGNETIC_FIELD);
        if (sensors.size() > 0) {
            sensor = sensors.get(0);
            running = sensorManager.registerListener(
                    sensorEventListener, sensor, 
                    SensorManager.SENSOR_DELAY_GAME);
        }
        locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
        try {
            locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000L, 2f, locListener);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * The listener that listen to events from the orientation listener
     */
    private SensorEventListener sensorEventListener = 
        new SensorEventListener() {

        public void onAccuracyChanged(Sensor sensor, int accuracy) {}

        public void onSensorChanged(SensorEvent event) {
            /*
            if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
                azimuth = event.values[0];     // azimuth
                pitch = event.values[1];     // pitch
                roll = event.values[2];        // roll
             }
            */
            if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                mGrv = event.values;
            }
            if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
                mMag = event.values;
            }
            if (SensorManager.getRotationMatrix(mR, mI, mGrv, mMag)) {
                SensorManager.getOrientation(mR, mAng);
                mAng[0] = (float) Math.toDegrees(mAng[0]);
                mAng[1] = (float) Math.toDegrees(mAng[1]);
                mAng[2] = (float) Math.toDegrees(mAng[2]);
                float[] tmp = new float[16]; 
                for (int i = 0; i