Java Android应用程序-将传感器数据保存到本地文件

我正在做一个项目，记录来自加速计传感器（xyz）的数据，并将其保存到手机上的文件中。我发现了一个代码片段，它从连接的传感器中检索数据，但没有将其保存在找到的传感器上。不幸的是，我一点也不懂Java，所以我希望这里有人能给我一个提示，告诉我如何才能达到节省的目的。我假设我需要将onSensorChanged中的变量（变量accx、accy、accz）连续附加到对象，然后在停止录制时保存它

编辑： 我声明了以下数组列表。3用于我的传感器数据，1用于写入相应的时间戳

final ArrayList<Integer> arrlist_ts = new ArrayList<Integer>(5);
final ArrayList<Integer> arrlist_x = new ArrayList<Integer>(5);
final ArrayList<Integer> arrlist_y = new ArrayList<Integer>(5);
final ArrayList<Integer> arrlist_z = new ArrayList<Integer>(5);

final ArrayList arrlist\u ts=新的ArrayList（5）；
最终ArrayList arrlist_x=新ArrayList（5）；
最终ArrayList arrlist_y=新ArrayList（5）；
最终ArrayList arrlist_z=新ArrayList（5）；

我将add to array命令放在run（）函数的变量String out_text后面

然后在if（timer1！=null）条件下，我将字符串连接放在函数stopRecording（）中。这有意义吗？ 然后，我会将代码保存到同一位置的文件中

这是密码

package pervasive_recorder;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.ArrayList;

import android.os.Handler;
import android.os.Message;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Binder;
import android.os.IBinder;
import android.support.v4.app.TaskStackBuilder;
import android.support.v4.app.NotificationCompat;
import android.widget.Toast;


public class ARFFRecorderService extends Service implements SensorEventListener {

    private int NOTIFICATION = R.string.recording;

    private final IBinder mBinder = new LocalBinder();
    private NotificationManager mNM;
    private boolean recording = false;
    private SensorManager mSensorManager;
    private Sensor mAccelerometer;
    private ARFFRecorderActivity clientActivity = null;
    private int ts, accx, accy, accz;
    static Timer timer1 = null;

    final ArrayList<Integer> arrlist_ts = new ArrayList<Integer>(5);
    final ArrayList<Integer> arrlist_x = new ArrayList<Integer>(5);
    final ArrayList<Integer> arrlist_y = new ArrayList<Integer>(5);
    final ArrayList<Integer> arrlist_z = new ArrayList<Integer>(5);

    public class LocalBinder extends Binder {
        ARFFRecorderService getService() {
            return ARFFRecorderService.this;
        }
    }

    @Override
    public void onCreate() {
        mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
    }

    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            if (clientActivity != null) clientActivity.updateAccStatus("Callback handler");
            return true;
        }
    });

    public void setClientActivity(ARFFRecorderActivity clientActivity) {
        this.clientActivity = clientActivity;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        if (clientActivity.disp_rate > 0) {
            timer1 = new Timer();
            timer1.schedule(new TimerTask() {
                @Override
                public void run() {
                    String out_text = "acc  x = " + accx + "  y = " + accy  + "  z = " + accz;
                    arrlist_ts.add(ts);
                    arrlist_x.add(accx);
                    arrlist_y.add(accy);
                    arrlist_z.add(accz);
                    if (clientActivity != null) clientActivity.updateAccStatus(out_text);
                }
            }, 1000, (int) (1000 / clientActivity.disp_rate));
        }

        if (!recording) {
            recording = true;
            NotificationCompat.Builder mBuilder =
                    new NotificationCompat.Builder(this)
                            .setSmallIcon(R.mipmap.ic_launcher)
                            .setContentTitle(getText(R.string.app_name))
                            .setContentText(getText(R.string.recording));
            Intent resultIntent = new Intent(this, ARFFRecorderActivity.class);
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(ARFFRecorderActivity.class);
            stackBuilder.addNextIntent(resultIntent);
            PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
            mBuilder.setContentIntent(resultPendingIntent);
            mNM.notify(NOTIFICATION, mBuilder.build());

            mSensorManager.registerListener(this, mAccelerometer, clientActivity.samp_rate);
            if (clientActivity != null) clientActivity.updateAccStatus("acc started");
        }
        return START_STICKY;
    }

    public void onSensorChanged(SensorEvent e) {
        ts = (int) (new Date().getTime()/1000);
        accx = (int) (100000 * e.values[0]);
        accy = (int) (100000 * e.values[1]);
        accz = (int) (100000 * e.values[2]);
    }

    private void showMessage(String text) {
        Toast toast = Toast.makeText(this, text, Toast.LENGTH_LONG);
        toast.show();
    }

    @Override
    public void onDestroy() {
        stopRecording();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

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

    public boolean isRecording() {
        return recording;
    }

    public void stopRecording() {
        if (recording) {
            mSensorManager.unregisterListener(this);
            mNM.cancel(NOTIFICATION);
            recording = false;
            if (timer1 != null) {
                String s_ts = "";
                String s_x = "";
                String s_y = "";
                String s_z = "";
                StringBuilder sb_ts = new StringBuilder();
                for (int i = 0; i < arrlist_ts.size(); i++) {
                    sb_ts.append(arrlist_ts.get(i));
                }
                StringBuilder sb_x = new StringBuilder();
                for (int i = 0; i < arrlist_x.size(); i++) {
                    sb_x.append(arrlist_x.get(i));
                }
                StringBuilder sb_y = new StringBuilder();
                for (int i = 0; i < arrlist_ts.size(); i++) {
                    sb_y.append(arrlist_y.get(i));
                }
                StringBuilder sb_z = new StringBuilder();
                for (int i = 0; i < arrlist_ts.size(); i++) {
                    sb_z.append(arrlist_z.get(i));
                }
                s_ts = sb_ts.toString();
                s_x = sb_x.toString();
                s_y = sb_y.toString();
                s_z = sb_z.toString();
                timer1.cancel();
            }
            if (clientActivity != null) clientActivity.updateAccStatus("acc stopped");
            stopSelf();
        }
    }

}

u记录器；
导入java.util.Date；
导入java.util.Timer；
导入java.util.TimerTask；
导入java.util.ArrayList；
导入android.os.Handler；
导入android.os.Message；
导入android.app.NotificationManager；
导入android.app.pendingent；
导入android.app.Service；
导入android.content.Intent；
导入android.hardware.Sensor；
导入android.hardware.SensorEvent；
导入android.hardware.SensorEventListener；
导入android.hardware.SensorManager；
导入android.os.Binder；
导入android.os.IBinder；
导入android.support.v4.app.TaskStackBuilder；
导入android.support.v4.app.NotificationCompat；
导入android.widget.Toast；
公共类ARFFRecorderService扩展服务实现SensorEventListener{
私有int通知=R.string.recording；
private final IBinder mBinder=new LocalBinder（）；
私人通知经理mNM；
私有布尔记录=假；
私人传感器管理器；
专用传感器mAccelerometer；
私有ARFFRecorderActivity clientActivity=null；
私家车，accx，accy，accz；
静态计时器计时器1=空；
最终ArrayList arrlist_ts=新ArrayList（5）；
最终ArrayList arrlist_x=新ArrayList（5）；
最终ArrayList arrlist_y=新ArrayList（5）；
最终ArrayList arrlist_z=新ArrayList（5）；
公共类LocalBinder扩展了Binder{
ARFFRecorderService getService（）{
返回ARFFRecorderService.this；
}
}
@凌驾
public void onCreate（）{
mNM=（NotificationManager）getSystemService（通知服务）；
msSensorManager=（SensorManager）getSystemService（传感器服务）；
mAccelerometer=mSensorManager.getDefaultSensor（传感器类型\磁场）；
}
private Handler=new Handler（new Handler.Callback（）{
@凌驾
公共布尔句柄消息（消息消息消息）{
if（clientActivity！=null）clientActivity.updateacstatus（“回调处理程序”）；
返回true；
}
});
public void setClientActivity（ARFFRecorderActivity clientActivity）{
this.clientActivity=clientActivity；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
if（clientActivity.disp_rate>0）{
timer1=新定时器（）；
timer1.时间表（新TimerTask（）{
@凌驾
公开募捐{
字符串输出_text=“acc x=“+accx+”y=“+accy+”z=“+accz；
arrlist_ts.add（ts）；
arrlist_x.add（accx）；
arrlist_y.add（会计科目）；
arrlist_z.add（accz）；
if（clientActivity！=null）clientActivity.updateacstatus（out_text）；
}
}，1000，（int）（1000/客户活动显示率）；
}
如果（！录制）{
记录=真；
通知相容建筑商mBuilder=
新建NotificationCompat.Builder（此）
.setSmallIcon（R.mipmap.ic_启动器）
.setContentTitle（getText（R.string.app_name））
.setContentText（getText（R.string.recording））；
Intent resultIntent=新的Intent（这个，ARFFRecorderActivity.class）；
TaskStackBuilder stackBuilder=TaskStackBuilder.create（此）；
addParentStack（ARFFRecorderActivity.class）；
stackBuilder.addNextIntent（resultIntent）；
PendingEvent ResultPendingEvent=stackBuilder.GetPendingEvent（0，PendingEvent.FLAG_UPDATE_CURRENT）；
mBuilder.setContentIntent（resultPendingContent）；
mNM.notify（NOTIFICATION，mBuilder.build（））；
mSensorManager.registerListener（this、mAccelerometer、clientActivity.samp_rate）；
if（clientActivity！=null）clientActivity.updateacstatus（“acc已启动”）；
}
返回开始时间；
}
传感器更改时的公共无效（传感器事件e）{
ts=（int）（new Date（）.getTime（）/1000）；
accx=（int）（100000*e.values[0]）；
accy=（int）（100000*e.values[1]）；
accz=（int）（100000*e.values[2]）；
}
私有void showMessage（字符串文本）{
Toast Toast=Toast.makeText（this，text，Toast.LENGTH\u LONG）；
toast.show（）；
}
@凌驾
公共空间{
停止录制（）；
}
@凌驾
公共IBinder onBind（意向）{
返回mBinder；
}
精度更改时的公共无效（传感器，int精度）{
}
公共布尔值isRecording（）{
返回记录；
}
公开作废停止录制（）{
如果（录音）{
mSensorManager.unregisterListener（此）；
mNM.取消（通知）；