diff --git a/app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java b/app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
index d81a6ae..e1b6b68 100644
--- a/app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
+++ b/app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
@@ -2,8 +2,10 @@ package de.edotzlaff.schockwelle;
 
 import android.Manifest;
 import android.content.Context;
+import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.location.Location;
+import android.net.wifi.WifiManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.CountDownTimer;
@@ -63,8 +65,11 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
     private boolean useOwnGPS;
     private boolean takeGPSfromDB = true;
     private boolean tookOwnGPS = false;
+    private boolean globalShit = true;
+    private boolean permissionToWriteToDataBase = true;
 
     boolean vibrationTrigger = true;
+    boolean grabGPSandID = true;
 
 
     private DatabaseReference mDatenbank;
@@ -84,6 +89,7 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
         getLocationPermission(); //Zuerst werden die aktuellen Standortdaten ermittelt
 
         getVibrationAbility();
+        System.out.println("Global Shit: " + globalShit);
     }
 
 
@@ -108,22 +114,9 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
         }
     }
 
-    private long getTimeStampDifference(float distance)
-    {
-        long diff= 0;
-        //TODO Zeitdifferenz in Millisekunden zwischen aktuellen Uhrzeit und Vibratonszeitstempel berechnen
-
-
-        if (distance>0)
-        {
-            diff = (long)Math.round(1/(EARTHQUAKE_VELOCITY/distance));
-        }
-        return diff;
-    }
-
     private void setVibrationTimer(long msDelay, int duration, int amplitude, int index)
     {
-
+    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!setVibrationTimer wurde getriggert mit Index " + index);
         new CountDownTimer(msDelay, 1000) {
             public void onTick(long millisUntilFinished) {
                 ((TextView)   findViewById(R.id.txtSensor)).setText("Earthquake hits in " + millisUntilFinished / 1000 + " s");
@@ -133,7 +126,7 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
                 Toast.makeText(getApplicationContext(), "The Ground is shaking!", Toast.LENGTH_SHORT).show();
                 performVibration(duration, amplitude);
                 ( (TextView)   findViewById(R.id.txtSensor)).setText("No Earthquake upcoming");
-                //In DB schreiben!
+                //Hier wird tatsächlich die DB beschrieben sobald der Timer abgelaufen ist
                 setVibrationInDataBase(index);
             }
         }.start();
@@ -162,7 +155,6 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
             if(duration == 0)
             {
                 v.cancel(); //stop vibration if still running
-
                 return;
             }
 
@@ -226,7 +218,8 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
             mMap.setMyLocationEnabled(true);
         }
 
-        // Add a marker in Sydney and move the camera
+        //TODO @ Eddy: Ich denke diesen Code brauchst du noch, oder? :D
+        //Add a marker in Sydney and move the camera
         //LatLng sydney = new LatLng(-34, 151);
         //mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
         //mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
@@ -272,6 +265,9 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
     //##################################################################  ^^^^ GPS Code ^^^^  #############################################################################
     //#####################################################################################################################################################################
 
+    //#####################################################################################################################################################################
+    //##################################################################  vvv DB Code vvv  ###############################################################################
+
     //Datenbank auslesen mit Listener. D.h. es werden Daten (snapshot) ausgelesen und gleichzeitig ein Listener hinterlegt.
     //Sollten sich danach Daten zu einem beliebigen Zeitpunkt in der DB ändern, wird die Funktion "onDataChange" erneut ausgelöst und wieder Daten (snapshot) ausgelesen.
     public void getDataBaseValuesWithListener()
@@ -289,101 +285,276 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
         });
     }
 
-    public void processDataBaseUpdate (DataSnapshot data)
+    public boolean analyzeForUseOfOwnGPS(DataSnapshot data)
+    {
+        String nativeGPSString;
+        boolean nativeGPS;
+        int amountNativeGPSisTrue = 0;
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+        for (int i = 1; i <= indexMax; i++)
+        {
+            nativeGPSString = data.child("overviewnodes").child("IDG" + i).child("f_nativegps").getValue().toString();
+            if(nativeGPSString.equals("true"))
+            {
+                amountNativeGPSisTrue++;
+            }else
+            {
+                amountNativeGPSisTrue--;
+            }
+        }
+        if(amountNativeGPSisTrue == indexMax)
+        {
+            nativeGPS = true;
+        }else{
+            nativeGPS = false;
+        }
+        return nativeGPS;
+    }
+
+    public boolean analyzeIfAnroidIdIsEmpty(DataSnapshot data, int k)
+    {
+        String androidid;
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+        boolean androididempty = false;
+        for (int i = k; i <= k; i++)
+        {
+            androidid = data.child("overviewnodes").child("IDG" + i).child("a_androidid").getValue().toString();
+            if(androidid.isEmpty())
+            {
+                androididempty = true;
+            }else
+            {
+                androididempty = false;
+            }
+        }
+        return androididempty;
+    }
+
+    public boolean analyzeForOwnAndroidID(DataSnapshot data, int k)
+    {
+        String androididString;
+        boolean ownAndroidID = false;
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+        for (int i = k; i <= k; i++)
+        {
+            androididString = data.child("overviewnodes").child("IDG" + i).child("a_androidid").getValue().toString();
+            if(androididString.equals(getandroidid()))
+            {
+                ownAndroidID = true;
+            }else
+            {
+                ownAndroidID = false;
+            }
+        }
+        return ownAndroidID;
+    }
+
+    public boolean analyzeForStateOfVibration(DataSnapshot data, int k)
+    {
+        String vibrationString;
+        boolean stateOfVibration = false;
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+        for (int i = k; i <= k; i++)
+        {
+            vibrationString = data.child("overviewnodes").child("IDG" + i).child("g_vibration").getValue().toString();
+            if(vibrationString.equals("true"))
+            {
+                stateOfVibration = true;
+            }else
+            {
+                stateOfVibration = false;
+            }
+        }
+        return stateOfVibration;
+    }
+
+    public boolean analyzeForExisitingGPSvalues(DataSnapshot data, int k)
     {
         String breitengradString;
         String laengengradString;
-        String vibrationString;
-        String androidid;
-        int vibratingDevices = 0;
-
-        for (int i = 1; i<=4; i++)
+        boolean bothGPSvaluesExist = false;
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+        for (int i = k; i <= k; i++)
         {
-            breitengradString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("breitengrad").getValue().toString();
-            laengengradString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("laengengrad").getValue().toString();
-
-            androidid = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("androidid").getValue().toString();
-            vibrationString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("vibration").getValue().toString();
-
-            if(!androidid.isEmpty())
+            breitengradString = data.child("overviewnodes").child("IDG" + i).child("d_breitengrad").getValue().toString();
+            laengengradString = data.child("overviewnodes").child("IDG" + i).child("e_laengengrad").getValue().toString();
+            if(!breitengradString.isEmpty() && !laengengradString.isEmpty())
             {
-                //System.out.println("Index " + i + " ist nicht leer");
-                if(vibrationString == "false")
+                bothGPSvaluesExist = true;
+            }else
+            {
+                bothGPSvaluesExist = false;
+            }
+        }
+        return bothGPSvaluesExist;
+    }
+
+    public void processDataBaseUpdate (DataSnapshot data)
+    {
+
+        int indexMax = (int) data.child("overviewnodes").getChildrenCount();
+
+        //Festellen ob DB oder eigene GPS-Daten verwendet werden sollen
+        if(analyzeForUseOfOwnGPS(data))
+        {
+            useOwnGPS = true;
+        }
+        else
+        {
+            useOwnGPS = false;
+        }
+
+        //Wichtig zur Verwendung von GPS-Daten explizit aus der Datenbank
+        if(!useOwnGPS && grabGPSandID)
+        {
+            for (int f = 1; f<=indexMax; f++)
+            {
+                if(f>=2 && f<=indexMax)
                 {
-                    //System.out.println("Index " + i + " Vibration ist false");
-                    continue;
-                }
-                else
-                {
-                    //System.out.println("Index " + i + " Vibration ist true");
-                    if(androidid.equals(getandroidid()))
+                    if(analyzeIfAnroidIdIsEmpty(data,f))
                     {
-                        //System.out.println("Index " + i + " Vibration ist von mir. Falscher Alarm");
-                        vibrationTrigger = false;
+                        String breitengradString = data.child("overviewnodes").child("IDG" + f).child("d_breitengrad").getValue().toString();
+                        String laengengradString = data.child("overviewnodes").child("IDG" + f).child("e_laengengrad").getValue().toString();
+                        breitengrad = Double.parseDouble(breitengradString);
+                        laengengrad = Double.parseDouble(laengengradString);
+                        allocateIDtoDatabaseSlot(f);
+                        grabGPSandID = false;
                         break;
                     }
-                    else
-                    {
-                        //System.out.println("Index " + i + " Vibration ist nicht von mir. Breitengrad und Laegengrad von Vibrationsquelle bestimmen.");
-                        breitengradQuellVibration = breitengradString;
-                        laengengradQuellVibration = laengengradString;
-                        vibratingDevices++;
-                        continue;
-                    }
-                }
-            }
-            else
-            {
-                //System.out.println("Index " + i + " ist leer");
-                if(androidid.isEmpty() && !breitengradString.isEmpty() && !laengengradString.isEmpty() && vibrationString.equals("false") && takeGPSfromDB)
-                {
-                    System.out.println("Index " + i +" -> Leere AdnroidID. Breitengrad und Laengengrad sind belegt. Vibration ist false. Kann als eigenes Gerät beansprucht werden.");
-                    System.out.println("Index " + i +" -> Übernehme Breitengrad: " + breitengradString + " und Laengengrad: " + laengengradString + " als eigene Position.");
-                    breitengrad = Double.parseDouble(breitengradString);
-                    laengengrad = Double.parseDouble(laengengradString);
-                    useOwnGPS = false;
-                    takeGPSfromDB = false;
-                }else
-                {
-                    if(!tookOwnGPS && takeGPSfromDB)
-                    {
-                        //System.out.println("Nutze eigene DB. Bin bei Index " + i + " ++++++++++++++++++++++++++++++++++++++++++++");
-                        tookOwnGPS = true;
-                        useOwnGPS = true;
-                    }
-                }
-
-                if(vibrationTrigger == true && (vibratingDevices == 1))
-                {
-                    //System.out.println("#########Freigabe zum Schreiben in DB mit Index " + i + " liegt vor. Schreibe nun... !!!!!#####################");
-                    /*
-                    System.out.println("currentLocation.getLatitude():                 " + currentLocation.getLatitude());
-                    System.out.println("currentLocation.getLongitude():                " + currentLocation.getLongitude());
-                    System.out.println("Double.parseDouble(breitengradQuellVibration): " + Double.parseDouble(breitengradQuellVibration));
-                    System.out.println("Double.parseDouble(laengengradQuellVibration): " + Double.parseDouble(laengengradQuellVibration));
-                    System.out.println("######################################################################################################################################################################");
-                     */
-
-                    vibrationTrigger = false;
-                    float distanceToEarthquake;
-                    distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
-                    System.out.println("Distance to Earthquake: " + distanceToEarthquake);
-                    long wellenAusbreitungsGeschwindigkeit = 4500;    //Meter die Sekunde
-                    long delayInSeconds = (long) distanceToEarthquake/wellenAusbreitungsGeschwindigkeit; //s
-                    long delayInMilliSeconds = delayInSeconds*1000;
-                    setVibrationTimer(delayInMilliSeconds,1500,255,i);
-                    //setVibrationInDataBase(i);
-                    break;
                 }
             }
         }
 
-        //TODO Weiterer Code von Patrick. @Aron Anschauen ob dieser noch verwendet werden muss da paar Sachen schon in dieser Version umgesetzt worde sind.
+
+        //Hier sind die Schreibregeln für die DB definiert wenn Sensor aktiviert ist
+        for (int f = 1; f<=indexMax && permissionToWriteToDataBase; f++)
+        {
+            if((!analyzeIfAnroidIdIsEmpty(data,f) && !analyzeForOwnAndroidID(data,f) && analyzeForStateOfVibration(data,f) && analyzeForExisitingGPSvalues(data,f) && permissionToWriteToDataBase))
+            {
+                String breitengradString = data.child("overviewnodes").child("IDG" + f).child("d_breitengrad").getValue().toString();
+                String laengengradString = data.child("overviewnodes").child("IDG" + f).child("e_laengengrad").getValue().toString();
+                breitengradQuellVibration = breitengradString;
+                laengengradQuellVibration = laengengradString;
+
+                f=1;
+                if(analyzeForOwnAndroidID(data,f))
+                {
+                    if (!analyzeForStateOfVibration(data,f))
+                    {
+                        if(analyzeForExisitingGPSvalues(data,f))
+                        {
+                            float distanceToEarthquake;
+                            distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
+                            long wellenAusbreitungsGeschwindigkeit = 4500;    //Meter die Sekunde
+                            long delayInSeconds = (long) distanceToEarthquake/wellenAusbreitungsGeschwindigkeit; //s
+                            long delayInMilliSeconds = delayInSeconds*1000;
+                            setVibrationTimer(delayInMilliSeconds,1500,255,f);
+                            permissionToWriteToDataBase = false;
+                            break;
+                        }
+                        else{
+                            System.out.println("###Index " + f + " >>>Habe keine GPS daten...");
+                        }
+                    }else{
+                        System.out.println(">>>Index " + f + " >>>Meine Vibration wurde breits true gesetzt. Falscher Alarm");
+                        break;
+                    }
+                }
+                else
+                {
+                    for(f = f; f<=indexMax; f++)
+                    {
+                        if(analyzeIfAnroidIdIsEmpty(data,f) || analyzeForOwnAndroidID(data,f))
+                        {
+                            float distanceToEarthquake;
+                            distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
+                            long wellenAusbreitungsGeschwindigkeit = 4500;    //Meter die Sekunde
+                            long delayInSeconds = (long) distanceToEarthquake/wellenAusbreitungsGeschwindigkeit; //s
+                            long delayInMilliSeconds = delayInSeconds*1000;
+                            setVibrationTimer(delayInMilliSeconds,1500,255,f);
+                            permissionToWriteToDataBase = false;
+                            break;
+                        }
+
+                        if(f == indexMax && !analyzeIfAnroidIdIsEmpty(data,f))
+                        {
+                           System.out.println(">>>Index " + f + " >>>Konnte keine freien Slot finden");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    public void allocateIDtoDatabaseSlot(int k)
+    {
+        mDatenbank = FirebaseDatabase.getInstance().getReference();
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("a_androidid").setValue(getandroidid());
+    }
+
+
+    public void setVibrationInDataBase(int k)
+    {
+        mDatenbank = FirebaseDatabase.getInstance().getReference();
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("a_androidid").setValue(getandroidid());
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            mDatenbank.child("overviewnodes").child("IDG" + k).child("b_localdatetime").setValue(LocalDateTime.now().toString());
+        }
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("c_ip").setValue(getDeviceIpAdress());
+        if (useOwnGPS)
+        {
+            mDatenbank.child("overviewnodes").child("IDG" + k).child("d_breitengrad").setValue(currentLocation.getLatitude());    //aktueller Breitengrad
+            mDatenbank.child("overviewnodes").child("IDG" + k).child("e_laengengrad").setValue(currentLocation.getLongitude());   //aktueller Längergrad
+        }else{
+            mDatenbank.child("overviewnodes").child("IDG" + k).child("d_breitengrad").setValue(breitengrad);    //aktueller Breitengrad
+            mDatenbank.child("overviewnodes").child("IDG" + k).child("e_laengengrad").setValue(laengengrad);   //aktueller Längergrad
+        }
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("f_nativegps").setValue(false);
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("g_vibration").setValue(true);
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("h_timestamp").setValue(Calendar.getInstance().getTimeInMillis());     //aktueller Zeitstempel wird in Datenbank eingetragen
+        mDatenbank.child("overviewnodes").child("IDG" + k).child("i_amplitude").setValue(1000);
+    }
+
+    public String getDeviceIpAdress ()
+    {
+        WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
+        int ip = wm.getConnectionInfo().getIpAddress();
+        String ipAddress = String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff));
+        return ipAddress;
+    }
+
+    public String getandroidid ()
+    {
+        return Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
+    }
+
+    public void getDataBaseFailure (DatabaseError error)
+    {
+        System.out.println("Fehler");
+        Log.w("Datenbankfehler", error.toException());
+    }
+
+    private float distance(double currentlatitude, double currentlongitude, double originLat, double originLon) {
+
+        float[] results = new float[1];
+        Location.distanceBetween(currentlatitude, currentlongitude, originLat, originLon, results);
+        float distanceInMeters = results[0];
+
+        return distanceInMeters;
+    }
+
+    //##################################################################  ^^^^ DB Code ^^^^  #############################################################################
+    //#####################################################################################################################################################################
+
+    //TODO @Patrick: Ist backupVonAltemCode noch relevanter Code wenn Viration und das Schreiben in die Datenbank passt und synchron abläuft? Falls nichts relevant, können wir das ja löschen ;)
+    public void backupVonAltemCode (DataSnapshot data)
+    {
         /*
         //####### Auslesen für boolean-Werte #######:
         int i = 1;
-        String vibrationString = data.child("overview").child("IDG").child("vibration").getValue().toString();
-        String amplitudeString = data.child("overview").child("IDG").child("amplitude").getValue().toString();
+        String vibrationString = data.child("overviewnodes").child("IDG").child("vibration").getValue().toString();
+        String amplitudeString = data.child("overviewnodes").child("IDG").child("amplitude").getValue().toString();
         boolean vibration;
         if(vibrationString.equals("true")){
             vibration = true;
@@ -402,51 +573,19 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
          */
     }
 
-    public void setVibrationInDataBase(int k)
+    //TODO @Patrick: Ist getTimeStampDifference noch relevanter Code wenn Viration und das Schreiben in die Datenbank passt und synchron abläuft? Falls nichts relevant, können wir das ja löschen ;)
+    private long getTimeStampDifference(float distance)
     {
-        mDatenbank = FirebaseDatabase.getInstance().getReference();
-        mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("ip").setValue(k + "0.00.00.000");
-        mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("vibration").setValue(true);
-        mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("timestamp").setValue(Calendar.getInstance().getTimeInMillis());     //aktueller Zeitstempel wird in Datenbank eingetragen
+        long diff= 0;
 
-        if (useOwnGPS)
+        if (distance>0)
         {
-            //System.out.println("YYYcurrentLocation.getLatitude():                 " + currentLocation.getLatitude());
-            //System.out.println("YYYcurrentLocation.getLongitude():                " + currentLocation.getLongitude());
-            mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("breitengrad").setValue(currentLocation.getLatitude());    //aktueller Breitengrad
-            mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("laengengrad").setValue(currentLocation.getLongitude());   //aktueller Längergrad
-        }else{
-            //System.out.println("YYYbreitengrad:                 " + breitengrad);
-            //System.out.println("YYYlaengengrad:                 " + laengengrad);
-            mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("breitengrad").setValue(breitengrad);    //aktueller Breitengrad
-            mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("laengengrad").setValue(laengengrad);   //aktueller Längergrad
+            diff = (long)Math.round(1/(EARTHQUAKE_VELOCITY/distance));
         }
-        mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("amplitude").setValue(1001);
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("localdatetime").setValue(LocalDateTime.now().toString());
-        }
-        mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + k).child("androidid").setValue(getandroidid());
-    }
-
-    public String getandroidid ()
-    {
-        return Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
-    }
-
-    public void getDataBaseFailure (DatabaseError error)
-    {
-        System.out.println("Fehler");
-        Log.w("Datenbankfehler", error.toException());
-    }
-
-    //TODO Edward Dauer für Timer berechnen bis Smartphone vibriert
-
-    private float distance(double currentlatitude, double currentlongitude, double originLat, double originLon) {
-
-        float[] results = new float[1];
-        Location.distanceBetween(currentlatitude, currentlongitude, originLat, originLon, results);
-        float distanceInMeters = results[0];
-
-        return distanceInMeters;
+        return diff;
     }
 }
+
+
+
+