Add sensor app for activity recognition

code/lukas/SensorDataCollector/app/src/androidTest/java/com/koeping/lukas/sensordatacollector/ApplicationTest.java

@@ -0,0 +1,13 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.app.Application;
+import android.test.ApplicationTestCase;
+
+/**
+ * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
+ */
+public class ApplicationTest extends ApplicationTestCase<Application> {
+    public ApplicationTest() {
+        super(Application.class);
+    }
+}

code/lukas/SensorDataCollector/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.koeping.lukas.sensordatacollector">
+
+
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+
+
+        <activity android:name=".MainActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+        <service android:name=".SensorService" />
+    </application>
+
+</manifest>

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/EventInformation.java

@@ -0,0 +1,21 @@
+package com.koeping.lukas.sensordatacollector;
+
+
+public class EventInformation {
+    private long timestamp;
+    private Events event;
+
+
+    public EventInformation(long timestamp, Events event) {
+        this.timestamp = timestamp;
+        this.event = event;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public Events getEvent() {
+        return event;
+    }
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/EventMarker.java

@@ -0,0 +1,78 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.os.AsyncTask;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class EventMarker extends AsyncTask<EventInformation, Void, Boolean> {
+
+    private final String SAVE_DIRECTORY = "SensorDataCollector";
+    private final String EVENT_FILENAME = "Events.txt";
+    private FileWriter fw = null;
+    private BufferedWriter bw = null;
+    private String directory_name;
+    private long startTime;
+
+    public EventMarker(String directory_name, long startTime) {
+        this.directory_name = directory_name;
+        this.startTime = startTime;
+    }
+
+    @Override
+    protected void onPreExecute() {
+
+        File root = null;
+        try {
+            root = Helper.getStorageRoot();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        File directory = new File(root, SAVE_DIRECTORY + "/" + directory_name);
+
+
+        if (!directory.exists()) {
+            directory.mkdirs();
+        }
+
+        File eventFile = new File(directory, EVENT_FILENAME);
+
+        try {
+            fw = new FileWriter(eventFile, true);
+            bw = new BufferedWriter(fw, 32768);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    @Override
+    protected Boolean doInBackground(EventInformation... info) {
+
+        EventInformation ei = info[0];
+        long time = ei.getTimestamp() - startTime;
+
+        try {
+            bw.write(time + ";" + ei.getEvent());
+            bw.newLine();
+
+
+            bw.flush();
+            bw.close();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false;
+        }
+
+        return true;
+    }
+
+
+
+
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/Events.java

@@ -0,0 +1,6 @@
+package com.koeping.lukas.sensordatacollector;
+
+public enum Events {
+    STAND, ELEVATOR_UP, ELEVATOR_DOWN, STAIRS_UP, STAIRS_DOWN, WALK_NORMAL, WALK_SLOW,
+    WALK_FAST, UNDEFINED
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/Helper.java

@@ -0,0 +1,70 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.os.Environment;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Calendar;
+
+
+public class Helper
+{
+
+    /* Checks if external storage is available for read and write */
+    public static boolean isExternalStorageWritable() {
+        String state = Environment.getExternalStorageState();
+        if (Environment.MEDIA_MOUNTED.equals(state)) {
+            return true;
+        }
+        return false;
+    }
+
+    public static String getCurretDate() {
+        String currentDate =
+                Calendar.getInstance().get(Calendar.YEAR) + "_" +
+                        (Calendar.getInstance().get(Calendar.MONTH)+1) + "_" +
+                        Calendar.getInstance().get(Calendar.DAY_OF_MONTH) + "_" +
+                        Calendar.getInstance().get(Calendar.HOUR_OF_DAY) + "_" +
+                        Calendar.getInstance().get(Calendar.MINUTE) + "_" +
+                        Calendar.getInstance().get(Calendar.SECOND);
+
+        return currentDate;
+    }
+
+    public static File getStorageRoot() throws FileNotFoundException{
+        File root;
+        if(Helper.isExternalStorageWritable()) {
+            root = Environment.getExternalStorageDirectory();
+        } else {
+            throw new FileNotFoundException("External storage not writeable");
+        }
+
+        return root;
+    }
+
+    private class EventInformation {
+        private int event_id;
+        private long timestamp;
+        private boolean start;
+
+        EventInformation(int event_id, long timestamp, boolean start) {
+            this.event_id = event_id;
+            this.timestamp = timestamp;
+            this.start = start;
+        }
+
+        public int getEvent_id() {
+            return event_id;
+        }
+
+        public long getTimestamp() {
+            return timestamp;
+        }
+
+        public boolean isStart() {
+            return start;
+        }
+    }
+
+
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/MainActivity.java

@@ -0,0 +1,187 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.Manifest;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+
+public class MainActivity extends AppCompatActivity  {
+    private boolean isRecording = false;
+
+    private final int MY_PERMISSIONS_WRITE_EXTERNAL_STORAGE = 0;
+    private Intent sensorServiceIntent;
+    private String currentDate;
+    private long startTime;
+
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        getWindow().addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    }
+
+
+    public void startStopRecording(View view) {
+
+        if (isRecording) {
+            stopRecording();
+        }
+        else {
+            startRecording();
+        }
+        changeRecordingButtonText(isRecording);
+        isRecording = !isRecording;
+
+    }
+
+
+    private void startRecording() {
+        boolean writing_permission = checkPermission();
+
+
+        if (writing_permission) {
+            startCollectingData();
+        }
+        else {
+            ActivityCompat.requestPermissions(this,
+                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
+                    MY_PERMISSIONS_WRITE_EXTERNAL_STORAGE);
+        }
+
+    }
+
+
+    private void stopRecording() {
+        stopService(sensorServiceIntent);
+
+    }
+
+    private void startCollectingData() {
+        this.currentDate = Helper.getCurretDate();
+        this.startTime = System.currentTimeMillis();
+
+        sensorServiceIntent = new Intent(this, SensorService.class);
+        sensorServiceIntent.putExtra("directory_name", this.currentDate);
+        sensorServiceIntent.putExtra("startTime", startTime);
+        startService(sensorServiceIntent);
+    }
+
+
+
+
+    private boolean checkPermission() {
+        int writePermission = ContextCompat.checkSelfPermission(this,
+                Manifest.permission.WRITE_EXTERNAL_STORAGE);
+
+
+        if (writePermission == PackageManager.PERMISSION_GRANTED) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    private void changeRecordingButtonText(boolean isRecording) {
+        Button b = (Button)findViewById(R.id.recording_button);
+
+        if(isRecording) {
+            b.setText("Start\nRecording");
+        }
+        else {
+            b.setText("Stop\nRecording");
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode,
+                                           String permissions[], int[] grantResults) {
+        switch (requestCode) {
+            case MY_PERMISSIONS_WRITE_EXTERNAL_STORAGE: {
+                // If request is cancelled, the result arrays are empty.
+                if (grantResults.length > 0
+                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+
+                    startCollectingData();
+
+                } else {
+                    Button b = (Button)findViewById(R.id.recording_button);
+                    b.setText("No Writing Permissions!!!!");
+                }
+                return;
+            }
+        }
+    }
+
+
+    public void markEvent(View view) {
+
+        int view_id = view.getId();
+        long timestamp = System.currentTimeMillis();
+
+
+        switch(view_id) {
+            case R.id.stand_button:
+                doMarking(timestamp, Events.STAND);
+                changeEventText(Events.STAND);
+                break;
+            case R.id.elevator_up_button:
+                doMarking(timestamp, Events.ELEVATOR_UP);
+                changeEventText(Events.ELEVATOR_UP);
+                break;
+            case R.id.elevator_down_button:
+                doMarking(timestamp, Events.ELEVATOR_DOWN);
+                changeEventText(Events.ELEVATOR_DOWN);
+                break;
+            case R.id.stairs_up_button:
+                doMarking(timestamp, Events.STAIRS_UP);
+                changeEventText(Events.STAIRS_UP);
+                break;
+            case R.id.stairs_down_button:
+                doMarking(timestamp, Events.STAIRS_DOWN);
+                changeEventText(Events.STAIRS_DOWN);
+                break;
+            case R.id.walk_normal_button:
+                doMarking(timestamp, Events.WALK_NORMAL);
+                changeEventText(Events.WALK_NORMAL);
+                break;
+            case R.id.walk_slow_button:
+                doMarking(timestamp, Events.WALK_SLOW);
+                changeEventText(Events.WALK_SLOW);
+                break;
+            case R.id.walk_fast_button:
+                doMarking(timestamp, Events.WALK_FAST);
+                changeEventText(Events.WALK_FAST);
+                break;
+            case R.id.undefined_button:
+                doMarking(timestamp, Events.UNDEFINED);
+                changeEventText(Events.UNDEFINED);
+
+        }
+
+
+    }
+
+
+    private void doMarking(long timestamp, Events event) {
+        EventInformation ei = new EventInformation(timestamp, event);
+        new EventMarker(this.currentDate, this.startTime).execute(ei);
+    }
+
+    private void changeEventText(Events event) {
+        ((TextView)findViewById(R.id.event_text)).setText(event.toString());
+
+    }
+
+
+
+
+
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/SensorDataCollector.java

@@ -0,0 +1,133 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
+/**
+ * Created by lukas on 18.01.16.
+ */
+public class SensorDataCollector implements SensorEventListener
+{
+    private SensorManager sensorManager;
+    private final int SENSOR_DELAY = SensorManager.SENSOR_DELAY_FASTEST;
+    private SensorDataWriter dataWriter;
+    private long startTime;
+
+
+
+    public SensorDataCollector(SensorDataWriter sdw, SensorManager sensorManager, long startTime) {
+        this.sensorManager = sensorManager;
+        initSensors();
+        this.startTime = startTime;
+        this.dataWriter = sdw;
+    }
+
+    private void initSensors() {
+        Sensors[] allSensors = Sensors.values();
+
+        for(int i = 0; i < Sensors.values().length; i++) {
+            allSensors[i].setSensor(sensorManager.getDefaultSensor(allSensors[i].getSensorType()));
+            sensorManager.registerListener(this, allSensors[i].getSensor(), SENSOR_DELAY);
+        }
+    }
+
+
+    private float[] getSensorData(Sensors sensor, SensorEvent event) {
+        int nValues = sensor.getNValues();
+        int pos = sensor.getPos();
+        float[] data = new float[nValues];
+        System.arraycopy(event.values, 0, data, 0, nValues);
+
+        return data;
+    }
+
+    private float[] getRotationMatrix(float[] gravity, float[] magnetic) {
+        float[] rotation = new float[16];
+        float[] inclination = new float[16];
+        sensorManager.getRotationMatrix(rotation, inclination, gravity, magnetic);
+
+        return rotation;
+    }
+
+    private float[] getOrientations(float[] rotation_Matrix) {
+        float[] values = new float[3];
+        values = sensorManager.getOrientation(rotation_Matrix, values);
+
+        return values;
+    }
+
+    private void receiveAndWrite(Sensors sensor, SensorEvent event) {
+        float[] data = getSensorData(sensor, event);
+        sensor.setData(data);
+        long timestamp = System.currentTimeMillis() - startTime;
+        dataWriter.writeDataToFile(sensor, timestamp, data);
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+
+        if(dataWriter != null)
+            recordData(event);
+    }
+
+
+    private void recordData(SensorEvent event) {
+
+        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+            receiveAndWrite(Sensors.ACCELEROMETER, event);
+        }
+
+        if (event.sensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION) {
+            receiveAndWrite(Sensors.LINEAR_ACCELEROMETER, event);
+        }
+
+        if (event.sensor.getType() == Sensor.TYPE_GRAVITY) {
+            receiveAndWrite(Sensors.GRAVITY, event);
+            long timestamp = System.currentTimeMillis() - startTime;
+
+            if (Sensors.MAGNETOMETER.getData() != null) {
+                float[] data = getRotationMatrix(Sensors.GRAVITY.getData(), Sensors.MAGNETOMETER.getData());
+                Sensors.ROTATION_MATRIX.setData(data);
+                dataWriter.writeDataToFile(Sensors.ROTATION_MATRIX, timestamp, data);
+
+                data = getOrientations(Sensors.ROTATION_MATRIX.getData());
+                Sensors.ORIENTATION.setData(data);
+                dataWriter.writeDataToFile(Sensors.ORIENTATION, timestamp, data);
+            }
+
+        }
+
+        if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
+            receiveAndWrite(Sensors.GYROSCOPE, event);
+        }
+
+        if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
+            receiveAndWrite(Sensors.MAGNETOMETER, event);
+        }
+
+        if (event.sensor.getType() == Sensor.TYPE_PRESSURE) {
+            receiveAndWrite(Sensors.BAROMETER, event);
+        }
+
+    }
+
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        //Nothing to be done here
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/SensorDataWriter.java

@@ -0,0 +1,112 @@
+package com.koeping.lukas.sensordatacollector;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+
+
+public class SensorDataWriter {
+    private String separator;
+    private final String APP_DIRECTORY = "SensorDataCollector";
+    private HashMap<String, BufferedWriter> writerHashMap;
+
+
+    public SensorDataWriter(String directory_name) {
+        this.writerHashMap = new HashMap<String, BufferedWriter>();
+        this.separator = ";";
+
+        File root = null;
+        try {
+            root = Helper.getStorageRoot();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        File directory = new File(root, APP_DIRECTORY + "/" + directory_name);
+
+
+        if (!directory.exists()) {
+            directory.mkdirs();
+        }
+
+        for(String sensorName : Sensors.getAllNames()) {
+            File sensorFile = new File(directory, sensorName+".csv");
+            FileWriter fw = null;
+            BufferedWriter bw = null;
+
+            try {
+                fw = new FileWriter(sensorFile);
+                bw = new BufferedWriter(fw, 32768);
+                writerHashMap.put(sensorName, bw);
+                writeFileHeaders(sensorName);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    private void writeFileHeaders(String sensorname) {
+        BufferedWriter bw = writerHashMap.get(sensorname);
+
+        try {
+            if (sensorname.equals(Sensors.ROTATION_MATRIX.getName())) {
+                bw.write("Timestamp;");
+                for (int i = 0; i < 15; i++) {
+                    bw.write("Rotation_"+i+";");
+                }
+                bw.write("Rotation_15");
+                bw.newLine();
+            }
+            else {
+                bw.write("Timestamp;X;Y;Z");
+                bw.newLine();
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    public void writeDataToFile(Sensors sensor, long timestamp, float[] data) {
+        BufferedWriter bw = writerHashMap.get(sensor.getName());
+
+        try {
+
+            bw.write(timestamp+this.separator);
+            for (int i = 0; i < data.length - 1; i++) {
+                bw.write(data[i] + this.separator);
+            }
+            //Last column does not need a seperator
+            bw.write(""+data[data.length-1]);
+            bw.newLine();
+
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void closeWriters() {
+        for (String sensorName : writerHashMap.keySet()) {
+            try {
+                writerHashMap.get(sensorName).flush();
+                writerHashMap.get(sensorName).close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+        }
+
+    }
+
+
+}
+
+
+
+

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/SensorService.java

@@ -0,0 +1,48 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.app.IntentService;
+import android.content.Context;
+import android.content.Intent;
+import android.hardware.SensorManager;
+
+
+public class SensorService extends IntentService {
+    private SensorDataWriter sdw;
+    private SensorDataCollector sdc;
+    private SensorManager sensorManager;
+    private String directory_name;
+    private long startTime;
+
+    public SensorService () {
+        super("SensorService");
+
+    }
+
+    @Override
+    public void onDestroy() {
+        sdw.closeWriters();
+        this.sensorManager.unregisterListener(sdc);
+    }
+
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startID) {
+        this.directory_name = intent.getStringExtra("directory_name");
+        this.startTime = intent.getLongExtra("startTime", 0);
+        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
+        sdw = new SensorDataWriter(this.directory_name);
+        sdc = new SensorDataCollector(sdw, sensorManager, this.startTime);
+
+        return START_STICKY;
+    }
+
+
+
+    @Override
+    protected void onHandleIntent(Intent intent) {
+        while(true) {
+            //SensorDataCollector is doing the work and is called in onCreate
+        }
+
+    }
+}

code/lukas/SensorDataCollector/app/src/main/java/com/koeping/lukas/sensordatacollector/Sensors.java

@@ -0,0 +1,75 @@
+package com.koeping.lukas.sensordatacollector;
+
+import android.hardware.Sensor;
+
+public enum Sensors {
+    ACCELEROMETER("Accelerometer",0,3, Sensor.TYPE_ACCELEROMETER),
+    LINEAR_ACCELEROMETER("LinearAccelerometer",1,3, Sensor.TYPE_LINEAR_ACCELERATION),
+    GRAVITY("Gravity",2,3, Sensor.TYPE_GRAVITY),
+    GYROSCOPE("Gyroscope",3,3, Sensor.TYPE_GYROSCOPE),
+    MAGNETOMETER("Magnetometer", 4,3, Sensor.TYPE_MAGNETIC_FIELD),
+    ROTATION_MATRIX("RotationMatrix", 5, 16, Sensor.TYPE_GRAVITY),
+    ORIENTATION("Orientation", 6, 3, Sensor.TYPE_GRAVITY),
+    BAROMETER("Barometer", 7, 3, Sensor.TYPE_PRESSURE);
+
+    private int pos;
+    private int nValues;
+    private String name;
+    private int sensorType;
+    private Sensor sensor;
+    private float[] data;
+
+
+    private Sensors(String name, int pos, int nValues, int sensorType) {
+        this.pos = pos;
+        this.nValues = nValues;
+        this.name = name;
+        this.sensorType = sensorType;
+    }
+
+    public int getNValues() {
+        return this.nValues;
+    }
+
+    public int getPos() {
+        return this.pos;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public int getSensorType() {
+        return this.sensorType;
+    }
+
+    public void setSensor(Sensor s) {
+        this.sensor = s;
+    }
+
+    public Sensor getSensor() {
+        return this.sensor;
+    }
+
+    public void setData(float[] data) {
+        this.data = data;
+    }
+
+    public float[] getData() {
+        return this.data;
+    }
+
+    public static String[] getAllNames() {
+        Sensors[] allSensors = Sensors.values();
+        String[] names = new String[allSensors.length];
+
+        for(int i = 0; i < names.length; i++) {
+            names[i] = allSensors[i].getName();
+        }
+        return names;
+    }
+
+
+
+
+}

code/lukas/SensorDataCollector/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingBottom="@dimen/activity_vertical_margin"
+    android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    tools:context="com.koeping.lukas.sensordatacollector.MainActivity">
+
+
+    <TextView
+        android:id="@+id/event_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Current Moving Mode" />
+
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerVertical="true"
+        android:orientation="vertical">
+
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_centerVertical="true"
+            android:orientation="horizontal">
+
+            <Button
+                android:id="@+id/stairs_up_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Stairs Up"
+                android:textSize="14sp"
+                />
+
+            <Button
+                android:id="@+id/stairs_down_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Stairs Down"
+                android:textSize="14sp"
+                />
+
+
+        </LinearLayout>
+
+
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_centerVertical="true"
+            android:orientation="horizontal">
+
+
+            <Button
+                android:id="@+id/walk_slow_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Walk slow"
+                android:textSize="14sp"
+                />
+
+            <Button
+                android:id="@+id/walk_normal_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Walk Normal"
+                android:textSize="14sp"
+                />
+
+            <Button
+                android:id="@+id/walk_fast_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Walk fast"
+                android:textSize="14sp"
+                />
+
+        </LinearLayout>
+
+
+        <Button
+            android:id="@+id/stand_button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:onClick="markEvent"
+            android:text="Stand"
+            android:textSize="14sp"
+            />
+
+
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_centerVertical="true"
+            android:orientation="horizontal">
+
+
+            <Button
+                android:id="@+id/elevator_up_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Elevator Up"
+                android:textSize="14sp"
+                />
+
+
+            <Button
+                android:id="@+id/elevator_down_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Elevator Down"
+                android:textSize="14sp"
+                />
+
+        </LinearLayout>
+
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_centerVertical="true"
+            android:orientation="horizontal">
+
+
+            <Button
+                android:id="@+id/undefined_button"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:onClick="markEvent"
+                android:text="Undefined"
+                android:textSize="14sp"
+                />
+
+        </LinearLayout>
+
+
+
+    </LinearLayout>
+
+
+    <Button
+        android:id="@+id/recording_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_centerHorizontal="true"
+        android:onClick="startStopRecording"
+        android:text="Start\nRecording"
+        android:textSize="12sp"
+        />
+
+
+</RelativeLayout>

code/lukas/SensorDataCollector/app/src/main/res/values-w820dp/dimens.xml

@@ -0,0 +1,6 @@
+<resources>
+    <!-- Example customization of dimensions originally defined in res/values/dimens.xml
+         (such as screen margins) for screens with more than 820dp of available width. This
+         would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively). -->
+    <dimen name="activity_horizontal_margin">64dp</dimen>
+</resources>

code/lukas/SensorDataCollector/app/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#3F51B5</color>
+    <color name="colorPrimaryDark">#303F9F</color>
+    <color name="colorAccent">#FF4081</color>
+</resources>

code/lukas/SensorDataCollector/app/src/main/res/values/dimens.xml

@@ -0,0 +1,5 @@
+<resources>
+    <!-- Default screen margins, per the Android Design guidelines. -->
+    <dimen name="activity_horizontal_margin">16dp</dimen>
+    <dimen name="activity_vertical_margin">16dp</dimen>
+</resources>

code/lukas/SensorDataCollector/app/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">SensorDataCollector</string>
+</resources>

code/lukas/SensorDataCollector/app/src/main/res/values/styles.xml

@@ -0,0 +1,11 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+</resources>

code/lukas/SensorDataCollector/app/src/test/java/com/koeping/lukas/sensordatacollector/ExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.koeping.lukas.sensordatacollector;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * To work on unit tests, switch the Test Artifact in the Build Variants view.
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() throws Exception {
+        assertEquals(4, 2 + 2);
+    }
+}