Merge branch 'master' of https://git.frank-ebner.de/toni/IPIN2016

code/lukas/.gitignore

@@ -0,0 +1 @@
+__pycache__

code/lukas/ActivityRecognition_Python/Data/Fahrstuhl/Events.txt

@@ -0,0 +1,13 @@
+1460;UNDEFINED
+7609;ELEVATOR_UP
+30264;UNDEFINED
+42412;ELEVATOR_DOWN
+63334;UNDEFINED
+75247;ELEVATOR_UP
+95222;UNDEFINED
+108569;ELEVATOR_DOWN
+129666;UNDEFINED
+141531;ELEVATOR_UP
+161218;UNDEFINED
+174578;ELEVATOR_DOWN
+195029;UNDEFINED

code/lukas/ActivityRecognition_Python/Data/Standing/Events.txt

@@ -0,0 +1 @@
+3584;STAND

code/lukas/ActivityRecognition_Python/Data/Walking/Events.txt

@@ -0,0 +1,15 @@
+2348;WALK_NORMAL
+8941;UNDEFINED
+11954;WALK_NORMAL
+21541;UNDEFINED
+24198;WALK_NORMAL
+33469;UNDEFINED
+36233;WALK_NORMAL
+47991;UNDEFINED
+50356;WALK_NORMAL
+63256;UNDEFINED
+67202;WALK_NORMAL
+75750;UNDEFINED
+78141;WALK_NORMAL
+88637;UNDEFINED
+91053;WALK_NORMAL

code/lukas/ActivityRecognition_Python/Data/WalkingStairs/Events.txt

@@ -0,0 +1,61 @@
+576;UNDEFINED
+11757;STAIRS_UP
+15990;UNDEFINED
+19433;STAIRS_UP
+23657;UNDEFINED
+26566;STAIRS_UP
+30932;UNDEFINED
+34880;STAIRS_DOWN
+39065;UNDEFINED
+42106;STAIRS_DOWN
+46247;UNDEFINED
+49422;STAIRS_DOWN
+53230;UNDEFINED
+58138;STAIRS_UP
+61920;UNDEFINED
+64520;STAIRS_UP
+68571;UNDEFINED
+71272;STAIRS_UP
+75604;UNDEFINED
+79527;STAIRS_DOWN
+83243;UNDEFINED
+85661;STAIRS_DOWN
+89751;UNDEFINED
+92920;STAIRS_DOWN
+96766;UNDEFINED
+100924;STAIRS_UP
+104880;UNDEFINED
+107871;STAIRS_UP
+111861;UNDEFINED
+114536;STAIRS_UP
+118601;UNDEFINED
+122589;STAIRS_DOWN
+126208;UNDEFINED
+129174;STAIRS_DOWN
+133249;UNDEFINED
+136649;STAIRS_DOWN
+140090;UNDEFINED
+143964;STAIRS_UP
+147780;UNDEFINED
+150738;STAIRS_UP
+154819;UNDEFINED
+157560;STAIRS_UP
+161867;UNDEFINED
+165723;STAIRS_DOWN
+169269;UNDEFINED
+172363;STAIRS_DOWN
+176313;UNDEFINED
+179102;STAIRS_DOWN
+182750;UNDEFINED
+187214;STAIRS_UP
+190970;UNDEFINED
+194485;STAIRS_UP
+198564;UNDEFINED
+201720;STAIRS_UP
+205693;UNDEFINED
+209273;STAIRS_DOWN
+212737;UNDEFINED
+216170;STAIRS_DOWN
+219842;UNDEFINED
+223507;STAIRS_DOWN
+227271;UNDEFINED

code/lukas/ActivityRecognition_Python/DataReader.py

@@ -0,0 +1,63 @@
+import numpy as np
+import pandas as pd
+
+
+data_paths = ["Data/WalkingStairs", "Data/Standing",
+              "Data/Walking", "Data/Fahrstuhl"]
+
+
+def read_data_files(path):
+    accelerometer = pd.read_csv(
+        path + "/Accelerometer.csv", sep=";", skiprows=1, header=0, names=["t", "ax", "ay", "az"])
+
+    barometer = pd.read_csv(path + "/Barometer.csv", sep=";",
+                            skiprows=1, header=0, names=["t", "bx", "by", "bz"])
+
+    events = pd.read_csv(path + "/Events.txt", sep=";",
+                         skiprows=0, header=None, names=["t", "event"])
+
+    data = pd.merge(accelerometer, barometer, on="t", how="outer")
+    data = pd.merge(data, events, on="t", how="outer")
+    data = data.sort_values('t')
+
+    # Fill all nan values in event with the last known event
+    data['event'] = data['event'].fillna(method='pad')
+
+    # Add additional magnitude column
+    data['magnitude'] = np.sqrt(data['ax']**2 + data['ay']**2 + data['az']**2)
+
+    return data
+
+
+def increment_timestamps(data_frames):
+    """
+    data_frames: list
+    """
+    max_t = 0
+    for frame in data_frames:
+        frame['t'] += max_t
+        max_t = frame['t'].iloc[-1]
+
+    return data_frames
+
+
+def merge_data_frames(data_frames):
+    df = pd.DataFrame()
+
+    for frame in data_frames:
+        df = df.append(frame, ignore_index=True)
+
+    return df
+
+
+def load_all_data():
+    print("Loading data files...")
+    d = []
+    for path in data_paths:
+        data = read_data_files(path)
+        d.append(data)
+
+    d = increment_timestamps(d)
+    data = merge_data_frames(d)
+
+    return data

code/lukas/ActivityRecognition_Python/Main.py

@@ -0,0 +1,242 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+np.set_printoptions(formatter={'float_kind': '{:8f}'.format})
+from DataReader import load_all_data
+
+"""
+Data Preprocessing
+"""
+
+# load the data using DataReader
+data = load_all_data()
+
+# In the following I use pandas to structure the data for processing
+
+# Split data regarding activities
+standing_df = data[data['event'] == 'STAND']
+stairs_up_df = data[data['event'] == 'STAIRS_UP']
+stairs_down_df = data[data['event'] == 'STAIRS_DOWN']
+walk_normal_df = data[data['event'] == 'WALK_NORMAL']
+elevator_up_df = data[data['event'] == 'ELEVATOR_UP']
+elevator_down_df = data[data['event'] == 'ELEVATOR_DOWN']
+
+
+# Get the biggest timestamp
+maxtime = data.iloc[-1].t
+
+# Split data in sliding windows
+INTERVAL_SIZE = 1000
+
+
+# define start and end times for each interval and remove the first second
+# due to bad data during recording
+start = np.arange(1000, maxtime - INTERVAL_SIZE,
+                  INTERVAL_SIZE / 2)
+end = np.arange(1000 + INTERVAL_SIZE, maxtime, INTERVAL_SIZE / 2)
+
+# Pairs of start and end times of every interval
+start_end = np.vstack((start, end)).T
+
+
+def extract_intervals(activity_df, start_end):
+    intervals = []
+    for ii in start_end:
+
+        df = activity_df[(activity_df['t'] > ii[0]) &
+                         (activity_df['t'] <= ii[1])]
+        # only include the dataframe if it contains values
+        if df.size > 0:
+            intervals.append(df)
+
+    return intervals
+
+stand_intervals = extract_intervals(standing_df, start_end)
+stairs_up_intervals = extract_intervals(stairs_up_df, start_end)
+stairs_down_intervals = extract_intervals(stairs_down_df, start_end)
+walk_normal_intervals = extract_intervals(walk_normal_df, start_end)
+elevator_up_intervals = extract_intervals(elevator_up_df, start_end)
+elevator_down_intervals = extract_intervals(elevator_down_df, start_end)
+
+
+# Calculate features
+# from feature_calculator import calculate_features
+
+
+def calculate_features(intervals):
+    feature_df = pd.DataFrame(
+        columns=["ax_mean", "ay_mean", "az_mean", "bx_mean",
+                 "ax_var", "ay_var", "az_var", "bx_var",
+                 'mag_mean', 'mag_var'])
+
+    all_ax = np.ndarray(len(intervals))
+
+    for ind, interval in enumerate(intervals):
+
+        ax = interval['ax'].values  # Remove nan from the data
+        ax = ax[~np.isnan(ax)]
+        ay = interval['ay'].values
+        ay = ay[~np.isnan(ay)]
+        az = interval['az'].values
+        az = az[~np.isnan(az)]
+        bx = interval['bx'].values
+        bx = bx[~np.isnan(bx)]
+
+        # subtract gravity constant from magnitude
+        magnitude = (interval['magnitude'].values) - 9.81
+        magnitude = magnitude[~np.isnan(magnitude)]
+
+        if len(bx) == 0:
+            continue
+
+            #!!!!!!!BX mean is dependent on the location and the day!!!!!Do not use as feature
+        df = pd.DataFrame({'ax_mean': [np.mean(ax)],
+                           'ay_mean': [np.mean(ay)],
+                           'az_mean': [np.mean(az)],
+                           'ax_var': [np.var(ax)],
+                           'ay_var': [np.var(ay)],
+                           'az_var': [np.var(az)],
+                           'bx_var': [np.var(bx)],
+                           'bx_diff': [bx[0] - bx[-1]],
+                           'mag_mean': [np.mean(magnitude)],
+                           'mag_var': [np.var(magnitude)],
+                           'mag_max': [np.max(magnitude)],
+                           'mag_min': [np.min(magnitude)],
+                           'mag_diff': [np.max(magnitude) - np.min(magnitude)]
+                           })
+
+        # skip dataframe if it contains nan
+        if df.isnull().any().any():
+            continue
+
+        feature_df = feature_df.append(df)
+
+    return feature_df
+
+
+print("Calculating features...")
+features_stand = calculate_features(stand_intervals)
+features_stairs_up = calculate_features(stairs_up_intervals)
+features_stairs_down = calculate_features(stairs_down_intervals)
+features_walk_normal = calculate_features(walk_normal_intervals)
+features_elevator_up = calculate_features(elevator_up_intervals)
+features_elevator_down = calculate_features(elevator_down_intervals)
+
+
+# Manually select some features
+features = ["mag_var", "bx_diff"]
+
+features_stand = features_stand[features]
+features_stairs_up = features_stairs_up[features]
+features_stairs_down = features_stairs_down[features]
+features_walk_normal = features_walk_normal[features]
+features_elevator_up = features_elevator_up[features]
+features_elevator_down = features_elevator_down[features]
+
+
+# Create labels
+label_stand = np.full((len(features_stand), ), 1, dtype=np.int)
+label_stairs_up = np.full((len(features_stairs_up), ), 2, dtype=np.int)
+label_stairs_down = np.full((len(features_stairs_down), ), 3, dtype=np.int)
+label_walk_normal = np.full((len(features_walk_normal), ), 4, dtype=np.int)
+label_elevator_up = np.full((len(features_elevator_up), ), 5, dtype=np.int)
+label_elevator_down = np.full((len(features_elevator_down), ), 6, dtype=np.int)
+
+
+# Gather all feature vectors and labels in one array
+features = np.vstack((features_stand, features_stairs_up,
+                      features_stairs_down, features_walk_normal,
+                      features_elevator_up, features_elevator_down))
+
+# Scale features
+from sklearn import preprocessing
+features_scaled = preprocessing.scale(features)
+
+labels = np.hstack((label_stand, label_stairs_up,
+                    label_stairs_down, label_walk_normal,
+                    label_elevator_up, label_elevator_down))
+
+
+# Use PCA for dimesionality reduction (if necessary)
+from sklearn.decomposition import PCA
+pca = PCA(n_components=2)
+features_trans = pca.fit(features_scaled).transform(features_scaled)
+
+# Do classification
+# Split in training and testing dataset
+from sklearn import cross_validation
+
+X_train, X_test, y_train, y_test = cross_validation.train_test_split(
+    features, labels, test_size=0.5)
+
+# Train classifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.svm import SVC
+from sklearn import tree
+
+# clf = KNeighborsClassifier(n_neighbors=3)
+# clf.fit(X_train, y_train)
+
+clf = GaussianNB()
+clf.fit(X_train, y_train)
+
+# clf = SVC()
+# clf.fit(X_train, y_train)
+
+# clf = tree.DecisionTreeClassifier()
+# clf.fit(X_train, y_train)
+
+predicts = clf.predict(X_test)
+
+# Some metrics
+from sklearn.metrics import accuracy_score, classification_report, f1_score, confusion_matrix
+
+print("Accuracy score: ", accuracy_score(y_test, predicts))
+print("F1 score: ", f1_score(y_test, predicts, average=None))
+print("Classification report: \n", classification_report(y_test, predicts))
+print("Confusion matrix: \n", confusion_matrix(y_test, predicts))
+
+
+# Plot some data
+
+# wähle Merkmal
+# für jede Klasse plotte ein histogram:
+#
+# f = features_scaled[:, 2]  # feature 0
+# target_names = ["standing", "stairs_up", "stairs_down",
+#                 "walk", "elevator_up", "elevator_down"]
+# colors = ['b', 'g', 'r', 'c', 'm', 'y']
+
+# for label, color, target in zip(range(1, 7), colors, target_names):
+#     #sns.kdeplot(f[labels == label])
+#     plt.scatter(features_scaled[labels == label, 1], features_scaled[labels == label, 2],
+#                 label=target, c=color, s=30)
+
+# plt.legend()
+
+# fig, ax = plt.subplots(nrows=2, ncols=1)
+
+# ax[0].scatter(features[labels == 1, 0], features[
+#               labels == 1, 1], s=40, c="green", label="standing")
+# ax[0].scatter(features[labels == 2, 0], features[
+#               labels == 2, 1], s=40, c="blue", label="stairs_up")
+# ax[0].scatter(features[labels == 3, 0], features[
+#               labels == 3, 1], s=40, c="black", label="stairs_down")
+# ax[0].scatter(features[labels == 4, 0], features[
+#               labels == 4, 1], s=40, c="yellow", label="walk_normal")
+# ax[0].legend()
+# ax[0].set_xlabel("Mag Mean")
+# ax[0].set_ylabel("Mag_Var")
+
+# ax[1].scatter(features_trans[labels == 1, 0], features_trans[
+#               labels == 1, 1], s=40, c="green", label="standing")
+# ax[1].scatter(features_trans[labels == 2, 0], features_trans[
+#               labels == 2, 1], s=40, c="blue", label="stairs_up")
+# ax[1].scatter(features_trans[labels == 3, 0], features_trans[
+#               labels == 3, 1], s=40, c="black", label="stairs_down")
+# ax[1].scatter(features_trans[labels == 4, 0], features_trans[
+#               labels == 4, 1], s=40, c="yellow", label="walk_normal")
+# ax[1].legend()
+# ax[1].set_xlabel("First principial component")
+# ax[1].set_ylabel("Second principal component")

code/lukas/SensorDataCollector/.gitignore

@@ -0,0 +1,39 @@
+# Built application files
+*.apk
+*.ap_
+
+# Files for the Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+#Android Studio Workspace
+.idea/*
+.idea/workspace.xml
+.idea/misc.xml
+.idea/vcs.xml
+*.iml

code/lukas/SensorDataCollector/app/.gitignore

@@ -0,0 +1 @@
+/build

code/lukas/SensorDataCollector/app/build.gradle

@@ -0,0 +1,26 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.2"
+
+    defaultConfig {
+        applicationId "com.koeping.lukas.sensordatacollector"
+        minSdkVersion 21
+        targetSdkVersion 23
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(include: ['*.jar'], dir: 'libs')
+    testCompile 'junit:junit:4.12'
+    compile 'com.android.support:appcompat-v7:23.1.1'
+}

code/lukas/SensorDataCollector/app/proguard-rules.pro

@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /home/lukas/Android/Sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

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);
+    }
+}

code/lukas/SensorDataCollector/build.gradle

@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.5.0'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

code/lukas/SensorDataCollector/gradle.properties

@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true

code/lukas/SensorDataCollector/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Oct 21 11:34:03 PDT 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip

code/lukas/SensorDataCollector/gradlew

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

code/lukas/SensorDataCollector/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

code/lukas/SensorDataCollector/settings.gradle

@@ -0,0 +1 @@
+include ':app'