AbdulajevAr51780/mMDT5_PR_MSY1_Gruppe1
1
0 Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: AbdulajevAr51780/mMDT5_PR_MSY1_Gruppe1:9932f3fc248511daaaa72dc51d688df1c8cfb6ce
AbdulajevAr51780/mMDT5_PR_MSY1_Gruppe1:master
..
compare: AbdulajevAr51780/mMDT5_PR_MSY1_Gruppe1:master
AbdulajevAr51780/mMDT5_PR_MSY1_Gruppe1:master
41 Commits
9932f3fc24 .. master
Author SHA1 Message Date
Raz492 054e9687a8 Alpha Version 3.500 V2 2021-06-28 13:18:52 +02:00
Raz492 2d4508ec1a Alpha Version 3.500 2021-06-28 13:18:30 +02:00
Raz492 5dd5d3c892 Alpha Version 3.500 2021-06-28 12:02:41 +02:00
Raz492 a4cb71a8f3 Alpha Version 3.1 - Ohne DB Schreibkonflikte 2021-06-28 11:42:46 +02:00
Raz492 eb620bccbc Alpha Version 3 - Ohne DB Schreibkonflikte 2021-06-28 11:31:16 +02:00
Raz492 69070b020f AlphaV21 mit GeschwindigkeitWelle 500m-s 2021-06-27 20:50:58 +02:00
Raz492 5159f9da57 AlphaV21 mit Buildversion 2021-06-27 20:33:39 +02:00
Raz492 e9d75b7ec4 AlphaV21 2021-06-27 13:04:27 +02:00
Raz492 45d9a86d48 AlphaV20 2021-06-27 12:37:55 +02:00
AbdulajevAr51780 085ea36824 CrashFix 2021-06-26 12:53:48 +00:00
AbdulajevAr51780 a6b614dabe CrashFix 2021-06-26 12:53:34 +00:00
AbdulajevAr51780 0809d06f3f CrashFix 2021-06-26 12:53:16 +00:00
AbdulajevAr51780 3827352818 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-26 12:52:43 +00:00
halbothpa61667 5c59f7732e if(amplitude > 255 || amplitude < 1) 
amplitude = VibrationEffect.DEFAULT_AMPLITUDE;
 2021-06-25 10:57:27 +02:00
halbothpa61667 eb68c99d99 onPause() onResume() 2021-06-25 10:37:45 +02:00
AbdulajevAr51780 0cb1101aa8 Dateien hochladen nach „app/src/main“ 2021-06-21 19:09:07 +00:00
AbdulajevAr51780 0864c39091 Dateien hochladen nach „app/src/main/res/layout“ 2021-06-21 19:08:37 +00:00
AbdulajevAr51780 b6da735750 Dateien hochladen nach „app/src/main/res/layout“ 2021-06-21 19:08:30 +00:00
AbdulajevAr51780 4d5e9405d4 Dateien hochladen nach „app/src/main/res/layout“ 2021-06-21 19:08:24 +00:00
AbdulajevAr51780 a780c9e900 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-21 19:07:32 +00:00
AbdulajevAr51780 5b116a1773 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-21 19:07:25 +00:00
AbdulajevAr51780 41c36a9e02 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-21 19:07:19 +00:00
AbdulajevAr51780 e85656eb58 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-21 19:07:12 +00:00
AbdulajevAr51780 d1639e103e Dateien hochladen nach „app/src/main“ 2021-06-20 20:36:50 +00:00
AbdulajevAr51780 22dec5900c Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 20:11:06 +00:00
AbdulajevAr51780 24e651da4e Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 20:10:55 +00:00
AbdulajevAr51780 f414fa62f2 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 20:10:40 +00:00
AbdulajevAr51780 700c5ba792 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 20:10:31 +00:00
AbdulajevAr51780 7345a35d97 Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 20:10:20 +00:00
AbdulajevAr51780 23dd646e90 Dateien hochladen nach „app/src/main/res/values“ 2021-06-20 19:31:13 +00:00
AbdulajevAr51780 7e10399b92 Dateien hochladen nach „app/src/main/res/layout“ 2021-06-20 19:30:26 +00:00
AbdulajevAr51780 3c7f30a74b Dateien hochladen nach „app/src/main/res/layout“ 2021-06-20 19:30:12 +00:00
AbdulajevAr51780 e50fafd505 Dateien hochladen nach „app/src/main/res/layout“ 2021-06-20 19:30:01 +00:00
AbdulajevAr51780 af1e25bf8c Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 19:28:07 +00:00
AbdulajevAr51780 b930e39dee Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 19:27:57 +00:00
AbdulajevAr51780 d7addc222d Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 19:27:36 +00:00
AbdulajevAr51780 903664503a Dateien hochladen nach „app/src/main/java/de/edotzlaff/schockwelle“ 2021-06-20 19:27:23 +00:00
Raz492 1d2485d59e Merge remote-tracking branch 'origin/master' 2021-06-20 21:24:34 +02:00
Raz492 eba661a070 Merge remote-tracking branch 'origin/master' 
# Conflicts:
#	app/src/main/AndroidManifest.xml
#	app/src/main/java/de/edotzlaff/schockwelle/EarthquakeMapsActivity.java
#	app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
#	app/src/main/res/layout/activity_earthquake_maps.xml
 2021-06-20 21:22:55 +02:00
Raz492 c37a99723f Merge remote-tracking branch 'origin/master' 
# Conflicts:
#	app/src/main/AndroidManifest.xml
#	app/src/main/java/de/edotzlaff/schockwelle/EarthquakeMapsActivity.java
#	app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
#	app/src/main/res/layout/activity_earthquake_maps.xml
 2021-06-20 20:48:56 +02:00
Raz492 84ac745cec Alpha Version der Schockwellen App 2021-06-20 20:42:35 +02:00
10 changed files with 2162 additions and 1005 deletions
Expand all files Collapse all files

No files matched your search

app/src/main/AndroidManifest.xml
+53 -50
View File
@@ -1,50 +1,53 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" <manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="de.edotzlaff.schockwelle"> package="de.edotzlaff.schockwelle">
<!-- <!--
The ACCESS_COARSE/FINE_LOCATION permissions are not required to use The ACCESS_COARSE/FINE_LOCATION permissions are not required to use
Google Maps Android API v2, but you must specify either coarse or fine Google Maps Android API v2, but you must specify either coarse or fine
location permissions for the "MyLocation" functionality. location permissions for the "MyLocation" functionality.
--> -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.VIBRATE" /> <uses-permission android:name="android.permission.VIBRATE" />
<application
android:allowBackup="true" <application
android:icon="@mipmap/schockicon" android:allowBackup="true"
android:label="@string/app_name" android:icon="@mipmap/schockicon"
android:roundIcon="@mipmap/schockicon" android:label="@string/app_name"
android:supportsRtl="true" android:roundIcon="@mipmap/schockicon"
android:theme="@style/Theme.Schockwelle"> android:supportsRtl="true"
android:theme="@style/Theme.Schockwelle">
<!--
The API key for Google Maps-based APIs is defined as a string resource. <!--
(See the file "res/values/google_maps_api.xml"). The API key for Google Maps-based APIs is defined as a string resource.
Note that the API key is linked to the encryption key used to sign the APK. (See the file "res/values/google_maps_api.xml").
You need a different API key for each encryption key, including the release key that is used to Note that the API key is linked to the encryption key used to sign the APK.
sign the APK for publishing. You need a different API key for each encryption key, including the release key that is used to
You can define the keys for the debug and release targets in src/debug/ and src/release/. sign the APK for publishing.
--> You can define the keys for the debug and release targets in src/debug/ and src/release/.
<meta-data -->
android:name="com.google.android.geo.API_KEY" <meta-data
android:value="@string/google_maps_key" /> android:name="com.google.android.geo.API_KEY"
android:value="@string/google_maps_key" />
<activity
android:name=".SensorMapsActivity" <activity
android:label="@string/title_activity_sensor_maps"></activity> android:name=".SensorMapsActivity"
<activity android:label="@string/title_activity_sensor_maps"></activity>
android:name=".EarthquakeMapsActivity" <activity
android:label="@string/title_activity_earthquake_maps" /> android:name=".EarthquakeMapsActivity"
<activity android:name=".MainActivity"> android:label="@string/title_activity_earthquake_maps"/>
<intent-filter> <activity android:name=".MainActivity">
<action android:name="android.intent.action.MAIN" /> <intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter> <category android:name="android.intent.category.LAUNCHER" />
</activity> </intent-filter>
</application> </activity>
</application>
</manifest>
</manifest>
<!--android:parentActivityName=".MainActivity"-->
app/src/main/java/de/edotzlaff/schockwelle/Datenbank.java
+664
View File
@@ -0,0 +1,664 @@
package de.edotzlaff.schockwelle;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.util.Log;
import android.widget.Toast;
import androidx.annotation.NonNull;
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.ZoneOffset;
import java.util.Calendar;
public class Datenbank {
private String myAndroidID;
private String myIPadress;
private int myWaveSpeed; // Meter pro Sekunde
private double shakeBreitengrad;
private double shakeLaengengrad;
private String a_androidid;
private String b_localdatetime;
private String c_ip;
private double d_breitengrad;
private double e_laengengrad;
private boolean f_nativegps;
private boolean g_vibration;
private long h_timestamp;
private int i_amplitude;
private int w_wellengeschwindigkeit;
private DatabaseReference mDatenbank = FirebaseDatabase.getInstance().getReference().child("overviewnodes");
private String TAG = "Datenbank";
DataSnapshot DatenBankInhalt;
//######### Für andere Klassen: ###########################
//Datenbank db = new Datenbank(); <--Bei Initialisierung
//db.getDatafromDBnoListener(); <--OnCreate
//db.getDataBaseValuesWithListener(); <--OnCreate
public Datenbank(String a_androidid, String b_localdatetime, String c_ip, double d_breitengrad, double e_laengengrad, boolean f_nativegps, boolean g_vibration, long h_timestamp, int i_amplitude, int w_wellengeschwindigkeit) {
this.a_androidid = a_androidid;
this.b_localdatetime = b_localdatetime;
this.c_ip = c_ip;
this.d_breitengrad = d_breitengrad;
this.e_laengengrad = e_laengengrad;
this.f_nativegps = f_nativegps;
this.g_vibration = g_vibration;
this.h_timestamp = h_timestamp;
this.i_amplitude = i_amplitude;
this.w_wellengeschwindigkeit = w_wellengeschwindigkeit;
}
public Datenbank ()
{
}
//DatenBankInhalt wird einmalig Aktualisiert
public void getDatafromDBnoListener()
{
mDatenbank.get().addOnCompleteListener(new OnCompleteListener<DataSnapshot>() {
@Override
public void onComplete(@NonNull Task<DataSnapshot> task) {
if (!task.isSuccessful()) {
Log.d(TAG,"Fehler in getDatafromDBnoListener" + task.getException());
}
else {
setDatenBankInhalt(task.getResult());
initializeDataBase_ShockApplication_Main();
}
}
});
}
//DatenBankInhalt wird bei Veränderung Aktualisiert
public void getDataBaseValuesWithListener()
{
mDatenbank.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot snapshot) {
setDatenBankInhalt(snapshot);
//Geänderte DB schicken an SensorMapActivity
SensorMapsActivity sensor = new SensorMapsActivity();
}
@Override
public void onCancelled(@NonNull DatabaseError error) {
getDataBaseFailure(error);
}
});
}
public void getDataBaseFailure (DatabaseError error)
{
Log.w("Datenbankfehler", error.toException());
}
public void initializeDataBase_ShockApplication_Main()
{
if(getDatenBankInhalt().exists())
{
//Wenn DB schon exisitiert
if(getIfPureIDGareEmpty())
{
//Wenn IDG nocht KOMPLETT leer sind und keine weiteren Children haben
setEmptyDataInDBcompletly();
Log.d(TAG,"Datenbankzweig wurde für Anwendung angepasst. Weitermachen.");
}
}else
{
//Wenn DB nicht exisitert
setEmptyIDGinDBcomplety();
Log.d(TAG,"Datenbankzweig nicht existent. Dieser wurde angelgt. Neustart der App nötig");
}
}
public void setCommand()
{
setAndroidIDInDB(2,"hello");
setBreitengrad(2,15);
}
public String getCommand()
{
getAndroidIDInDB(2);
getBreitengrad(2);
return getAndroidIDInDB(2) + getBreitengrad(2);
}
//########################################################################### Set / Get von IDGs
public void setEmptyDataInIDG(int i) //Setzt leere Strings children von IDGi
{
mDatenbank.child("IDG" + i).child("a_androidid").setValue("");
mDatenbank.child("IDG" + i).child("b_localdatetime").setValue("");
mDatenbank.child("IDG" + i).child("c_ip").setValue("");
mDatenbank.child("IDG" + i).child("d_breitengrad").setValue("");
mDatenbank.child("IDG" + i).child("e_laengengrad").setValue("");
mDatenbank.child("IDG" + i).child("f_nativegps").setValue("");
mDatenbank.child("IDG" + i).child("g_vibration").setValue("");
mDatenbank.child("IDG" + i).child("h_timestamp").setValue("");
mDatenbank.child("IDG" + i).child("i_amplitude").setValue("");
mDatenbank.child("IDG" + i).child("w_wellengeschwindigkeit").setValue("");
}
public boolean getStatusEmptyAboutIDG(int i) //Gibt true wenn IDG i leer ist
{
String androidid = getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString();
String localdatetime = getDatenBankInhalt().child("IDG" + i).child("b_localdatetime").getValue().toString();
String ip = getDatenBankInhalt().child("IDG" + i).child("c_ip").getValue().toString();
String breitengrad = getDatenBankInhalt().child("IDG" + i).child("d_breitengrad").getValue().toString();
String laengengrad = getDatenBankInhalt().child("IDG" + i).child("e_laengengrad").getValue().toString();
String nativegps = getDatenBankInhalt().child("IDG" + i).child("f_nativegps").getValue().toString();
String vibration = getDatenBankInhalt().child("IDG" + i).child("g_vibration").getValue().toString();
String timestamp = getDatenBankInhalt().child("IDG" + i).child("h_timestamp").getValue().toString();
String amplitude = getDatenBankInhalt().child("IDG" + i).child("i_amplitude").getValue().toString();
String wellengeschwindigkeit = getDatenBankInhalt().child("IDG" + i).child("w_wellengeschwindigkeit").getValue().toString();
if(androidid.isEmpty() && localdatetime.isEmpty() && ip.isEmpty() && breitengrad.isEmpty() && laengengrad.isEmpty() && nativegps.isEmpty() && vibration.isEmpty() && timestamp.isEmpty() && amplitude.isEmpty() && wellengeschwindigkeit.isEmpty())
{
return true;
}else
{
return false;
}
}
public boolean getStatusEmptyAboutIDGexceptNativeGPSandVibration(int i) //Gibt true wenn IDG i, bis auf nativegps und vibration, leer ist
{
String androidid = getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString();
String localdatetime = getDatenBankInhalt().child("IDG" + i).child("b_localdatetime").getValue().toString();
String ip = getDatenBankInhalt().child("IDG" + i).child("c_ip").getValue().toString();
String breitengrad = getDatenBankInhalt().child("IDG" + i).child("d_breitengrad").getValue().toString();
String laengengrad = getDatenBankInhalt().child("IDG" + i).child("e_laengengrad").getValue().toString();
String timestamp = getDatenBankInhalt().child("IDG" + i).child("h_timestamp").getValue().toString();
String amplitude = getDatenBankInhalt().child("IDG" + i).child("i_amplitude").getValue().toString();
String wellengeschwindigkeit = getDatenBankInhalt().child("IDG" + i).child("w_wellengeschwindigkeit").getValue().toString();
if(androidid.isEmpty() && localdatetime.isEmpty() && ip.isEmpty() && breitengrad.isEmpty() && laengengrad.isEmpty() && timestamp.isEmpty() && amplitude.isEmpty() && wellengeschwindigkeit.isEmpty())
{
return true;
}else
{
return false;
}
}
public boolean getStatusFullAboutIDG(int i) //Gibt true wenn IDG i voll ist
{
String androidid = getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString();
String localdatetime = getDatenBankInhalt().child("IDG" + i).child("b_localdatetime").getValue().toString();
String ip = getDatenBankInhalt().child("IDG" + i).child("c_ip").getValue().toString();
String breitengrad = getDatenBankInhalt().child("IDG" + i).child("d_breitengrad").getValue().toString();
String laengengrad = getDatenBankInhalt().child("IDG" + i).child("e_laengengrad").getValue().toString();
String nativegps = getDatenBankInhalt().child("IDG" + i).child("f_nativegps").getValue().toString();
String vibration = getDatenBankInhalt().child("IDG" + i).child("g_vibration").getValue().toString();
String timestamp = getDatenBankInhalt().child("IDG" + i).child("h_timestamp").getValue().toString();
String amplitude = getDatenBankInhalt().child("IDG" + i).child("i_amplitude").getValue().toString();
String wellengeschwindigkeit = getDatenBankInhalt().child("IDG" + i).child("w_wellengeschwindigkeit").getValue().toString();
if(!androidid.isEmpty() && !localdatetime.isEmpty() && !ip.isEmpty() && !breitengrad.isEmpty() && !laengengrad.isEmpty() && !nativegps.isEmpty() && !vibration.isEmpty() && !timestamp.isEmpty() && !amplitude.isEmpty() && !wellengeschwindigkeit.isEmpty())
{
return true;
}else
{
return false;
}
}
//########################################################################### Set / Get von kompletter DB
public void setEmptyDataInDBcompletly() //Setzt leere Strings in alle children von allen IDGs
{
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
mDatenbank.child("IDG" + i).child("a_androidid").setValue("");
mDatenbank.child("IDG" + i).child("b_localdatetime").setValue("");
mDatenbank.child("IDG" + i).child("c_ip").setValue("");
mDatenbank.child("IDG" + i).child("d_breitengrad").setValue("");
mDatenbank.child("IDG" + i).child("e_laengengrad").setValue("");
mDatenbank.child("IDG" + i).child("f_nativegps").setValue("");
mDatenbank.child("IDG" + i).child("g_vibration").setValue("");
mDatenbank.child("IDG" + i).child("h_timestamp").setValue("");
mDatenbank.child("IDG" + i).child("i_amplitude").setValue("");
mDatenbank.child("IDG" + i).child("w_wellengeschwindigkeit").setValue("");
}
}
public void setEmptyDataInDBcompletlyForNativeUse() //Setzt leere Strings in alle children von allen IDGs, wobei nativeGPS = true und vibration = false gesetzt werden
{
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
mDatenbank.child("IDG" + i).child("a_androidid").setValue("");
mDatenbank.child("IDG" + i).child("b_localdatetime").setValue("");
mDatenbank.child("IDG" + i).child("c_ip").setValue("");
mDatenbank.child("IDG" + i).child("d_breitengrad").setValue("");
mDatenbank.child("IDG" + i).child("e_laengengrad").setValue("");
mDatenbank.child("IDG" + i).child("f_nativegps").setValue(true);
mDatenbank.child("IDG" + i).child("g_vibration").setValue(false);
mDatenbank.child("IDG" + i).child("h_timestamp").setValue("");
mDatenbank.child("IDG" + i).child("i_amplitude").setValue("");
mDatenbank.child("IDG" + i).child("w_wellengeschwindigkeit").setValue("");
}
}
public boolean getStatusOnEmptyDBcomplety() //Gibt true wenn alle Strings aller IDGs leer sind
{
int emptyIDGs = 0;
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
if(getStatusEmptyAboutIDG(i))
{
emptyIDGs++;
}
}
if(emptyIDGs == (int) getDatenBankInhalt().getChildrenCount())
{
return true;
}else{
return false;
}
}
public void setVibrationInDBcompletly(boolean boolValue) //Setzt Vibration true/false in allen children aller IDGs
{
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
mDatenbank.child("IDG" + i).child("g_vibration").setValue(boolValue);
}
}
public void setNativeGPSInDBcompletly(boolean boolValue) //Setzt nativeGPS true/false in allen children aller IDGs
{
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
mDatenbank.child("IDG" + i).child("f_nativegps").setValue(boolValue);
}
}
public boolean getNativeGPScaseInDB() //Gibt true an, wenn in allen IDGs der wert nativeGPs true oder leer ist
{
int nativeGPS = 0;
for (int i = 1; i<=getAmountOfIDGs(); i++)
{
if(getDatenBankInhalt().child("IDG" + i).child("f_nativegps").getValue().toString().equals("true") || getDatenBankInhalt().child("IDG" + i).child("f_nativegps").getValue().toString().isEmpty())
{
nativeGPS++;
}
}
if(nativeGPS == getDatenBankInhalt().getChildrenCount())
{
return true;
}else
{
return false;
}
}
public boolean getIfPureIDGareEmpty() //Gibt true an, wenn alle IDGs komplett leer sind
{
int pureEmptyIDG = 0;
for (int i = 1; i<=getDatenBankInhalt().getChildrenCount(); i++)
{
if(getDatenBankInhalt().child("IDG" + i).getValue().toString().isEmpty())
{
pureEmptyIDG++;
}
}
if(pureEmptyIDG == getDatenBankInhalt().getChildrenCount())
{
return true;
}
else
{
return false;
}
}
public void setNonNativeCaseInDB() //Setzt Musterwerte ein
{
Devices d1 = new Devices("","","",49.58967957913626,11.011387124069765,false,false,0,1000,10); //Erlangen 49.58967957913626, 11.011387124069765
Devices d2 = new Devices("","","",48.7560280895443,11.425157702952347,false,false,0,1000,10); //Ingolstadt 48.7560280895443, 11.425157702952347
Devices d3 = new Devices("","","",48.16958655466396,11.617418429524394,false,false,0,1000,10); //München 48.16958655466396, 11.617418429524394
Devices d4 = new Devices("","","",45.55620112204013,12.342516140205387,false,false,0,1000,10); //Venedig 45.55620112204013, 12.342516140205387
Devices d5 = new Devices("","","",41.9204784730154,12.651055829215638,false,false,0,1000,10); //Rom 41.9204784730154, 12.651055829215638
mDatenbank.child("IDG1").setValue(d1);
mDatenbank.child("IDG2").setValue(d2);
mDatenbank.child("IDG3").setValue(d3);
mDatenbank.child("IDG4").setValue(d4);
mDatenbank.child("IDG5").setValue(d4);
mDatenbank.child("IDG5").setValue(d5);
}
public void setEmptyIDGinDBcomplety() //Setzt leer IDGs in einen Dantenbankzweig
{
for (int i = 1; i<=5; i++)
{
mDatenbank.child("IDG" + i).setValue("");
}
}
//########################################################################### Allgemeine Getter und Setter
public long getAmountOfIDGs() //Gibt Anzahl der Children an
{
return getDatenBankInhalt().getChildrenCount();
}
public void setIDGtoDevice(int i, Devices dev) //Gibt Anzahl der Children an
{
mDatenbank.child("IDG" + i).setValue(dev);
}
//Get-Set AndroidID
public void setAndroidIDInDB(int i, String andoridID)
{
mDatenbank.child("IDG" + i).child("a_androidid").setValue(andoridID);
}
public String getAndroidIDInDB(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString();
}
public boolean getAndroidIDisEmpty(int i)
{
if(getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString().isEmpty())
{
return true;
}else
{
return false;
}
}
public boolean getStatusIFAndroidIDexistsInDB(String androidID)
{
boolean androidIDexists;
for (int i = 1; i<=getAmountOfIDGs(); i++)
{
if(getDatenBankInhalt().child("IDG" + i).child("a_androidid").getValue().toString().equals(getMyAndroidID()))
{
androidIDexists = true;
return androidIDexists;
}else
{
if(i == (int) getAmountOfIDGs())
{
androidIDexists = false;
return androidIDexists;
}
}
}
return false;
}
//Get-Set LocalDatetime
public void setLocalDateTimeInDB(int i, String localdatetime)
{
mDatenbank.child("IDG" + i).child("b_localdatetime").setValue(localdatetime);
}
public String getLocalDateTimeInDB(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("b_localdatetime").getValue().toString();
}
public boolean getLocalDateTimeIsEmpty(int i)
{
if(getDatenBankInhalt().child("IDG" + i).child("b_localdatetime").getValue().toString().isEmpty())
{
return true;
}else
{
return false;
}
}
//Get-Set IP
public void setIPInDB(int i, String ipAdress)
{
mDatenbank.child("IDG" + i).child("c_ip").setValue(ipAdress);
}
public String getIPInDB(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("c_ip").getValue().toString();
}
//Get-Set Breitengrad
public void setBreitengrad(int i, double breitengrad)
{
mDatenbank.child("IDG" + i).child("d_breitengrad").setValue(breitengrad);
}
public String getBreitengrad(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("d_breitengrad").getValue().toString();
}
public boolean getBreitengradIsEmpty(int i)
{
if(getDatenBankInhalt().child("IDG" + i).child("d_breitengrad").getValue().toString().isEmpty())
{
return true;
}else
{
return false;
}
}
//Get-Set Laengengrad
public void setLaengengrad(int i, double laengengrad)
{
mDatenbank.child("IDG" + i).child("e_laengengrad").setValue(laengengrad);
}
public String getLaengengrad(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("e_laengengrad").getValue().toString();
}
public boolean getLaengengradIsEmpty(int i)
{
if(getDatenBankInhalt().child("IDG" + i).child("e_laengengrad").getValue().toString().isEmpty())
{
return true;
}else
{
return false;
}
}
//Set GPS
public void setBreitengradUndLaengengrad(int i, double breitengrad, double laengengrad)
{
mDatenbank.child("IDG" + i).child("d_breitengrad").setValue(breitengrad);
mDatenbank.child("IDG" + i).child("e_laengengrad").setValue(laengengrad);
}
//Get-Set NativeGPS
public void setNativeGPS(int i, boolean nativegps)
{
mDatenbank.child("IDG" + i).child("f_nativegps").setValue(nativegps);
}
public String getNativeGPS(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("f_nativegps").getValue().toString();
}
//Get-Set Vibration
public void setVibration(int i, boolean vibration)
{
mDatenbank.child("IDG" + i).child("g_vibration").setValue(vibration);
}
public String getVibration(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("g_vibration").getValue().toString();
}
//Get-Set timestamp
public void setTimestamp(int i, long timestamp)
{
mDatenbank.child("IDG" + i).child("h_timestamp").setValue(timestamp);
}
public String getTimestamp(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("h_timestamp").getValue().toString();
}
public boolean getTimestampIsEmpty(int i)
{
if(getDatenBankInhalt().child("IDG" + i).child("h_timestamp").getValue().toString().isEmpty())
{
return true;
}else
{
return false;
}
}
//Get-Set Amplitude
public void setAmplitude(int i, int amplitude)
{
mDatenbank.child("IDG" + i).child("i_amplitude").setValue(amplitude);
}
public String getAmplitude(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("i_amplitude").getValue().toString();
}
//Get-Set Wellengeschwindigkeit
public void setWellengeschwindigkeit(int i, int wellengeschwindigkeit)
{
mDatenbank.child("IDG" + i).child("w_wellengeschwindigkeit").setValue(wellengeschwindigkeit);
}
public String getWellengeschwindigkeit(int i)
{
return getDatenBankInhalt().child("IDG" + i).child("w_wellengeschwindigkeit").getValue().toString();
}
//########################################################################### Sontiges
//########################################################################### Contruktor Getter und Setter
public String getA_androidid() {
return a_androidid;
}
public void setA_androidid(String a_androidid) {
this.a_androidid = a_androidid;
}
public String getB_localdatetime() {
return b_localdatetime;
}
public void setB_localdatetime(String b_localdatetime) {
this.b_localdatetime = b_localdatetime;
}
public String getC_ip() {
return c_ip;
}
public void setC_ip(String c_ip) {
this.c_ip = c_ip;
}
public double getD_breitengrad() {
return d_breitengrad;
}
public void setD_breitengrad(double d_breitengrad) {
this.d_breitengrad = d_breitengrad;
}
public double getE_laengengrad() {
return e_laengengrad;
}
public void setE_laengengrad(double e_laengengrad) {
this.e_laengengrad = e_laengengrad;
}
public boolean isF_nativegps() {
return f_nativegps;
}
public void setF_nativegps(boolean f_nativegps) {
this.f_nativegps = f_nativegps;
}
public boolean isG_vibration() {
return g_vibration;
}
public void setG_vibration(boolean g_vibration) {
this.g_vibration = g_vibration;
}
public long getH_timestamp() {
return h_timestamp;
}
public void setH_timestamp(long h_timestamp) {
this.h_timestamp = h_timestamp;
}
public int getI_amplitude() {
return i_amplitude;
}
public void setI_amplitude(int i_amplitude) {
this.i_amplitude = i_amplitude;
}
public int getW_wellengeschwindigkeit() {
return w_wellengeschwindigkeit;
}
public void setW_wellengeschwindigkeit(int w_wellengeschwindigkeit) {
this.w_wellengeschwindigkeit = w_wellengeschwindigkeit;
}
public DataSnapshot getDatenBankInhalt() {
return DatenBankInhalt;
}
public void setDatenBankInhalt(DataSnapshot datenBankInhalt) {
DatenBankInhalt = datenBankInhalt;
}
public String getMyAndroidID() {
return myAndroidID;
}
public void setMyAndroidID(String myAndroidID) {
this.myAndroidID = myAndroidID;
}
public int getMyWaveSpeed() {
return myWaveSpeed;
}
public void setMyWaveSpeed(int myWaveSpeed) {
this.myWaveSpeed = myWaveSpeed;
}
public String getMyIPadress() {
return myIPadress;
}
public void setMyIPadress(String myIPadress) {
this.myIPadress = myIPadress;
}
public double getShakeBreitengrad() {
return shakeBreitengrad;
}
public void setShakeBreitengrad(double shakeBreitengrad) {
this.shakeBreitengrad = shakeBreitengrad;
}
public double getShakeLaengengrad() {
return shakeLaengengrad;
}
public void setShakeLaengengrad(double shakeLaengengrad) {
this.shakeLaengengrad = shakeLaengengrad;
}
}
app/src/main/java/de/edotzlaff/schockwelle/Devices.java
+114 -70
View File
@@ -1,70 +1,114 @@
package de.edotzlaff.schockwelle; package de.edotzlaff.schockwelle;
public class Devices { import java.time.LocalDateTime;
private String ip;
private boolean vibration; public class Devices {
private long timestamp; private String a_androidid;
private double breitengrad; private String b_localdatetime;
private double laengengrad; private String c_ip;
private int amplitude; private double d_breitengrad;
private double e_laengengrad;
public Devices() { private boolean f_nativegps;
private boolean g_vibration;
} private long h_timestamp;
private int i_amplitude;
public Devices(String ip, boolean vibration, long timestamp, double breitengrad, double laengengrad, int amplitude) { private int w_wellengeschwindigkeit;
this.ip = ip;
this.vibration = vibration;
this.timestamp = timestamp; public Devices() {
this.breitengrad = breitengrad;
this.laengengrad = laengengrad; }
this.amplitude = amplitude;
} public Devices(String a_androidid, String b_localdatetime, String c_ip, double d_breitengrad, double e_laengengrad, boolean f_nativegps, boolean g_vibration, long h_timestamp, int i_amplitude, int w_wellengeschwindigkeit) {
this.a_androidid = a_androidid;
public String getIp() { this.b_localdatetime = b_localdatetime;
return ip; this.c_ip = c_ip;
} this.d_breitengrad = d_breitengrad;
public void setIp(String ip) { this.e_laengengrad = e_laengengrad;
this.ip = ip; this.f_nativegps = f_nativegps;
} this.g_vibration = g_vibration;
this.h_timestamp = h_timestamp;
this.i_amplitude = i_amplitude;
public boolean isVibration() { this.w_wellengeschwindigkeit = w_wellengeschwindigkeit;
return vibration; }
}
public void setVibration(boolean vibration) { public String getA_androidid() {
this.vibration = vibration; return a_androidid;
} }
public void setA_androidid(String a_androidid) {
public long getTimestamp() { this.a_androidid = a_androidid;
return timestamp; }
}
public void setTimestamp(long timestamp) { public String getB_localdatetime() {
this.timestamp = timestamp; return b_localdatetime;
} }
public void setB_localdatetime(String b_localdatetime) {
public double getBreitengrad() { this.b_localdatetime = b_localdatetime;
return breitengrad; }
}
public void setBreitengrad(double breitengrad) { public String getC_ip() {
this.breitengrad = breitengrad; return c_ip;
} }
public void setC_ip(String c_ip) {
public double getLaengengrad() { this.c_ip = c_ip;
return laengengrad; }
}
public void setLaengengrad(double laengengrad) { public double getD_breitengrad() {
this.laengengrad = laengengrad; return d_breitengrad;
} }
public void setD_breitengrad(double d_breitengrad) {
public int getAmplitude() { this.d_breitengrad = d_breitengrad;
return amplitude; }
}
public void setAmplitude(int amplitude) { public double getE_laengengrad() {
this.amplitude = amplitude; return e_laengengrad;
} }
}
public void setE_laengengrad(double e_laengengrad) {
this.e_laengengrad = e_laengengrad;
}
public boolean isF_nativegps() {
return f_nativegps;
}
public void setF_nativegps(boolean f_nativegps) {
this.f_nativegps = f_nativegps;
}
public boolean isG_vibration() {
return g_vibration;
}
public void setG_vibration(boolean g_vibration) {
this.g_vibration = g_vibration;
}
public long getH_timestamp() {
return h_timestamp;
}
public void setH_timestamp(long h_timestamp) {
this.h_timestamp = h_timestamp;
}
public int getI_amplitude() {
return i_amplitude;
}
public void setI_amplitude(int i_amplitude) {
this.i_amplitude = i_amplitude;
}
public int getW_wellengeschwindigkeit() {
return w_wellengeschwindigkeit;
}
public void setW_wellengeschwindigkeit(int w_wellengeschwindigkeit) {
this.w_wellengeschwindigkeit = w_wellengeschwindigkeit;
}
}
app/src/main/java/de/edotzlaff/schockwelle/EarthquakeMapsActivity.java
+355 -312
View File
@@ -1,312 +1,355 @@
package de.edotzlaff.schockwelle; package de.edotzlaff.schockwelle;
import android.Manifest; import android.Manifest;
import android.content.Context; import android.app.ActionBar;
import android.content.pm.PackageManager; import android.content.Context;
import android.location.Location; import android.content.pm.PackageManager;
import android.net.wifi.WifiManager; import android.hardware.Sensor;
import android.os.Bundle; import android.hardware.SensorEvent;
import android.os.CountDownTimer; import android.hardware.SensorEventListener;
import android.os.SystemClock; import android.hardware.SensorManager;
import android.text.format.Formatter; import android.location.Location;
import android.util.Log; import android.net.wifi.WifiManager;
import android.widget.Button; import android.os.Build;
import android.widget.TextView; import android.os.Bundle;
import android.widget.Toast; import android.os.CountDownTimer;
import android.os.SystemClock;
import android.hardware.Sensor; import android.provider.ContactsContract;
import android.hardware.SensorEvent; import android.provider.Settings;
import android.hardware.SensorEventListener; import android.util.Log;
import android.hardware.SensorManager; import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat; import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat; import androidx.annotation.RequiresApi;
import androidx.fragment.app.FragmentActivity; import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import com.google.android.gms.location.FusedLocationProviderClient; import androidx.fragment.app.FragmentActivity;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.CameraUpdateFactory; import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.SupportMapFragment; import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.model.LatLng; import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.model.MarkerOptions; import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.tasks.OnCompleteListener; import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.tasks.Task; import com.google.android.gms.maps.model.MarkerOptions;
import com.google.firebase.database.DataSnapshot; import com.google.android.gms.tasks.OnCompleteListener;
import com.google.firebase.database.DatabaseError; import com.google.android.gms.tasks.Task;
import com.google.firebase.database.DatabaseReference; import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.FirebaseDatabase; import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.ValueEventListener; import com.google.firebase.database.DatabaseReference;
import java.util.Calendar; import com.google.firebase.database.FirebaseDatabase;
import java.util.Date; import com.google.firebase.database.ValueEventListener;
import java.util.Objects;
import java.time.LocalDateTime;
public class EarthquakeMapsActivity extends FragmentActivity implements OnMapReadyCallback { import java.time.ZoneOffset;
import java.util.Calendar;
private static final String TAG = "MainActivity"; import java.util.Date;
private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION; import java.util.Objects;
private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
public class EarthquakeMapsActivity extends FragmentActivity implements OnMapReadyCallback {
//vars
private Boolean mLocationPermissionsGranted = false; private static final String TAG = "MainActivity";
private GoogleMap mMap; private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
private FusedLocationProviderClient mFusedLocationProviderClient; private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
private Boolean mLocationPermissionsGranted = false;
private DatabaseReference mDatenbank; private GoogleMap mMap;
private FusedLocationProviderClient mFusedLocationProviderClient;
//Date currentTime; //Workaround für Crash: currentTime nicht als Datum sondern als Long zeitstempel Datenbank db = new Datenbank();
Long currentTime;
Location currentLocation; Long currentTime;
Location currentLocation;
private double breitengrad; private DatabaseReference mDatenbank;
private double laengengrad; private double breitengrad;
private double laengengrad;
//Shake Sensor private boolean useOwnGPS;
private SensorManager mSensorManager; private int indexID = 1;
private static final float mUpperThreshold = 1.5f; // für Emulator auf 1.5 setzen
private static final float mLowerThreshold = 0.5f; // für Emulator auf 0.5 setzen
private static final long mShakeDetectionLockTimeMicroSeconds = 10000; //##########################################################################################################################################################################
private float mAccel; //################################################################## vvv ShakeParameter vvv ##############################################################################
private float mAccelCurrent; private SensorManager mSensorManager;
private float mAccelLast; private static final float mUpperThreshold = 10.5f; // für Emulator auf 1.5 setzen TODO Aron
private boolean mShakeDetectionIsActive = false; private static final float mLowerThreshold = 5.5f; // für Emulator auf 0.5 setzen TODO Aron
private boolean mShakeDetected = false; //private static final float mUpperThreshold = 10.5f; // für Emulator auf 1.5 setzen TODO Aron
private CountDownTimer mLockTimer = new CountDownTimer(mShakeDetectionLockTimeMicroSeconds, 1000) { //private static final float mLowerThreshold = 5.5f; // für Emulator auf 0.5 setzen TODO Aron
public void onTick(long millisUntilFinished) { private static final long mShakeDetectionLockTimeMicroSeconds = 10000;
((TextView) findViewById(R.id.txtEarthquake)).setText("Earthquake started! Detection locked for " + millisUntilFinished / 1000 + " s"); private float mAccel;
} private float mAccelCurrent;
private float mAccelLast;
public void onFinish() { private boolean mShakeDetectionIsActive = false;
mShakeDetectionIsActive = true; private boolean mShakeDetected = false;
mShakeDetected = false; private boolean allowShakeEvent = true;
Toast.makeText(getApplicationContext(), "Shake Detection unlocked", Toast.LENGTH_SHORT).show(); //################################################################## ^^^^ ShakeParameter ^^^^ ############################################################################
( (TextView) findViewById(R.id.txtEarthquake)).setText("Shake your Smartphone for an Earthquake"); //##########################################################################################################################################################################
}
};
@Override @Override
protected void onCreate(Bundle savedInstanceState) { protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); super.onCreate(savedInstanceState);
setContentView(R.layout.activity_earthquake_maps); setContentView(R.layout.activity_earthquake_maps);
TextView txtEarthquake = (TextView) findViewById(R.id.txtEarthquake);
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); //Database Init
Objects.requireNonNull(mSensorManager).registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL); db.setMyWaveSpeed(500);
mAccel = 1f; db.setMyAndroidID(Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID));
mAccelCurrent = SensorManager.GRAVITY_EARTH; WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
mAccelLast = SensorManager.GRAVITY_EARTH; int ip = wm.getConnectionInfo().getIpAddress();
mShakeDetectionIsActive = true; db.setMyIPadress(String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff)));
mShakeDetected = false; db.getDatafromDBnoListener();
db.getDataBaseValuesWithListener();
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 sensorManagementInit();
getLocationPermission(); getLocationPermission();
}
//#####################################################################################################################################################################
} //################################################################## vvv ShakeCode vvv ##############################################################################
private void sensorManagementInit()
private final SensorEventListener mSensorListener = new SensorEventListener() { {
@Override TextView txtEarthquake = (TextView) findViewById(R.id.txtEarthquake);
public void onSensorChanged(SensorEvent event) { mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
float x = event.values[0]; Objects.requireNonNull(mSensorManager).registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
float y = event.values[1]; mAccel = 1f;
float z = event.values[2]; mAccelCurrent = SensorManager.GRAVITY_EARTH;
mAccelLast = mAccelCurrent; mAccelLast = SensorManager.GRAVITY_EARTH;
mAccelCurrent = (float) Math.sqrt((double) (x * x + y * y + z * z)); mShakeDetectionIsActive = true;
float delta = mAccelCurrent - mAccelLast; mShakeDetected = false;
mAccel = mAccel * 0.9f + delta; }
// Log.d(TAG,"mAccel: "+ mAccel);
if (mShakeDetectionIsActive) { private CountDownTimer mLockTimer = new CountDownTimer(mShakeDetectionLockTimeMicroSeconds, 1000)
if(Math.abs(mAccel) > mUpperThreshold) { {
new CountDownTimer(50, 10) { public void onTick(long millisUntilFinished) {
((TextView) findViewById(R.id.txtEarthquake)).setText("Earthquake started! Detection locked for " + millisUntilFinished / 1000 + " s");
public void onTick(long millisUntilFinished) { }
if (Math.abs(mAccel) > mUpperThreshold) {
mShakeDetectionIsActive = false; public void onFinish() {
} else if (Math.abs(mAccel) < mLowerThreshold) { mShakeDetectionIsActive = true;
mShakeDetectionIsActive = true; mShakeDetected = false;
this.cancel(); Toast.makeText(getApplicationContext(), "Shake Detection unlocked", Toast.LENGTH_SHORT).show();
} ( (TextView) findViewById(R.id.txtEarthquake)).setText("Shake your Smartphone for an Earthquake");
}
} };
public void onFinish() {
if (Math.abs(mAccel) > mUpperThreshold) { private final SensorEventListener mSensorListener = new SensorEventListener() {
mShakeDetectionIsActive = false; @Override
mShakeDetected = true; public void onSensorChanged(SensorEvent event) {
Toast.makeText(getApplicationContext(), "Shake event detected", Toast.LENGTH_SHORT).show(); float x = event.values[0];
writeEarthquakeToDatabase(); float y = event.values[1];
mLockTimer.start(); float z = event.values[2];
} else { mAccelLast = mAccelCurrent;
mShakeDetectionIsActive = true; mAccelCurrent = (float) Math.sqrt((double) (x * x + y * y + z * z));
mShakeDetected = false; float delta = mAccelCurrent - mAccelLast;
} mAccel = mAccel * 0.9f + delta;
} // Log.d(TAG,"mAccel: "+ mAccel);
}.start(); if (mShakeDetectionIsActive) {
} if(Math.abs(mAccel) > mUpperThreshold) {
} new CountDownTimer(50, 10) {
}
@Override public void onTick(long millisUntilFinished) {
public void onAccuracyChanged(Sensor sensor, int accuracy) { if (Math.abs(mAccel) > mUpperThreshold) {
} mShakeDetectionIsActive = false;
}; } else if (Math.abs(mAccel) < mLowerThreshold) {
mShakeDetectionIsActive = true;
private void writeEarthquakeToDatabase() this.cancel();
{ }
setDataBaseValues(true); }
//TODO Erdbeben + Erzeugerparameter in Datenbank schreiben
} @RequiresApi(api = Build.VERSION_CODES.O)
@Override public void onFinish() {
protected void onResume() { if (Math.abs(mAccel) > mUpperThreshold) {
mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), mShakeDetectionIsActive = false;
SensorManager.SENSOR_DELAY_NORMAL); mShakeDetected = true;
super.onResume(); Toast.makeText(getApplicationContext(), "Shake event detected", Toast.LENGTH_SHORT).show();
} writeEarthquakeToDatabase(); //TODO Aron
@Override mLockTimer.start();
protected void onPause() { } else {
mSensorManager.unregisterListener(mSensorListener); mShakeDetectionIsActive = true;
super.onPause(); mShakeDetected = false;
} }
}
private void getLocationPermission() { }.start();
String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION}; }
if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) { }
mLocationPermissionsGranted = true; }
initMap(); @Override
} else { public void onAccuracyChanged(Sensor sensor, int accuracy) {
ActivityCompat.requestPermissions(this, permissions, LOCATION_PERMISSION_REQUEST_CODE); }
} };
}
@Override @Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { protected void onResume() {
super.onRequestPermissionsResult(requestCode, permissions, grantResults); mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
mLocationPermissionsGranted = false; super.onResume();
}
switch (requestCode) { @Override
case LOCATION_PERMISSION_REQUEST_CODE: { protected void onPause() {
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { mSensorManager.unregisterListener(mSensorListener);
mLocationPermissionsGranted = true; super.onPause();
//initalize or map }
initMap(); //################################################################## ^^^^ ShakeCode ^^^^ ############################################################################
} //#####################################################################################################################################################################
}
} //#####################################################################################################################################################################
} //################################################################## vvv GPS Code vvv ###############################################################################
private void getLocationPermission() {
private void initMap() { String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map); if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
mapFragment.getMapAsync(this); mLocationPermissionsGranted = true;
} initMap();
} else {
@Override ActivityCompat.requestPermissions(this, permissions, LOCATION_PERMISSION_REQUEST_CODE);
public void onMapReady(GoogleMap googleMap) { }
Toast.makeText(this, "Map is ready", Toast.LENGTH_SHORT).show(); }
mMap = googleMap;
@Override
if (mLocationPermissionsGranted) { public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
getDeviceLocation(); super.onRequestPermissionsResult(requestCode, permissions, grantResults);
mLocationPermissionsGranted = false;
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) switch (requestCode) {
!= PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, case LOCATION_PERMISSION_REQUEST_CODE: {
Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
mLocationPermissionsGranted = true;
return; initMap(); //initalize or map
} }
mMap.setMyLocationEnabled(true); }
} }
}
// Add a marker in Sydney and move the camera
//LatLng sydney = new LatLng(-34, 151); private void initMap() {
//mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney")); SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
//mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney)); mapFragment.getMapAsync(this);
} }
private void getDeviceLocation(){ @Override
mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this); public void onMapReady(GoogleMap googleMap) {
try { Toast.makeText(this, "Map is ready", Toast.LENGTH_SHORT).show();
if (mLocationPermissionsGranted){ mMap = googleMap;
final Task location = mFusedLocationProviderClient.getLastLocation();
if (mLocationPermissionsGranted) {
location.addOnCompleteListener(new OnCompleteListener() { getDeviceLocation();
@Override if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
public void onComplete(@NonNull Task task) { != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
if (task.isSuccessful()){ Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
currentLocation = (Location) task.getResult(); return;
//currentTime = Calendar.getInstance().getTime(); //Workaround für Crash: currentTime nicht als Datum sondern als Long zeitstempel }
currentTime = Calendar.getInstance().getTimeInMillis(); mMap.setMyLocationEnabled(true);
Toast.makeText(EarthquakeMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show(); }
currentLocation.setLatitude(breitengrad);
currentLocation.setLongitude(laengengrad); //TODO @ Eddy: Ich denke diesen Code brauchst du auch, oder? :D
setDataBaseValues(false); //TODO Edward: Die Funktion geht jetzt. Statt Datum wird Unix Zeitstempel als Long Typ verwendet //Add a marker in Sydney and move the camera
moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f); //LatLng sydney = new LatLng(-34, 151);
} //mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
else{ //mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
Toast.makeText(EarthquakeMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show(); }
}
} private void getDeviceLocation(){
}); mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
} try {
}catch (SecurityException e){ if (mLocationPermissionsGranted){
Log.e(TAG,"Device Location not found" + e.getMessage()); final Task location = mFusedLocationProviderClient.getLastLocation();
}
} location.addOnCompleteListener(new OnCompleteListener() {
private void moveCamera(LatLng latlng, float zoom){ @Override
Log.d(TAG,"Latitude: "+latlng.latitude+"Longitude: "+latlng.longitude); public void onComplete(@NonNull Task task) {
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom)); if (task.isSuccessful()){
} currentLocation = (Location) task.getResult();
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + db.getNativeGPScaseInDB());
if(db.getNativeGPScaseInDB())
public void getDataBaseValues() {
{ System.out.println("---Eigene GPS Daten werden verwendet");
mDatenbank = FirebaseDatabase.getInstance().getReference(); breitengrad = currentLocation.getLatitude();
mDatenbank.addValueEventListener(new ValueEventListener() { laengengrad = currentLocation.getLongitude();
@Override db.setShakeBreitengrad(breitengrad);
public void onDataChange(@NonNull DataSnapshot snapshot) { db.setShakeLaengengrad(laengengrad);
processDataBaseValues(snapshot); //Daten Snapshot, Übergabe an processDataBaseValues }
} /*
@Override if(useOwnGPS) //TODO Aron
public void onCancelled(@NonNull DatabaseError error) { {
getDataBaseFailure(error); breitengrad = currentLocation.getLatitude();
} laengengrad = currentLocation.getLongitude();
}); }
}
*/
public void processDataBaseValues (DataSnapshot data) currentLocation.setLatitude(breitengrad);
{ currentLocation.setLongitude(laengengrad);
//####### Hier wird beispielweise mit IDG1 gearbeitet, sollte aber klüger ausgearbeitet werden #######: moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
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(); else{
breitengrad = Double.parseDouble(breitengradString); Toast.makeText(EarthquakeMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show();
laengengrad = Double.parseDouble(laengengradString); }
} }
});
public void getDataBaseFailure (DatabaseError error) }
{ }catch (SecurityException e){
System.out.println("Fehler"); Log.e(TAG,"Device Location not found" + e.getMessage());
Log.w("Datenbankfehler", error.toException()); }
} }
private void moveCamera(LatLng latlng, float zoom){
//TODO Edward: Hier ist eine beispielhafte Methode mit der du Werte in der Datenbank setzen kannst Log.d(TAG,"Latitude: "+latlng.latitude+"Longitude: "+latlng.longitude);
public void setDataBaseValues(boolean vibration) mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom));
{ }
currentTime = Calendar.getInstance().getTimeInMillis();
WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE); //################################################################## ^^^^ GPS Code ^^^^ #############################################################################
int ip = wm.getConnectionInfo().getIpAddress(); //#####################################################################################################################################################################
String ipAddress = String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff));
mDatenbank = FirebaseDatabase.getInstance().getReference(); //#####################################################################################################################################################################
mDatenbank.child("overview").child("IDG1").child("ip").setValue(ipAddress); //################################################################## vvv Datenbank Code vvv #########################################################################
mDatenbank.child("overview").child("IDG1").child("vibration").setValue(vibration); @RequiresApi(api = Build.VERSION_CODES.O)
mDatenbank.child("overview").child("IDG1").child("timestamp").setValue(currentTime); //aktueller Zeitstempel wird in Datenbank eingetragen private void writeEarthquakeToDatabase()
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(255); boolean nativeGPS;
} if(db.getNativeGPScaseInDB())
} {
nativeGPS = true;
}else{
nativeGPS = false;
}
///Evtl löschen und localDateTimeMod mit LocalDateTime.now(ZoneOffset.UTC).toString() ersetzen...
String localDateTimeMod;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
localDateTimeMod = LocalDateTime.now(ZoneOffset.UTC).toString();
} else
{
localDateTimeMod = LocalDateTime.now(ZoneOffset.UTC).toString();
}
for(int i=1; i<=db.getAmountOfIDGs(); i++)
{
if(!db.getStatusIFAndroidIDexistsInDB(db.getMyAndroidID()))
{
//Wenn eigenen androidID nicht in DB existiert
Devices d1 = new Devices();
d1 = new Devices(db.getMyAndroidID(),
localDateTimeMod,
db.getMyIPadress(),
breitengrad,
laengengrad,
nativeGPS,
true,
Calendar.getInstance().getTimeInMillis(),
1000,
db.getMyWaveSpeed());
db.setIDGtoDevice(i,d1);
break;
}else{
Toast.makeText(getApplicationContext(), "Gerät ist bereits in DB eingetragen!", Toast.LENGTH_SHORT).show();
break;
}
}
}
}
app/src/main/java/de/edotzlaff/schockwelle/MainActivity.java
+197 -159
View File
@@ -1,159 +1,197 @@
package de.edotzlaff.schockwelle; package de.edotzlaff.schockwelle;
import androidx.annotation.NonNull; import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity; import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentActivity; import android.app.Dialog;
import android.content.Intent;
import android.app.Dialog; import android.net.wifi.WifiManager;
import android.content.Intent; import android.os.Bundle;
import android.hardware.Sensor; import android.provider.Settings;
import android.os.Bundle; import android.util.Log;
import android.util.Log; import android.view.View;
import android.view.View; import android.widget.Button;
import android.widget.Button; import android.widget.Toast;
import android.widget.Toast; import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.common.GoogleApiAvailability; import com.google.android.gms.tasks.Task;
import com.google.firebase.database.DataSnapshot; import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError; import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.DatabaseReference; import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
public class MainActivity extends FragmentActivity {
public class MainActivity extends FragmentActivity {
private static final String TAG = "MainActivity";
private static final String TAG = "MainActivity"; private static final int ERROR_DIALOG_REQUEST = 9001;
private static final int ERROR_DIALOG_REQUEST = 9001; private DatabaseReference mDatenbank;
private DatabaseReference mDatenbank; Datenbank db = new Datenbank();
@Override
@Override protected void onCreate(Bundle savedInstanceState) {
protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);
super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);
setContentView(R.layout.activity_main);
if (isServiceOK()){
if (isServiceOK()){ //Für Dantenbank
init();
} db.setMyWaveSpeed(500);
db.setMyAndroidID(Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID));
deviceInitDataBase(); //TODO Edward: Mit dieser Methode wird beim Starten der App die DB mit, vorerst festen, Werten für alle IDG 1-4 initialiert
} WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
int ip = wm.getConnectionInfo().getIpAddress();
private void init(){ db.setMyIPadress(String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff)));
Button btnEarthquake = (Button) findViewById(R.id.btnEarthquake); db.getDatafromDBnoListener();
btnEarthquake.setOnClickListener(new View.OnClickListener() {
@Override init();
public void onClick(View v) { }
Intent intent = new Intent(MainActivity.this, EarthquakeMapsActivity.class); }
startActivity(intent);
} private void init(){
});
Button btnEarthquake = (Button) findViewById(R.id.btnEarthquake);
Button btnSensor = (Button) findViewById(R.id.btnSensor); Button btnSensor = (Button) findViewById(R.id.btnSensor);
btnSensor.setOnClickListener(new View.OnClickListener() { Button btnMuster = (Button) findViewById(R.id.buttonDatenBankMuster);
@Override Button btnLeer = (Button) findViewById(R.id.buttonDatenBankLeeren);
public void onClick(View v) { Button btnReset = (Button) findViewById(R.id.buttonReset);
Intent intent = new Intent(MainActivity.this, SensorMapsActivity.class);
startActivity(intent); btnEarthquake.setEnabled(true);
} btnEarthquake.setOnClickListener(new View.OnClickListener() {
}); @Override
} public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, EarthquakeMapsActivity.class);
public boolean isServiceOK(){ btnEarthquake.setEnabled(true);
Log.d(TAG, "isServicesOK(): checking google services version"); btnSensor.setEnabled(true);
startActivity(intent);
int available = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(MainActivity.this); }
});
if (available== ConnectionResult.SUCCESS){
Log.d(TAG,"isServicesOK: Google Play Services is working"); btnSensor.setEnabled(true);
return true; btnSensor.setOnClickListener(new View.OnClickListener() {
} @Override
else if (GoogleApiAvailability.getInstance().isUserResolvableError(available)){ public void onClick(View v) {
Log.d(TAG, "isServicesOK(): an error occured but we can fix it"); Intent intent = new Intent(MainActivity.this, SensorMapsActivity.class);
Dialog dialog = GoogleApiAvailability.getInstance().getErrorDialog(MainActivity.this, available, ERROR_DIALOG_REQUEST); btnSensor.setEnabled(true);
dialog.show(); btnEarthquake.setEnabled(true);
} startActivity(intent);
else { }
Toast.makeText(this, "You can`t make map request", Toast.LENGTH_SHORT).show(); });
}
return false; btnMuster.setOnClickListener(new View.OnClickListener() {
} @Override
public void onClick(View v) {
public void deviceInitDataBase() btnEarthquake.setEnabled(true);
{ btnSensor.setEnabled(true);
mDatenbank = FirebaseDatabase.getInstance().getReference(); btnLeer.setEnabled(true);
Devices d1 = new Devices("10.00.00.000", false, 1623926431100L, 49.45470362290784, 11.151032510281498, 1000); btnMuster.setEnabled(true);
Devices d2 = new Devices("20.00.00.000", false, 1623926431200L, 40.70064147511923, -73.993767997977787, 200); btnReset.setEnabled(true);
Devices d3 = new Devices("30.00.00.000", false, 1623926431300L, -33.93157129193122, 18.39666975233824, 30); db.setNonNativeCaseInDB();
Devices d4 = new Devices("40.00.00.000", false, 1623926431400L, -33.40763257191139, -70.61870273653996, 4); //deviceInitDataBase(); //TODO: ARON
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); btnLeer.setOnClickListener(new View.OnClickListener() {
getDataBaseValues(); @Override
} public void onClick(View v) {
btnEarthquake.setEnabled(true);
public void getDataBaseValues() btnSensor.setEnabled(true);
{ btnMuster.setEnabled(false);
mDatenbank.addValueEventListener(new ValueEventListener() { btnReset.setEnabled(true);
@Override btnLeer.setEnabled(true);
public void onDataChange(@NonNull DataSnapshot snapshot) { //datenBankLeeren(); //TODO: ARON
processDataBaseValues(snapshot); //Daten - Snapshot, Übergabe an Methode processDataBaseValues db.setEmptyDataInDBcompletlyForNativeUse();
} System.out.println(db.getCommand());
@Override }
public void onCancelled(@NonNull DatabaseError error) { });
getDataBaseFailure(error);
} btnReset.setEnabled(true);
}); btnReset.setOnClickListener(new View.OnClickListener() {
} @Override
public void onClick(View v) {
public void processDataBaseValues (DataSnapshot data) //getDataBaseValuesNoListener(); //TODO ARON
{ btnMuster.setEnabled(true);
for (int i = 1; i<=4; i++) //Für alle IDG 1-4 werden Werte ausgegeben btnLeer.setEnabled(true);
{ btnEarthquake.setEnabled(true);
//####### Auslesen für String-Werte #######: btnSensor.setEnabled(true);
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{ public boolean isServiceOK(){
vibration = false; Log.d(TAG, "isServicesOK(): checking google services version");
}
int available = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(MainActivity.this);
//####### Auslesen für double-Werte #######:
String breitengradString = data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString(); if (available== ConnectionResult.SUCCESS){
String laengengradString = data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString(); Log.d(TAG,"isServicesOK: Google Play Services is working");
double breitengrad = Double.parseDouble(breitengradString); return true;
double laengengrad = Double.parseDouble(laengengradString); }
else if (GoogleApiAvailability.getInstance().isUserResolvableError(available)){
//####### Auslesen für long-Werte #######: Log.d(TAG, "isServicesOK(): an error occured but we can fix it");
String timestampString = data.child("overview").child("IDG" + i).child("timestamp").getValue().toString(); Dialog dialog = GoogleApiAvailability.getInstance().getErrorDialog(MainActivity.this, available, ERROR_DIALOG_REQUEST);
long timestamp = Long.parseLong(timestampString); dialog.show();
}
//####### Auslesen für ing-Werte #######: else {
String amplitudeString = data.child("overview").child("IDG" + i).child("amplitude").getValue().toString(); Toast.makeText(this, "You can`t make map request", Toast.LENGTH_SHORT).show();
int amplitude = Integer.parseInt(amplitudeString); }
return false;
//####### Optional zur Kontrolle #######: }
/*
System.out.println("IDG" + i + " - IP:" + data.child("overview").child("IDG" + i).child("ip").getValue().toString()); public void deviceInitDataBase()
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()); mDatenbank = FirebaseDatabase.getInstance().getReference();
System.out.println("IDG" + i + " - Breitengrad:" + data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString()); Devices d1 = new Devices("","","",49.58967957913626,11.011387124069765,false,false,0,1000,10); //Erlangen 49.58967957913626, 11.011387124069765
System.out.println("IDG" + i + " - Laengengrad:" + data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString()); Devices d2 = new Devices("","","",48.7560280895443,11.425157702952347,false,false,0,1000,10); //Ingolstadt 48.7560280895443, 11.425157702952347
System.out.println("IDG" + i + " - Amplitude:" + data.child("overview").child("IDG" + i).child("amplitude").getValue().toString()); Devices d3 = new Devices("","","",48.16958655466396,11.617418429524394,false,false,0,1000,10); //München 48.16958655466396, 11.617418429524394
*/ Devices d4 = new Devices("","","",45.55620112204013,12.342516140205387,false,false,0,1000,10); //Venedig 45.55620112204013, 12.342516140205387
} Devices d5 = new Devices("","","",41.9204784730154,12.651055829215638,false,false,0,1000,10); //Rom 41.9204784730154, 12.651055829215638
} mDatenbank.child("overviewnodes").child("IDG1").setValue(d1);
mDatenbank.child("overviewnodes").child("IDG2").setValue(d2);
public void getDataBaseFailure (DatabaseError error) mDatenbank.child("overviewnodes").child("IDG3").setValue(d3);
{ mDatenbank.child("overviewnodes").child("IDG4").setValue(d4);
System.out.println("Fehler"); mDatenbank.child("overviewnodes").child("IDG5").setValue(d4);
Log.w("Datenbankfehler", error.toException()); mDatenbank.child("overviewnodes").child("IDG5").setValue(d5);
} }
}
public void getDataBaseValuesNoListener()
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overviewnodes").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<=5; i++)
{
mDatenbank.child("overviewnodes").child("IDG" + i).child("a_androidid").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("b_localdatetime").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("c_ip").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("d_breitengrad").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("e_laengengrad").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("f_nativegps").setValue(true);
mDatenbank.child("overviewnodes").child("IDG" + i).child("g_vibration").setValue(false);
mDatenbank.child("overviewnodes").child("IDG" + i).child("h_timestamp").setValue("");
mDatenbank.child("overviewnodes").child("IDG" + i).child("i_amplitude").setValue("");
}
}
public void testProcess(DataSnapshot data)
{
mDatenbank = FirebaseDatabase.getInstance().getReference().child("overviewnodes");
}
}
app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java
+659 -330
View File
@@ -1,330 +1,659 @@
package de.edotzlaff.schockwelle; package de.edotzlaff.schockwelle;
import android.Manifest; import android.Manifest;
import android.content.Context; import android.content.Context;
import android.content.pm.PackageManager; import android.content.Intent;
import android.location.Location; import android.content.pm.PackageManager;
import android.os.Build; import android.location.Location;
import android.os.Bundle; import android.net.wifi.WifiManager;
import android.os.CountDownTimer; import android.os.Build;
import android.os.VibrationEffect; import android.os.Bundle;
import android.os.Vibrator; import android.os.CountDownTimer;
import android.util.Log; import android.os.VibrationEffect;
import android.widget.TextView; import android.os.Vibrator;
import android.widget.Toast; import android.provider.Settings;
import android.util.Log;
import androidx.annotation.NonNull; import android.widget.TextView;
import androidx.annotation.RequiresApi; import android.widget.Toast;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat; import androidx.annotation.NonNull;
import androidx.fragment.app.FragmentActivity; import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;
import com.google.android.gms.location.FusedLocationProviderClient; import androidx.core.content.ContextCompat;
import com.google.android.gms.location.LocationServices; import androidx.fragment.app.FragmentActivity;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap; import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.maps.OnMapReadyCallback; import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.SupportMapFragment; import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.model.LatLng; import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.model.MarkerOptions; import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.tasks.OnCompleteListener; import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.tasks.Task; import com.google.android.gms.maps.model.LatLng;
import com.google.firebase.database.DataSnapshot; import com.google.android.gms.maps.model.MarkerOptions;
import com.google.firebase.database.DatabaseError; import com.google.android.gms.tasks.OnCompleteListener;
import com.google.firebase.database.DatabaseReference; import com.google.android.gms.tasks.Task;
import com.google.firebase.database.FirebaseDatabase; import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.ValueEventListener; import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import java.util.Calendar; import com.google.firebase.database.FirebaseDatabase;
import java.util.Date; import com.google.firebase.database.ValueEventListener;
public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCallback { import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Calendar;
private static final String TAG = "MainActivity"; import java.util.Date;
private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234; public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCallback {
private static final double EARTHQUAKE_VELOCITY = 1; // 1 Meter pro Sekunde Erdbebengeschwindigkeit
//vars
private Boolean mLocationPermissionsGranted = false; private static final String TAG = "MainActivity";
private GoogleMap mMap; private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
private FusedLocationProviderClient mFusedLocationProviderClient; private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
private static final double EARTHQUAKE_VELOCITY = 1; // 1 Meter pro Sekunde Erdbebengeschwindigkeit
Date currentTime; Datenbank db = new Datenbank();
Location currentLocation;
//vars
private double breitengrad; private Boolean mLocationPermissionsGranted = false;
private double laengengrad; private GoogleMap mMap;
private FusedLocationProviderClient mFusedLocationProviderClient;
private DatabaseReference mDatenbank;
//Date currentTime;
//Vibration Location currentLocation;
private Boolean mDeviceCanVibrate = false; Long currentTime;
@Override private double breitengrad;
protected void onCreate(Bundle savedInstanceState) { private double laengengrad;
super.onCreate(savedInstanceState); private double sensorGPSbreitengrad;
setContentView(R.layout.activity_sensor_maps); private double sensorGPSlaengengrad;
private boolean useOwnGPS;
TextView tv= (TextView) findViewById(R.id.txtSensor); private boolean takeGPSfromDB = true;
private boolean tookOwnGPS = false;
getLocationPermission(); //Zuerst werden die aktuellen Standortdaten ermittelt private boolean globalShit = true;
private boolean permissionToWriteToDataBase = true;
getDataBaseValues(); // Hier werden die Daten von der DB abgefragt //TODO Edward: Geht wieder :D private DataSnapshot datenBankSnapShot;
getVibrationAbility(); boolean vibrationTrigger = true;
//distance(currentLocation.getLatitude(), currentLocation.getLongitude(),breitengrad,laengengrad); //Übergabe zur Berechnung der Distanz zwischen Auslöser und aktuellem Standort boolean grabGPSandID = true;
//TODO Patrick: die Funktion distance gibt Meter zurück, könntest Du das mit dem Zeitstempel und der Berechnung bis zur Vibration machen?
// setVibrationTimer(10000,1000,255);
} private DatabaseReference mDatenbank;
private String breitengradQuellVibration;
private void getLocationPermission() { private String laengengradQuellVibration;
String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) { private Boolean mDeviceCanVibrate = false;
mLocationPermissionsGranted = true;
initMap(); @Override
} else { protected void onCreate(Bundle savedInstanceState) {
ActivityCompat.requestPermissions(this, permissions, LOCATION_PERMISSION_REQUEST_CODE); super.onCreate(savedInstanceState);
} setContentView(R.layout.activity_sensor_maps);
}
//Database Init
private void getVibrationAbility() db.setMyWaveSpeed(500);
{ db.setMyAndroidID(Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID));
// Get instance of Vibrator from current Context WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); int ip = wm.getConnectionInfo().getIpAddress();
db.setMyIPadress(String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff)));
// Output yes if can vibrate, no otherwise /*
if (v.hasVibrator()) { db.getDatafromDBnoListener();
Log.v("Can Vibrate", "YES"); db.getDataBaseValuesWithListener();
// Log.v("Can Control Amplitude", v.hasAmplitudeControl() ? "YES" : "NO");
mDeviceCanVibrate = true; */
}
else getDataBaseValuesWithListener();
{
TextView tv= (TextView) findViewById(R.id.txtSensor);
Log.v("Can Vibrate", "NO"); getLocationPermission(); //Zuerst werden die aktuellen Standortdaten ermittelt
mDeviceCanVibrate = false;
} getVibrationAbility();
} }
private long getTimeStampDifference(float distance)
{ //#####################################################################################################################################################################
long diff= 0; //################################################################## vvv ShakeCode vvv ##############################################################################
//TODO Zeitdifferenz in Millisekunden zwischen aktuellen Uhrzeit und Vibratonszeitstempel berechnen private void getVibrationAbility()
{
// Get instance of Vibrator from current Context
if (distance>0) Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
{
diff = (long)Math.round(1/(EARTHQUAKE_VELOCITY/distance)); // Output yes if can vibrate, no otherwise
} if (v.hasVibrator()) {
return diff; Log.v("Can Vibrate", "YES");
} // Log.v("Can Control Amplitude", v.hasAmplitudeControl() ? "YES" : "NO");
private void setVibrationTimer(long msDelay, int duration, int amplitude) mDeviceCanVibrate = true;
{ }
else
new CountDownTimer(msDelay, 1000) { {
public void onTick(long millisUntilFinished) {
((TextView) findViewById(R.id.txtSensor)).setText("Earthquake hits in " + millisUntilFinished / 1000 + " s"); Log.v("Can Vibrate", "NO");
} mDeviceCanVibrate = false;
}
public void onFinish() { }
Toast.makeText(getApplicationContext(), "The Ground is shaking!", Toast.LENGTH_SHORT).show(); private void setVibrationTimer(long msDelay, int duration, int amplitude, int index)
performVibration(duration, amplitude); {
( (TextView) findViewById(R.id.txtSensor)).setText("No Earthquake upcoming"); new CountDownTimer(msDelay, 1000) {
} public void onTick(long millisUntilFinished) {
}.start(); ((TextView) findViewById(R.id.txtSensor)).setText("Earthquake hits in " + millisUntilFinished / 1000 + " s");
} }
public void performVibration(int duration, int amplitude) { @RequiresApi(api = Build.VERSION_CODES.O)
if(!mDeviceCanVibrate) public void onFinish() {
return; Toast.makeText(getApplicationContext(), "The Ground is shaking!", Toast.LENGTH_SHORT).show();
performVibration(duration, amplitude);
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); ( (TextView) findViewById(R.id.txtSensor)).setText("No Earthquake upcoming");
if (Build.VERSION.SDK_INT >= 26) { //Hier wird in DB geschrieben
if(duration == 0) setVibrationInDataBase(index); //TODO Aron
{ }
v.cancel(); //stop vibration if still running }.start();
Toast.makeText(this, "Vibration has been stopped", Toast.LENGTH_SHORT).show(); }
return;
} public void performVibration(int duration, int amplitude) {
if(!mDeviceCanVibrate)
Toast.makeText(this, "Ampl: " + amplitude + ", Dur: " + duration, Toast.LENGTH_SHORT).show(); return;
v.vibrate(VibrationEffect.createOneShot(duration,amplitude)); Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
if (Build.VERSION.SDK_INT >= 26) {
if(amplitude > 255 || amplitude < 1)
} else { amplitude = VibrationEffect.DEFAULT_AMPLITUDE;
if(duration == 0)
if(duration == 0) {
{ v.cancel(); //stop vibration if still running
v.cancel(); //stop vibration if still running Toast.makeText(this, "Vibration has been stopped", Toast.LENGTH_SHORT).show();
return;
return; }
} //Toast.makeText(this, "Ampl: " + amplitude + ", Dur: " + duration, Toast.LENGTH_SHORT).show();
v.vibrate(duration); v.vibrate(VibrationEffect.createOneShot(duration,amplitude));
}
}
} else {
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if(duration == 0)
super.onRequestPermissionsResult(requestCode, permissions, grantResults); {
mLocationPermissionsGranted = false; v.cancel(); //stop vibration if still running
return;
switch (requestCode) { }
case LOCATION_PERMISSION_REQUEST_CODE: {
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { v.vibrate(duration);
mLocationPermissionsGranted = true; }
//initalize or map }
initMap(); //################################################################## ^^^^ ShakeCode ^^^^ ############################################################################
} //#####################################################################################################################################################################
}
} //#####################################################################################################################################################################
} //################################################################## vvv GPS Code vvv ###############################################################################
void initMap(){ private void getLocationPermission() {
// Obtain the SupportMapFragment and get notified when the map is ready to be used. String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager() if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
.findFragmentById(R.id.map); mLocationPermissionsGranted = true;
mapFragment.getMapAsync(this); initMap();
} } else {
ActivityCompat.requestPermissions(this, permissions, LOCATION_PERMISSION_REQUEST_CODE);
@Override }
public void onMapReady(GoogleMap googleMap) { }
Toast.makeText(this, "Map is ready", Toast.LENGTH_SHORT).show(); @Override
mMap = googleMap; public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (mLocationPermissionsGranted) { mLocationPermissionsGranted = false;
getDeviceLocation();
switch (requestCode) {
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) case LOCATION_PERMISSION_REQUEST_CODE: {
!= PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { mLocationPermissionsGranted = true;
//initalize or map
return; initMap();
} }
mMap.setMyLocationEnabled(true); }
} }
}
// Add a marker in Sydney and move the camera
LatLng sydney = new LatLng(-34, 151); void initMap(){
mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney")); // Obtain the SupportMapFragment and get notified when the map is ready to be used.
mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney)); SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
} .findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
private void getDeviceLocation(){ }
mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
try { @Override
if (mLocationPermissionsGranted){ public void onMapReady(GoogleMap googleMap) {
final Task location = mFusedLocationProviderClient.getLastLocation();
Toast.makeText(this, "Map is ready", Toast.LENGTH_SHORT).show();
location.addOnCompleteListener(new OnCompleteListener() { mMap = googleMap;
@Override if (mLocationPermissionsGranted) {
public void onComplete(@NonNull Task task) { getDeviceLocation();
if (task.isSuccessful()){
currentLocation = (Location) task.getResult(); if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
currentTime = Calendar.getInstance().getTime(); != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
Toast.makeText(SensorMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show(); Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
} return;
else{ }
Toast.makeText(SensorMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show(); mMap.setMyLocationEnabled(true);
} }
}
}); //TODO @ Eddy: Ich denke diesen Code brauchst du noch, oder? :D
} //Add a marker in Sydney and move the camera
}catch (SecurityException e){ //LatLng sydney = new LatLng(-34, 151);
Log.e(TAG,"Device Location not found" + e.getMessage()); //mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
} //mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
} }
private void moveCamera(LatLng latlng, float zoom){ private void getDeviceLocation(){
Log.d(TAG,"Latitude: "+latlng.latitude+"Longitude: "+latlng.longitude); mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom)); try {
} if (mLocationPermissionsGranted){
final Task location = mFusedLocationProviderClient.getLastLocation();
//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() location.addOnCompleteListener(new OnCompleteListener() {
{
mDatenbank = FirebaseDatabase.getInstance().getReference(); @Override
mDatenbank.addValueEventListener(new ValueEventListener() { public void onComplete(@NonNull Task task) {
@Override if (task.isSuccessful()){
public void onDataChange(@NonNull DataSnapshot snapshot) { currentLocation = (Location) task.getResult();
processDataBaseValues(snapshot); currentTime = Calendar.getInstance().getTimeInMillis();
}
@Override /*
public void onCancelled(@NonNull DatabaseError error) { if(!db.getNativeGPScaseInDB())
getDataBaseFailure(error); {
} System.out.println("---Fremde GPS Daten werden verwendet");
}); currentLocation.setLatitude(breitengrad);
} currentLocation.setLongitude(laengengrad);
}
public void processDataBaseValues (DataSnapshot data)
{ */
for (int i = 1; i<=4; i++) //Für alle IDG 1-4 werden Werte ausgegeben if (!useOwnGPS)
{ {
//####### Auslesen für String-Werte #######: currentLocation.setLatitude(breitengrad);
String ipAdresse = data.child("overview").child("IDG" + i).child("ip").getValue().toString(); currentLocation.setLongitude(laengengrad);
}
//####### Auslesen für boolean-Werte #######:
String vibrationString = data.child("overview").child("IDG" + i).child("vibration").getValue().toString(); //Toast.makeText(SensorMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show();
boolean vibration; moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
if(vibrationString == "true"){ }
vibration = true; else{
}else{ Toast.makeText(SensorMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show();
vibration = false; }
} }
});
//####### Auslesen für double-Werte #######: }
String breitengradString = data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString(); }catch (SecurityException e){
String laengengradString = data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString(); Log.e(TAG,"Device Location not found" + e.getMessage());
double breitengrad = Double.parseDouble(breitengradString); }
double laengengrad = Double.parseDouble(laengengradString); }
//####### Auslesen für long-Werte #######: private void moveCamera(LatLng latlng, float zoom){
String timestampString = data.child("overview").child("IDG" + i).child("timestamp").getValue().toString(); Log.d(TAG,"Latitude: "+latlng.latitude+"Longitude: "+latlng.longitude);
long timestamp = Long.parseLong(timestampString); mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom));
}
//####### Auslesen für ing-Werte #######:
String amplitudeString = data.child("overview").child("IDG" + i).child("amplitude").getValue().toString(); //################################################################## ^^^^ GPS Code ^^^^ #############################################################################
int amplitude = Integer.parseInt(amplitudeString); //#####################################################################################################################################################################
//TODO Workaround beseiteigen: hier wird immer davon ausgegangen, dass auslösendes Gerät die ID 1 besitzt
if(vibration == true && i == 1) //#####################################################################################################################################################################
{ //################################################################## vvv DB Code vvv ###############################################################################
float distance = distance(currentLocation.getLatitude(), currentLocation.getLongitude(),breitengrad,laengengrad);
long delay = getTimeStampDifference(distance); //Datenbank auslesen mit Listener. D.h. es werden Daten (snapshot) ausgelesen und gleichzeitig ein Listener hinterlegt.
setVibrationTimer(delay,1000,amplitude); //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()
//####### Optional zur Kontrolle #######: {
/* mDatenbank = FirebaseDatabase.getInstance().getReference();
System.out.println("IDG" + i + " - IP:" + data.child("overview").child("IDG" + i).child("ip").getValue().toString()); mDatenbank.addValueEventListener(new ValueEventListener() {
System.out.println("IDG" + i + " - Vibration:" + data.child("overview").child("IDG" + i).child("vibration").getValue().toString()); @Override
System.out.println("IDG" + i + " - Zeitstempel:" + data.child("overview").child("IDG" + i).child("timestamp").getValue().toString()); public void onDataChange(@NonNull DataSnapshot snapshot) {
System.out.println("IDG" + i + " - Breitengrad:" + data.child("overview").child("IDG" + i).child("breitengrad").getValue().toString()); processDataBaseUpdate(snapshot);
System.out.println("IDG" + i + " - Laengengrad:" + data.child("overview").child("IDG" + i).child("laengengrad").getValue().toString()); datenBankSnapShot = snapshot;
System.out.println("IDG" + i + " - Amplitude:" + data.child("overview").child("IDG" + i).child("amplitude").getValue().toString()); }
*/ @Override
} public void onCancelled(@NonNull DatabaseError error) {
} getDataBaseFailure(error);
}
public void getDataBaseFailure (DatabaseError error) });
{ }
System.out.println("Fehler");
Log.w("Datenbankfehler", error.toException()); public void processDataBaseUpdate (DataSnapshot data)
} {
int indexMax = (int) data.child("overviewnodes").getChildrenCount();
//TODO Edward Dauer für Timer berechnen bis Smartphone vibriert //Festellen ob DB oder eigene GPS-Daten verwendet werden sollen
if(analyzeForUseOfOwnGPS(data))
private float distance(double currentlatitude, double currentlongitude, double originLat, double originLon) { {
useOwnGPS = true;
float[] results = new float[1]; }
Location.distanceBetween(currentlatitude, currentlongitude, originLat, originLon, results); else
float distanceInMeters = results[0]; {
useOwnGPS = false;
return distanceInMeters; }
} //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)
{
if(analyzeIfAnroidIdIsEmpty(data,f))
{
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;
}
}
}
}
//Hier sind die Schreibregeln für die DB definiert wenn Sensor aktiviert ist
for (int f = 1; f<=indexMax; f++)
{
if((!analyzeIfAnroidIdIsEmpty(data,f) && !analyzeForOwnAndroidID(data,f) && analyzeForStateOfVibration(data,f) && analyzeForExisitingGPSvalues(data,f) && permissionToWriteToDataBase))
{
System.out.println("Index: " + f + ": Eintrittskriterien erfüllt.");
//Nehme Quelle GPS Daten
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))
{
System.out.println("Index: " + f + ": Eigene ID vorhanden.");
if (!analyzeForStateOfVibration(data,f))
{
System.out.println("Index: " + f + ": Vibration is false.");
if(analyzeForExisitingGPSvalues(data,f) && permissionToWriteToDataBase)
{
//System.out.println("Index: " + f + ": Beide GPS Daten vorhanden. Ich reserviere mir diesen Platz und schreibe hier demnächst rein.");
//hier sofort ID eintragen
//mDatenbank = FirebaseDatabase.getInstance().getReference();
//mDatenbank.child("overviewnodes").child("IDG" + f).child("a_androidid").setValue(getandroidid());
float distanceToEarthquake;
distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
long wellenAusbreitungsGeschwindigkeit = (long) db.getMyWaveSpeed(); //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 ist bereits true.");
break;
}
}
else
{
System.out.println("Index: " + f + ": Eigene ID nicht vorhanden");
for(f = f; f<=indexMax; f++)
{
if((analyzeIfAnroidIdIsEmpty(data,f) || analyzeForOwnAndroidID(data,f)) && permissionToWriteToDataBase)
{
//System.out.println("Index: " + f + ": Diese Slot war leer oder es ist meine eigene ID. Ich schreibe hier rein");
//mDatenbank = FirebaseDatabase.getInstance().getReference();
//mDatenbank.child("overviewnodes").child("IDG" + f).child("a_androidid").setValue(getandroidid());
float distanceToEarthquake;
distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
long wellenAusbreitungsGeschwindigkeit = (long) db.getMyWaveSpeed(); //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 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;
boolean bothGPSvaluesExist = false;
int indexMax = (int) data.child("overviewnodes").getChildrenCount();
for (int i = k; i <= k; i++)
{
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())
{
bothGPSvaluesExist = true;
}else
{
bothGPSvaluesExist = false;
}
}
return bothGPSvaluesExist;
}
public void allocateIDtoDatabaseSlot(int k)
{
mDatenbank = FirebaseDatabase.getInstance().getReference();
mDatenbank.child("overviewnodes").child("IDG" + k).child("a_androidid").setValue(getandroidid());
}
@RequiresApi(api = Build.VERSION_CODES.O)
public void setVibrationInDataBase(int k)
{
System.out.println("Es wird versucht in DB zu schreiben....");
for(k =k; k<=datenBankSnapShot.child("overviewnodes").getChildrenCount();k++)
{
System.out.println("Index...." + k);
System.out.println("analyzeIfAnroidIdIsEmpty(datenBankSnapShot,k)" + k + "___" + analyzeIfAnroidIdIsEmpty(datenBankSnapShot,k));
System.out.println("analyzeForOwnAndroidID(datenBankSnapShot,k)" + k + "___" + analyzeForOwnAndroidID(datenBankSnapShot,k));
System.out.println("analyzeForStateOfVibration(datenBankSnapShot,k)" + k + "___" + analyzeForStateOfVibration(datenBankSnapShot,k));
//Wenn Leer ODER eigene ID und Vibration = false;
if((analyzeIfAnroidIdIsEmpty(datenBankSnapShot,k) || analyzeForOwnAndroidID(datenBankSnapShot,k) && !analyzeForStateOfVibration(datenBankSnapShot,k) ))
{
System.out.println("Android ID war leer oder es war eigene ID mit Vibration = false. SChreibe in DB...... " + k);
//Reinschreieben
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("b_localdatetime").setValue(LocalDateTime.now(ZoneOffset.UTC).toString());
}
mDatenbank.child("overviewnodes").child("IDG" + k).child("c_ip").setValue(getDeviceIpAdress());
if (useOwnGPS)
{
mDatenbank.child("overviewnodes").child("IDG" + k).child("f_nativegps").setValue(true);
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);
mDatenbank.child("overviewnodes").child("IDG" + k).child("w_wellengeschwindigkeit").setValue(db.getMyWaveSpeed());
break;
}else
{
System.out.println("Erhöhe Index weil nicht durchgekommen" + k);
//k erhöhen solange leerer Slot ist oder abbruch weil zu voll
if(k ==(int) datenBankSnapShot.child("overviewnodes").getChildrenCount())
{
System.out.println("Kein freier Slot mehr vorhanden");
break;
}
}
}
}
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("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;
}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);
}
*/
}
//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)
{
long diff= 0;
if (distance>0)
{
diff = (long)Math.round(1/(EARTHQUAKE_VELOCITY/distance));
}
return diff;
}
}
app/src/main/res/layout/activity_earthquake_maps.xml
+27 -27
View File
@@ -1,28 +1,28 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools" xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent" android:layout_width="match_parent"
android:layout_height="match_parent" android:layout_height="match_parent"
tools:context=".EarthquakeMapsActivity"> tools:context=".EarthquakeMapsActivity"
android:paddingTop="?attr/actionBarSize">
<TextView
android:id="@+id/txtEarthquake" <TextView
android:layout_width="wrap_content" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_height="wrap_content"
android:layout_centerHorizontal="true" android:text="@string/shake_your_smartphone_for_a_earthquake"
android:text="Shake your Smartphone for an 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" <androidx.fragment.app.FragmentContainerView xmlns:map="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools" android:layout_below="@+id/txtEarthquake"
android:layout_below="@+id/txtEarthquake" android:id="@+id/map"
android:id="@+id/map" android:name="com.google.android.gms.maps.SupportMapFragment"
android:name="com.google.android.gms.maps.SupportMapFragment" android:layout_width="match_parent"
android:layout_width="match_parent" android:layout_height="match_parent"
android:layout_height="match_parent" android:layout_marginTop="50dp"
tools:context=".EarthquakeMapsActivity" /> tools:context=".EarthquakeMapsActivity" />
</RelativeLayout> </RelativeLayout>
app/src/main/res/layout/activity_main.xml
+51 -25
View File
@@ -1,26 +1,52 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools" xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent" android:layout_width="match_parent"
android:layout_height="match_parent" android:layout_height="match_parent"
tools:context=".MainActivity"> tools:context=".MainActivity">
<Button <Button
android:layout_width="wrap_content" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_height="wrap_content"
android:id="@+id/btnEarthquake" android:id="@+id/btnEarthquake"
android:text="@string/generate_earthquake" android:text="@string/generate_earthquake"
android:layout_centerVertical="true" android:layout_centerVertical="true"
android:layout_centerHorizontal="true" /> android:layout_centerHorizontal="true" />
<Button <Button
android:layout_width="wrap_content" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_height="wrap_content"
android:id="@+id/btnSensor" android:id="@+id/btnSensor"
android:text="@string/be_a_sensor" android:text="@string/be_a_sensor"
android:layout_centerHorizontal="true" android:layout_centerHorizontal="true"
android:layout_below="@id/btnEarthquake"/> 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> </RelativeLayout>
app/src/main/res/layout/activity_sensor_maps.xml
+26 -26
View File
@@ -1,27 +1,27 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools" xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent" android:layout_width="match_parent"
android:layout_height="match_parent" android:layout_height="match_parent"
tools:context=".EarthquakeMapsActivity"> tools:context=".EarthquakeMapsActivity">
<TextView <TextView
android:layout_width="wrap_content" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_height="wrap_content"
android:text="Timer till vibration" android:text="Timer till vibration"
android:layout_centerHorizontal="true" android:layout_centerHorizontal="true"
android:id="@+id/txtSensor"/> android:id="@+id/txtSensor"/>
<fragment xmlns:android="http://schemas.android.com/apk/res/android" <fragment xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:map="http://schemas.android.com/apk/res-auto" xmlns:map="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools" xmlns:tools="http://schemas.android.com/tools"
android:layout_below="@+id/txtSensor" android:layout_below="@+id/txtSensor"
android:id="@+id/map" android:id="@+id/map"
android:name="com.google.android.gms.maps.SupportMapFragment" android:name="com.google.android.gms.maps.SupportMapFragment"
android:layout_width="match_parent" android:layout_width="match_parent"
android:layout_height="match_parent" android:layout_height="match_parent"
tools:context=".SensorMapsActivity" /> tools:context=".SensorMapsActivity" />
</RelativeLayout> </RelativeLayout>
app/src/main/res/values/strings.xml
+16 -6
View File
@@ -1,7 +1,17 @@
<resources> <resources>
<string name="app_name">Schockwelle</string> <string name="app_name">Schockwelle</string>
<string name="title_activity_earthquake_maps">Map</string> <string name="title_activity_earthquake_maps">Map</string>
<string name="title_activity_sensor_maps">Map</string> <string name="title_activity_sensor_maps">Map</string>
<string name="be_a_sensor">Be a Sensor</string> <string name="be_a_sensor">Be a Sensor</string>
<string name="generate_earthquake">Generate Earthquake</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> </resources>