AbdulajevAr51780
/
mMDT5_PR_MSY1_Gruppe1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Alpha Version der Schockwellen App

master
Raz492 2 years ago
parent
344f6b4514
commit
84ac745cec
13 changed files with 748 additions and 141 deletions
Split View Show Diff Stats
  1. 1
    1
      .idea/compiler.xml
  2. 1
    1
      .idea/misc.xml
  3. 10
    0
      .idea/runConfigurations.xml
  4. 6
    2
      app/src/main/AndroidManifest.xml
  5. 22
    6
      app/src/main/java/de/edotzlaff/schockwelle/Devices.java
  6. 259
    40
      app/src/main/java/de/edotzlaff/schockwelle/EarthquakeMapsActivity.java
  7. 140
    36
      app/src/main/java/de/edotzlaff/schockwelle/MainActivity.java
  8. 266
    48
      app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
  9. 5
    5
      app/src/main/res/layout/activity_earthquake_maps.xml
  10. 26
    0
      app/src/main/res/layout/activity_main.xml
  11. 10
    0
      app/src/main/res/values/strings.xml
  12. 1
    1
      build.gradle
  13. 1
    1
      gradle/wrapper/gradle-wrapper.properties

+ 1
- 1
.idea/compiler.xml View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<bytecodeTargetLevel target="1.8" />
<bytecodeTargetLevel target="11" />
</component>
</project>

+ 1
- 1
.idea/misc.xml View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/build/classes" />
</component>
<component name="ProjectType">

+ 10
- 0
.idea/runConfigurations.xml View File

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RunConfigurationProducerService">
<option name="ignoredProducers">
<set>
<option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
</set>
</option>
</component>
</project>

+ 6
- 2
app/src/main/AndroidManifest.xml View File

@@ -11,6 +11,8 @@
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<uses-permission android:name="android.permission.VIBRATE" />

<application
android:allowBackup="true"
android:icon="@mipmap/schockicon"
@@ -36,7 +38,7 @@
android:label="@string/title_activity_sensor_maps"></activity>
<activity
android:name=".EarthquakeMapsActivity"
android:label="@string/title_activity_earthquake_maps" />
android:label="@string/title_activity_earthquake_maps"/>
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
@@ -46,4 +48,6 @@
</activity>
</application>

</manifest>
</manifest>

<!--android:parentActivityName=".MainActivity"-->

+ 22
- 6
app/src/main/java/de/edotzlaff/schockwelle/Devices.java View File

@@ -1,5 +1,7 @@
package de.edotzlaff.schockwelle;

import java.time.LocalDateTime;

public class Devices {
private String ip;
private boolean vibration;
@@ -7,18 +9,23 @@ public class Devices {
private double breitengrad;
private double laengengrad;
private int amplitude;
private String localdatetime;
private boolean idvergeben;
private String androidid;

public Devices() {

}

public Devices(String ip, boolean vibration, long timestamp, double breitengrad, double laengengrad, int amplitude) {
public Devices(String ip, boolean vibration, long timestamp, double breitengrad, double laengengrad, int amplitude, String localdatetime, String androidid) {
this.ip = ip;
this.vibration = vibration;
this.timestamp = timestamp;
this.breitengrad = breitengrad;
this.laengengrad = laengengrad;
this.amplitude = amplitude;
this.localdatetime = localdatetime;
this.androidid = androidid;
}

public String getIp() {
@@ -28,7 +35,6 @@ public class Devices {
this.ip = ip;
}


public boolean isVibration() {
return vibration;
}
@@ -36,7 +42,6 @@ public class Devices {
this.vibration = vibration;
}


public long getTimestamp() {
return timestamp;
}
@@ -44,7 +49,6 @@ public class Devices {
this.timestamp = timestamp;
}


public double getBreitengrad() {
return breitengrad;
}
@@ -52,7 +56,6 @@ public class Devices {
this.breitengrad = breitengrad;
}


public double getLaengengrad() {
return laengengrad;
}
@@ -60,11 +63,24 @@ public class Devices {
this.laengengrad = laengengrad;
}


public int getAmplitude() {
return amplitude;
}
public void setAmplitude(int amplitude) {
this.amplitude = amplitude;
}

public String getLocaldatetime() {
return localdatetime;
}
public void setLocaldatetime(String localdatetime) {
this.localdatetime = localdatetime;
}

public String getAndroidid() {
return androidid;
}
public void setAndroidid(String androidid) {
this.androidid = androidid;
}
}

+ 259
- 40
app/src/main/java/de/edotzlaff/schockwelle/EarthquakeMapsActivity.java View File

@@ -1,11 +1,23 @@
package de.edotzlaff.schockwelle;

import android.Manifest;
import android.app.ActionBar;
import android.content.Context;
import android.content.pm.PackageManager;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.location.Location;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.SystemClock;
import android.provider.ContactsContract;
import android.provider.Settings;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
@@ -28,39 +40,151 @@ import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;

import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.Date;
import java.util.Objects;

public class EarthquakeMapsActivity extends FragmentActivity implements OnMapReadyCallback {

private static final String TAG = "MainActivity";
private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;

//vars
private Boolean mLocationPermissionsGranted = false;
private GoogleMap mMap;
private FusedLocationProviderClient mFusedLocationProviderClient;

private DatabaseReference mDatenbank;

//Date currentTime; //Workaround für Crash: currentTime nicht als Datum sondern als Long zeitstempel
Long currentTime;
Location currentLocation;
private DatabaseReference mDatenbank;
private double breitengrad;
private double laengengrad;
private boolean useOwnGPS;
private int indexID = 1;

//##########################################################################################################################################################################
//################################################################## vvv ShakeParameter vvv ##############################################################################
private SensorManager mSensorManager;
private static final float mUpperThreshold = 10.5f; // für Emulator auf 1.5 setzen
private static final float mLowerThreshold = 5.5f; // für Emulator auf 0.5 setzen
private static final long mShakeDetectionLockTimeMicroSeconds = 10000;
private float mAccel;
private float mAccelCurrent;
private float mAccelLast;
private boolean mShakeDetectionIsActive = false;
private boolean mShakeDetected = false;
//private boolean allowShakeEvent = true;
//################################################################## ^^^^ ShakeParameter ^^^^ ############################################################################
//##########################################################################################################################################################################


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_earthquake_maps);

getDataBaseValues(); //TODO Edward: Nur als Anmerkung, diese Methode erfolgt damit deine Methode getDeviceLocation rechtzeitig Koordinaten aus der DB bekommt
//TODO Hast schon echt viel erledigt :D Ich habe gedacht das die Class EarthquakeMapsActivity Daten an die DB schickt und die SensorMapsActivity die Daten bekommt, ich glaub die Funktion muss in die andere Class
getDataBaseValuesNoListener();
sensorManagementInit();
getLocationPermission();
}

//#####################################################################################################################################################################
//################################################################## vvv ShakeCode vvv ##############################################################################
private void sensorManagementInit()
{
TextView txtEarthquake = (TextView) findViewById(R.id.txtEarthquake);
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Objects.requireNonNull(mSensorManager).registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
mAccel = 1f;
mAccelCurrent = SensorManager.GRAVITY_EARTH;
mAccelLast = SensorManager.GRAVITY_EARTH;
mShakeDetectionIsActive = true;
mShakeDetected = false;
}

private CountDownTimer mLockTimer = new CountDownTimer(mShakeDetectionLockTimeMicroSeconds, 1000)
{
public void onTick(long millisUntilFinished) {
((TextView) findViewById(R.id.txtEarthquake)).setText("Earthquake started! Detection locked for " + millisUntilFinished / 1000 + " s");
}

public void onFinish() {
mShakeDetectionIsActive = true;
mShakeDetected = false;
Toast.makeText(getApplicationContext(), "Shake Detection unlocked", Toast.LENGTH_SHORT).show();
( (TextView) findViewById(R.id.txtEarthquake)).setText("Shake your Smartphone for an Earthquake");
}
};


private final SensorEventListener mSensorListener = new SensorEventListener() {
@Override
public void onSensorChanged(SensorEvent event) {
float x = event.values[0];
float y = event.values[1];
float z = event.values[2];
mAccelLast = mAccelCurrent;
mAccelCurrent = (float) Math.sqrt((double) (x * x + y * y + z * z));
float delta = mAccelCurrent - mAccelLast;
mAccel = mAccel * 0.9f + delta;
// Log.d(TAG,"mAccel: "+ mAccel);
if (mShakeDetectionIsActive) {
if(Math.abs(mAccel) > mUpperThreshold) {
new CountDownTimer(50, 10) {

public void onTick(long millisUntilFinished) {
if (Math.abs(mAccel) > mUpperThreshold) {
mShakeDetectionIsActive = false;
} else if (Math.abs(mAccel) < mLowerThreshold) {
mShakeDetectionIsActive = true;
this.cancel();
}
}

public void onFinish() {
if (Math.abs(mAccel) > mUpperThreshold) {
mShakeDetectionIsActive = false;
mShakeDetected = true;
Toast.makeText(getApplicationContext(), "Shake event detected", Toast.LENGTH_SHORT).show();
writeEarthquakeToDatabase();
mLockTimer.start();
} else {
mShakeDetectionIsActive = true;
mShakeDetected = false;
}
}
}.start();
}
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
};

private void writeEarthquakeToDatabase()
{
setDataBaseValues();
}

@Override
protected void onResume() {
mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_NORMAL);
super.onResume();
}
@Override
protected void onPause() {
mSensorManager.unregisterListener(mSensorListener);
super.onPause();
}
//################################################################## ^^^^ ShakeCode ^^^^ ############################################################################
//#####################################################################################################################################################################

//#####################################################################################################################################################################
//################################################################## vvv GPS Code vvv ###############################################################################

private void getLocationPermission() {
String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
@@ -80,14 +204,12 @@ public class EarthquakeMapsActivity extends FragmentActivity implements OnMapRea
case LOCATION_PERMISSION_REQUEST_CODE: {
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
mLocationPermissionsGranted = true;
//initalize or map
initMap();
initMap(); //initalize or map
}
}
}
}


private void initMap() {
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
@@ -104,7 +226,6 @@ public class EarthquakeMapsActivity extends FragmentActivity implements OnMapRea
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

return;
}
mMap.setMyLocationEnabled(true);
@@ -128,13 +249,17 @@ public class EarthquakeMapsActivity extends FragmentActivity implements OnMapRea
public void onComplete(@NonNull Task task) {
if (task.isSuccessful()){
currentLocation = (Location) task.getResult();
//currentTime = Calendar.getInstance().getTime(); //Workaround für Crash: currentTime nicht als Datum sondern als Long zeitstempel
currentTime = Calendar.getInstance().getTimeInMillis();
Toast.makeText(EarthquakeMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show();
//currentTime = Calendar.getInstance().getTimeInMillis(); //verschoben in setDataBaseValues
//Toast.makeText(EarthquakeMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show(); //verschoben in setDataBaseValues
if(useOwnGPS)
{
breitengrad = currentLocation.getLatitude();
laengengrad = currentLocation.getLongitude();
}
currentLocation.setLatitude(breitengrad);
currentLocation.setLongitude(laengengrad);
setDataBaseValues(); //TODO Edward: Die Funktion geht jetzt. Statt Datum wird Unix Zeitstempel als Long Typ verwendet
moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
//setDataBaseValues(); //Wurde verschoben zu Methode writeEarthquakeToDatabase
}
else{
Toast.makeText(EarthquakeMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show();
@@ -152,8 +277,124 @@ public class EarthquakeMapsActivity extends FragmentActivity implements OnMapRea
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom));
}

//################################################################## ^^^^ GPS Code ^^^^ #############################################################################
//#####################################################################################################################################################################

//#####################################################################################################################################################################
//################################################################## vvv Datenbank Code vvv #########################################################################

public void getDataBaseValuesNoListener()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").get().addOnCompleteListener(new OnCompleteListener<DataSnapshot>() {
@Override
public void onComplete(@NonNull Task<DataSnapshot> task) {
if (!task.isSuccessful()) {
System.out.println("Datenbankfehler in getDataBaseValuesNoListener");
System.out.println("Error getting data: " + task.getException());
}
else {
processDataBaseValues(task.getResult());
}
}
});
}

public void processDataBaseValues (DataSnapshot data)
{
processDeviceIndex(data);
processLocation(data);
//processMessageDisplay(data);
}

public void processDeviceIndex(DataSnapshot data)
{
for (int i = 1; i<=4; i++)
{
String androidid = data.child("IDG" + i).child("androidid").getValue().toString();
if(androidid.isEmpty())
{
indexID = i;
break;
}else
{
continue;
}
}
}

public void processLocation(DataSnapshot data)
{
String breitengradString = data.child("IDG" + indexID).child("breitengrad").getValue().toString();
String laengengradString = data.child("IDG" + indexID).child("laengengrad").getValue().toString();

if(breitengradString.isEmpty() || laengengradString.isEmpty())
{
useOwnGPS = true;
}else{
useOwnGPS = false;
breitengrad = Double.parseDouble(breitengradString);
laengengrad = Double.parseDouble(laengengradString);
}
}

/*
public void processMessageDisplay(DataSnapshot data)
{
String vibrationString;
String androidid;
for (int i = 1; i<=4; i++)
{
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()) && vibrationString.equals("true"))
{
allowShakeEvent = false;
}
}
}

*/

public String getandroidid ()
{
return Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
}

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 void setDataBaseValues()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("ip").setValue(getDeviceIpAdress());
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("vibration").setValue(true);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("timestamp").setValue(Calendar.getInstance().getTimeInMillis());

currentTime = Calendar.getInstance().getTimeInMillis();
Toast.makeText(EarthquakeMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show();

mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("breitengrad").setValue(breitengrad);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("laengengrad").setValue(laengengrad);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("amplitude").setValue(1001);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("localdatetime").setValue(LocalDateTime.now().toString());
}
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + indexID).child("androidid").setValue(getandroidid());
}

//################################################################## ^^^^ Datenbank Code ^^^^ #############################################################################
//###########################################################################################################################################################################
}


//Evtl. Redundanter Code
/*
public void getDataBaseValues()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
@@ -169,31 +410,9 @@ public class EarthquakeMapsActivity extends FragmentActivity implements OnMapRea
});
}

public void processDataBaseValues (DataSnapshot data)
{
//####### Hier wird beispielweise mit IDG1 gearbeitet, sollte aber klüger ausgearbeitet werden #######:
String breitengradString = data.child("overview").child("IDG1").child("breitengrad").getValue().toString(); //TODO Aron/Team: Idee für passende ID je nach zugreifendem Gerät ==> Hardcoded oder flexibel?
String laengengradString = data.child("overview").child("IDG1").child("laengengrad").getValue().toString();
breitengrad = Double.parseDouble(breitengradString);
laengengrad = Double.parseDouble(laengengradString);
}

public void getDataBaseFailure (DatabaseError error)
{
System.out.println("Fehler");
System.out.println("Datenbankfehler in gerDataBaseFailure");
Log.w("Datenbankfehler", error.toException());
}


//TODO Edward: Hier ist eine beispielhafte Methode mit der du Werte in der Datenbank setzen kannst
public void setDataBaseValues()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overview").child("IDG1").child("ip").setValue("10.00.00.001");
mDatenbank.child("overview").child("IDG1").child("vibration").setValue(true);
mDatenbank.child("overview").child("IDG1").child("timestamp").setValue(currentTime); //aktueller Zeitstempel wird in Datenbank eingetragen
mDatenbank.child("overview").child("IDG1").child("breitengrad").setValue(currentLocation.getLatitude()); //aktueller Breitengrad
mDatenbank.child("overview").child("IDG1").child("laengengrad").setValue(currentLocation.getLongitude()); //aktueller Längergrad
mDatenbank.child("overview").child("IDG1").child("amplitude").setValue(1001);
}
}
*/

+ 140
- 36
app/src/main/java/de/edotzlaff/schockwelle/MainActivity.java View File

@@ -1,13 +1,17 @@
package de.edotzlaff.schockwelle;

import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.FragmentActivity;

import android.app.ActionBar;
import android.app.Dialog;
import android.content.Intent;
import android.hardware.Sensor;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.view.View;
import android.widget.Button;
@@ -15,17 +19,24 @@ import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;

public class MainActivity extends FragmentActivity {

private static final String TAG = "MainActivity";
private static final int ERROR_DIALOG_REQUEST = 9001;
private DatabaseReference mDatenbank;
String android_id;


@Override
@@ -36,29 +47,74 @@ public class MainActivity extends FragmentActivity {
if (isServiceOK()){
init();
}

deviceInitDataBase(); //TODO Edward: Mit dieser Methode wird beim Starten der App die DB mit, vorerst festen, Werten für alle IDG 1-4 initialiert
}

private void init(){

Button btnEarthquake = (Button) findViewById(R.id.btnEarthquake);
Button btnSensor = (Button) findViewById(R.id.btnSensor);
Button btnMuster = (Button) findViewById(R.id.buttonDatenBankMuster);
Button btnLeer = (Button) findViewById(R.id.buttonDatenBankLeeren);
Button btnReset = (Button) findViewById(R.id.buttonReset);

btnEarthquake.setEnabled(false);
btnEarthquake.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, EarthquakeMapsActivity.class);
btnEarthquake.setEnabled(false);
btnSensor.setEnabled(false);
startActivity(intent);
}
});

Button btnSensor = (Button) findViewById(R.id.btnSensor);
btnSensor.setEnabled(false);
btnSensor.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, SensorMapsActivity.class);
btnSensor.setEnabled(false);
btnEarthquake.setEnabled(false);
startActivity(intent);
}
});

btnMuster.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
btnEarthquake.setEnabled(true);
btnSensor.setEnabled(true);
btnLeer.setEnabled(false);
btnMuster.setEnabled(false);
btnReset.setEnabled(true);
deviceInitDataBase();
}
});

btnLeer.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
btnEarthquake.setEnabled(true);
btnSensor.setEnabled(true);
btnMuster.setEnabled(false);
btnReset.setEnabled(true);
btnLeer.setEnabled(false);
datenBankLeeren();
}
});

btnReset.setEnabled(false);
btnReset.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
getDataBaseValuesNoListener();
btnEarthquake.setEnabled(true);
btnSensor.setEnabled(true);
btnMuster.setEnabled(true);
btnLeer.setEnabled(true);
}
});

}

public boolean isServiceOK(){
@@ -84,23 +140,71 @@ public class MainActivity extends FragmentActivity {
public void deviceInitDataBase()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
Devices d1 = new Devices("10.00.00.000", false, 1623926431100L, 49.45470362290784, 11.151032510281498, 1000);
Devices d2 = new Devices("20.00.00.000", false, 1623926431200L, 40.70064147511923, -73.993767997977787, 200);
Devices d3 = new Devices("30.00.00.000", false, 1623926431300L, -33.93157129193122, 18.39666975233824, 30);
Devices d4 = new Devices("40.00.00.000", false, 1623926431400L, -33.40763257191139, -70.61870273653996, 4);
mDatenbank.child("overview").child("IDG1").setValue(d1);
mDatenbank.child("overview").child("IDG2").setValue(d2);
mDatenbank.child("overview").child("IDG3").setValue(d3);
mDatenbank.child("overview").child("IDG4").setValue(d4);
getDataBaseValues();
Devices d1 = new Devices("10.00.00.000", false, Calendar.getInstance().getTimeInMillis(), 52.51624237821577, 13.37683380067744, 1000, LocalDateTime.now().toString(), ""); //Berlin 52.51624237821577, 13.37683380067744
Devices d2 = new Devices("20.00.00.000", false, Calendar.getInstance().getTimeInMillis(), 48.7560280895443, 11.425157702952347, 200, LocalDateTime.now().toString(),""); //Ingolstadt 48.7560280895443, 11.425157702952347
Devices d3 = new Devices("30.00.00.000", false, Calendar.getInstance().getTimeInMillis(), 48.16958655466396, 11.617418429524394, 30, LocalDateTime.now().toString(),""); //München 48.16958655466396, 11.617418429524394
Devices d4 = new Devices("40.00.00.000", false, Calendar.getInstance().getTimeInMillis(), 45.55620112204013, 12.342516140205387, 4, LocalDateTime.now().toString(),""); //Venedig 45.55620112204013, 12.342516140205387
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG1").setValue(d1);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG2").setValue(d2);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG3").setValue(d3);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG4").setValue(d4);

//Nürnberg HBF: 49.4474136331757, 11.082661293035727
}

//Datenbank auslesen OHNE Listener. D.h. es werden Daten (snapshot) ausgelesen und kein Listener hinterlegt.
//Sollten sich danach Daten zu einem beliebigen Zeitpunkt in der DB ändern, wird die Funktion "onDataChange" NICHT erneut ausgelöst.
public void getDataBaseValuesNoListener()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").get().addOnCompleteListener(new OnCompleteListener<DataSnapshot>() {
@Override
public void onComplete(@NonNull Task<DataSnapshot> task) {
if (!task.isSuccessful()) {
System.out.println("Error getting data: " + task.getException());
}
else {
testProcess(task.getResult());
}
}
});
}

public void datenBankLeeren()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
for (int i = 1; i<=4; i++)
{
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("ip").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("vibration").setValue(false);
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("timestamp").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("breitengrad").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("laengengrad").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("amplitude").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("localdatetime").setValue("");
mDatenbank.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("androidid").setValue("");
}
}

public void testProcess(DataSnapshot data)
{
mDatenbank = FirebaseDatabase.getInstance().getReference().child("overviewAronTestetInDiesemAbschnitt");
}
}




public void getDataBaseValues()
/*
//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 getDataBaseValuesListener()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot snapshot) {
processDataBaseValues(snapshot); //Daten - Snapshot, Übergabe an Methode processDataBaseValues
//testProcess(snapshot); //Daten - Snapshot, Übergabe an Methode processDataBaseValues
}
@Override
public void onCancelled(@NonNull DatabaseError error) {
@@ -108,16 +212,27 @@ public class MainActivity extends FragmentActivity {
}
});
}
*/

/*
public void getDataBaseFailure (DatabaseError error)
{
System.out.println("Fehler");
Log.w("Datenbankfehler", error.toException());
}
*/

/*
@RequiresApi(api = Build.VERSION_CODES.O)
public void processDataBaseValues (DataSnapshot data)
{
for (int i = 1; i<=4; i++) //Für alle IDG 1-4 werden Werte ausgegeben
{
//####### Auslesen für String-Werte #######:
String ipAdresse = data.child("overview").child("IDG" + i).child("ip").getValue().toString();
String ipAdresse = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("ip").getValue().toString();

//####### Auslesen für boolean-Werte #######:
String vibrationString = data.child("overview").child("IDG" + i).child("vibration").getValue().toString();
String vibrationString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("vibration").getValue().toString();
boolean vibration;
if(vibrationString == "true"){
vibration = true;
@@ -126,34 +241,23 @@ public class MainActivity extends FragmentActivity {
}

//####### Auslesen für double-Werte #######:
String breitengradString = data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString();
String laengengradString = data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString();
String breitengradString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("breitengrad").getValue().toString();
String laengengradString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("laengengrad").getValue().toString();
double breitengrad = Double.parseDouble(breitengradString);
double laengengrad = Double.parseDouble(laengengradString);

//####### Auslesen für long-Werte #######:
String timestampString = data.child("overview").child("IDG" + i).child("timestamp").getValue().toString();
String timestampString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("timestamp").getValue().toString();
long timestamp = Long.parseLong(timestampString);

//####### Auslesen für ing-Werte #######:
String amplitudeString = data.child("overview").child("IDG" + i).child("amplitude").getValue().toString();
String amplitudeString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("amplitude").getValue().toString();
int amplitude = Integer.parseInt(amplitudeString);

//####### Optional zur Kontrolle #######:
/*
System.out.println("IDG" + i + " - IP:" + data.child("overview").child("IDG" + i).child("ip").getValue().toString());
System.out.println("IDG" + i + " - Vibration:" + data.child("overview").child("IDG" + i).child("vibration").getValue().toString());
System.out.println("IDG" + i + " - Zeitstempel:" + data.child("overview").child("IDG" + i).child("timestamp").getValue().toString());
System.out.println("IDG" + i + " - Breitengrad:" + data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString());
System.out.println("IDG" + i + " - Laengengrad:" + data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString());
System.out.println("IDG" + i + " - Amplitude:" + data.child("overview").child("IDG" + i).child("amplitude").getValue().toString());
*/
//####### Auslesen für LocalDateTime#######:
String localdatetimeString = data.child("overviewAronTestetInDiesemAbschnitt").child("IDG" + i).child("localdatetime").getValue().toString();
DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
LocalDateTime localdatetime = LocalDateTime.parse(localdatetimeString, formatter);
}
}

public void getDataBaseFailure (DatabaseError error)
{
System.out.println("Fehler");
Log.w("Datenbankfehler", error.toException());
}
}
*/

+ 266
- 48
app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java View File

@@ -1,9 +1,15 @@
package de.edotzlaff.schockwelle;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Build;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.provider.Settings;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;
@@ -29,6 +35,7 @@ import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;

import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.Date;

@@ -38,35 +45,135 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
private static final String TAG = "MainActivity";
private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
private static final double EARTHQUAKE_VELOCITY = 1; // 1 Meter pro Sekunde Erdbebengeschwindigkeit

//vars
private Boolean mLocationPermissionsGranted = false;
private GoogleMap mMap;
private FusedLocationProviderClient mFusedLocationProviderClient;

Date currentTime;
//Date currentTime;
Location currentLocation;
Long currentTime;

private double breitengrad;
private double laengengrad;
private double sensorGPSbreitengrad;
private double sensorGPSlaengengrad;
private boolean useOwnGPS;
private boolean takeGPSfromDB = true;
private boolean tookOwnGPS = false;

boolean vibrationTrigger = true;


private DatabaseReference mDatenbank;
private String breitengradQuellVibration;
private String laengengradQuellVibration;

private Boolean mDeviceCanVibrate = false;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sensor_maps);

TextView tv= (TextView) findViewById(R.id.txtSensor);
getDataBaseValuesWithListener();

TextView tv= (TextView) findViewById(R.id.txtSensor);
getLocationPermission(); //Zuerst werden die aktuellen Standortdaten ermittelt

getDataBaseValues(); // Hier werden die Daten von der DB abgefragt //TODO Edward: Geht wieder :D
getVibrationAbility();
}


//#####################################################################################################################################################################
//################################################################## vvv ShakeCode vvv ##############################################################################
private void getVibrationAbility()
{
// Get instance of Vibrator from current Context
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

// Output yes if can vibrate, no otherwise
if (v.hasVibrator()) {
Log.v("Can Vibrate", "YES");
// Log.v("Can Control Amplitude", v.hasAmplitudeControl() ? "YES" : "NO");
mDeviceCanVibrate = true;
}
else
{

Log.v("Can Vibrate", "NO");
mDeviceCanVibrate = false;
}
}

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)
{

new CountDownTimer(msDelay, 1000) {
public void onTick(long millisUntilFinished) {
((TextView) findViewById(R.id.txtSensor)).setText("Earthquake hits in " + millisUntilFinished / 1000 + " s");
}

public void onFinish() {
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!
setVibrationInDataBase(index);
}
}.start();
}

public void performVibration(int duration, int amplitude) {
if(!mDeviceCanVibrate)
return;

Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
if (Build.VERSION.SDK_INT >= 26) {
if(duration == 0)
{
v.cancel(); //stop vibration if still running
Toast.makeText(this, "Vibration has been stopped", Toast.LENGTH_SHORT).show();
return;
}

Toast.makeText(this, "Ampl: " + amplitude + ", Dur: " + duration, Toast.LENGTH_SHORT).show();

v.vibrate(VibrationEffect.createOneShot(duration,amplitude));

//distance(currentLocation.getLatitude(), currentLocation.getLongitude(),breitengrad,laengengrad); //Übergabe zur Berechnung der Distanz zwischen Auslöser und aktuellem Standort

//TODO Patrick: die Funktion distance gibt Meter zurück, könntest Du das mit dem Zeitstempel und der Berechnung bis zur Vibration machen?
} else {

if(duration == 0)
{
v.cancel(); //stop vibration if still running

return;
}

v.vibrate(duration);
}
}
//################################################################## ^^^^ ShakeCode ^^^^ ############################################################################
//#####################################################################################################################################################################

//#####################################################################################################################################################################
//################################################################## vvv GPS Code vvv ###############################################################################

private void getLocationPermission() {
String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
@@ -120,9 +227,9 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
}

// 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));
//LatLng sydney = new LatLng(-34, 151);
//mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
//mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
}

private void getDeviceLocation(){
@@ -137,7 +244,12 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
public void onComplete(@NonNull Task task) {
if (task.isSuccessful()){
currentLocation = (Location) task.getResult();
currentTime = Calendar.getInstance().getTime();
currentTime = Calendar.getInstance().getTimeInMillis();
if (!useOwnGPS)
{
currentLocation.setLatitude(breitengrad);
currentLocation.setLongitude(laengengrad);
}
Toast.makeText(SensorMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show();
moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
}
@@ -157,14 +269,18 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom));
}

//TODO Edward: Mit Methode getDataBaseValues werden die Werte in der DB abgefragt. In Methode processDataBaseValues werden diese beispielhaft ausgelesen. Kann nach Bedarf angepasst werden.
public void getDataBaseValues()
//################################################################## ^^^^ GPS Code ^^^^ #############################################################################
//#####################################################################################################################################################################

//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()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot snapshot) {
processDataBaseValues(snapshot);
processDataBaseUpdate(snapshot);
}
@Override
public void onCancelled(@NonNull DatabaseError error) {
@@ -173,46 +289,148 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa
});
}

public void processDataBaseValues (DataSnapshot data)
public void processDataBaseUpdate (DataSnapshot data)
{
for (int i = 1; i<=4; i++) //Für alle IDG 1-4 werden Werte ausgegeben
String breitengradString;
String laengengradString;
String vibrationString;
String androidid;
int vibratingDevices = 0;

for (int i = 1; i<=4; i++)
{
//####### Auslesen für String-Werte #######:
String ipAdresse = data.child("overview").child("IDG" + i).child("ip").getValue().toString();

//####### Auslesen für boolean-Werte #######:
String vibrationString = data.child("overview").child("IDG" + i).child("vibration").getValue().toString();
boolean vibration;
if(vibrationString == "true"){
vibration = true;
}else{
vibration = false;
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())
{
//System.out.println("Index " + i + " ist nicht leer");
if(vibrationString == "false")
{
//System.out.println("Index " + i + " Vibration ist false");
continue;
}
else
{
//System.out.println("Index " + i + " Vibration ist true");
if(androidid.equals(getandroidid()))
{
//System.out.println("Index " + i + " Vibration ist von mir. Falscher Alarm");
vibrationTrigger = 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;
}
}
}

//####### Auslesen für double-Werte #######:
String breitengradString = data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString();
String laengengradString = data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString();
double breitengrad = Double.parseDouble(breitengradString);
double laengengrad = Double.parseDouble(laengengradString);

//####### Auslesen für long-Werte #######:
String timestampString = data.child("overview").child("IDG" + i).child("timestamp").getValue().toString();
long timestamp = Long.parseLong(timestampString);

//####### Auslesen für ing-Werte #######:
String amplitudeString = data.child("overview").child("IDG" + i).child("amplitude").getValue().toString();
int amplitude = Integer.parseInt(amplitudeString);

//####### Optional zur Kontrolle #######:
/*
System.out.println("IDG" + i + " - IP:" + data.child("overview").child("IDG" + i).child("ip").getValue().toString());
System.out.println("IDG" + i + " - Vibration:" + data.child("overview").child("IDG" + i).child("vibration").getValue().toString());
System.out.println("IDG" + i + " - Zeitstempel:" + data.child("overview").child("IDG" + i).child("timestamp").getValue().toString());
System.out.println("IDG" + i + " - Breitengrad:" + data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString());
System.out.println("IDG" + i + " - Laengengrad:" + data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString());
System.out.println("IDG" + i + " - Amplitude:" + data.child("overview").child("IDG" + i).child("amplitude").getValue().toString());
*/
//TODO Weiterer Code von Patrick. @Aron Anschauen ob dieser noch verwendet werden muss da paar Sachen schon in dieser Version umgesetzt worde sind.
/*
//####### 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();
boolean vibration;
if(vibrationString.equals("true")){
vibration = true;
}else{
vibration = false;
}
int amplitude = Integer.parseInt(amplitudeString);
// Workaround beseiteigen: hier wird immer davon ausgegangen, dass auslösendes Gerät die ID 1 besitzt
if(vibration == true && i == 1)
{
float distance = distance(currentLocation.getLatitude(), currentLocation.getLongitude(),breitengrad,laengengrad);
long delay = getTimeStampDifference(distance);
setVibrationTimer(delay,1000,amplitude);
}

*/
}

public void setVibrationInDataBase(int k)
{
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

if (useOwnGPS)
{
//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
}
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)
@@ -231,4 +449,4 @@ public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCa

return distanceInMeters;
}
}
}

+ 5
- 5
app/src/main/res/layout/activity_earthquake_maps.xml View File

@@ -4,24 +4,24 @@
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".EarthquakeMapsActivity">
tools:context=".EarthquakeMapsActivity"
android:paddingTop="?attr/actionBarSize">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Shake your Smartphone for a Earthquake"
android:text="@string/shake_your_smartphone_for_a_earthquake"
android:layout_centerHorizontal="true"
android:id="@+id/txtEarthquake"/>


<fragment xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
<androidx.fragment.app.FragmentContainerView xmlns:map="http://schemas.android.com/apk/res-auto"
android:layout_below="@+id/txtEarthquake"
android:id="@+id/map"
android:name="com.google.android.gms.maps.SupportMapFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_marginTop="50dp"

tools:context=".EarthquakeMapsActivity" />


+ 26
- 0
app/src/main/res/layout/activity_main.xml View File

@@ -23,4 +23,30 @@
android:layout_centerHorizontal="true"
android:layout_below="@id/btnEarthquake"/>


<Button
android:id="@+id/buttonDatenBankMuster"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/btnSensor"
android:layout_centerHorizontal="true"
android:layout_marginTop="50dp"
android:text="@string/start_mit_vordefinierter_db" />

<Button
android:id="@+id/buttonDatenBankLeeren"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/buttonDatenBankMuster"
android:layout_centerHorizontal="true"
android:text="@string/start_mit_leeren_db" />

<Button
android:id="@+id/buttonReset"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/buttonDatenBankLeeren"
android:layout_centerHorizontal="true"
android:text="@string/weitermachen_buttonreset" />

</RelativeLayout>

+ 10
- 0
app/src/main/res/values/strings.xml View File

@@ -4,4 +4,14 @@
<string name="title_activity_sensor_maps">Map</string>
<string name="be_a_sensor">Be a Sensor</string>
<string name="generate_earthquake">Generate Earthquake</string>
<string name="buttontest">ButtonTest</string>
<string name="mit_leeren_db_starten">Mit leeren DB starten</string>
<string name="mit_voller_db_starten_beispielwerte">Mit voller DB starten (Beispielwerte)</string>
<string name="mit_voller_db_starten">Mit voller DB starten</string>
<string name="universalertestbutton">UniversalerTestButton</string>
<string name="weitermachen">Weitermachen</string>
<string name="shake_your_smartphone_for_a_earthquake">Shake your Smartphone for a Earthquake</string>
<string name="start_mit_vordefinierter_db">Start mit vordefinierter DB</string>
<string name="start_mit_leeren_db">Start mit Leeren DB</string>
<string name="weitermachen_buttonreset">Weitermachen - Buttonreset</string>
</resources>

+ 1
- 1
build.gradle View File

@@ -5,7 +5,7 @@ buildscript {
jcenter()
}
dependencies {
classpath "com.android.tools.build:gradle:4.1.3"
classpath 'com.android.tools.build:gradle:4.2.1'
classpath 'com.google.gms:google-services:4.3.8'

// NOTE: Do not place your application dependencies here; they belong

+ 1
- 1
gradle/wrapper/gradle-wrapper.properties View File

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-all.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-all.zip

Write Preview
Loading…
Cancel
Save