mMDT5_PR_MSY1_Gruppe1/app/src/main/java/de/edotzlaff/schockwelle/SensorMapsActivity.java

package de.edotzlaff.schockwelle;

import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Location;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.VibrationEffect;
import android.os.Vibrator;
import android.provider.Settings;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.FragmentActivity;

import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
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.util.Calendar;
import java.util.Date;

public class SensorMapsActivity extends FragmentActivity implements OnMapReadyCallback {


    private static final String TAG = "MainActivity";
    private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
    private static final double EARTHQUAKE_VELOCITY = 1; // 1 Meter pro Sekunde Erdbebengeschwindigkeit

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

    //Date currentTime;
    Location currentLocation;
    Long currentTime;

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

    boolean vibrationTrigger = true;
    boolean grabGPSandID = true;


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

    private Boolean mDeviceCanVibrate = false;

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

        getDataBaseValuesWithListener();

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

        getVibrationAbility();
        System.out.println("Global Shit: " + globalShit);
    }
    @Override
    protected void onPause()
    {

    super.onPause();
    }
    @Override
    protected void onResume()
    {

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

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

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

    private void setVibrationTimer(long msDelay, int duration, int amplitude, int index)
    {
    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!setVibrationTimer wurde getriggert mit Index " + index);
        new CountDownTimer(msDelay, 1000) {
            public void onTick(long millisUntilFinished) {
                ((TextView)   findViewById(R.id.txtSensor)).setText("Earthquake hits in " + millisUntilFinished / 1000 + " s");
            }

            public void onFinish() {
                Toast.makeText(getApplicationContext(), "The Ground is shaking!", Toast.LENGTH_SHORT).show();
                performVibration(duration, amplitude);
                ( (TextView)   findViewById(R.id.txtSensor)).setText("No Earthquake upcoming");
                //Hier wird tatsächlich die DB beschrieben sobald der Timer abgelaufen ist
                setVibrationInDataBase(index);
            }
        }.start();
    }

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

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

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

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


        } else {

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

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

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

    private void getLocationPermission() {
        String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION};
        if (ContextCompat.checkSelfPermission(this.getApplicationContext(), FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            mLocationPermissionsGranted = true;
            initMap();
        } else {
            ActivityCompat.requestPermissions(this, permissions, LOCATION_PERMISSION_REQUEST_CODE);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        mLocationPermissionsGranted = false;

        switch (requestCode) {
            case LOCATION_PERMISSION_REQUEST_CODE: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    mLocationPermissionsGranted = true;
                    //initalize or map
                    initMap();
                }
            }
        }
    }

    void initMap(){
        // Obtain the SupportMapFragment and get notified when the map is ready to be used.
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {

        Toast.makeText(this, "Map is ready", Toast.LENGTH_SHORT).show();
        mMap = googleMap;

        if (mLocationPermissionsGranted) {
            getDeviceLocation();

            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                    != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

                return;
            }
            mMap.setMyLocationEnabled(true);
        }

        //TODO @ Eddy: Ich denke diesen Code brauchst du noch, oder? :D
        //Add a marker in Sydney and move the camera
        //LatLng sydney = new LatLng(-34, 151);
        //mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
        //mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));
    }

    private void getDeviceLocation(){
        mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
        try {
            if (mLocationPermissionsGranted){
                final Task location = mFusedLocationProviderClient.getLastLocation();

                location.addOnCompleteListener(new OnCompleteListener() {

                    @Override
                    public void onComplete(@NonNull Task task) {
                        if (task.isSuccessful()){
                            currentLocation = (Location) task.getResult();
                            currentTime = Calendar.getInstance().getTimeInMillis();
                            if (!useOwnGPS)
                            {
                                currentLocation.setLatitude(breitengrad);
                                currentLocation.setLongitude(laengengrad);
                            }
                            Toast.makeText(SensorMapsActivity.this, currentTime.toString(), Toast.LENGTH_SHORT).show();
                            moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),15f);
                        }
                        else{
                            Toast.makeText(SensorMapsActivity.this, "Current Location unavailable", Toast.LENGTH_SHORT).show();
                        }
                    }
                });
            }
        }catch (SecurityException e){
            Log.e(TAG,"Device Location not found" + e.getMessage());
        }
    }

    private void moveCamera(LatLng latlng, float zoom){
        Log.d(TAG,"Latitude: "+latlng.latitude+"Longitude: "+latlng.longitude);
        mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latlng, zoom));
    }

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

    //#####################################################################################################################################################################
    //##################################################################  vvv DB Code vvv  ###############################################################################

    //Datenbank auslesen mit Listener. D.h. es werden Daten (snapshot) ausgelesen und gleichzeitig ein Listener hinterlegt.
    //Sollten sich danach Daten zu einem beliebigen Zeitpunkt in der DB ändern, wird die Funktion "onDataChange" erneut ausgelöst und wieder Daten (snapshot) ausgelesen.
    public void getDataBaseValuesWithListener()
    {
        mDatenbank = FirebaseDatabase.getInstance().getReference();
        mDatenbank.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                processDataBaseUpdate(snapshot);
            }
            @Override
            public void onCancelled(@NonNull DatabaseError error) {
                getDataBaseFailure(error);
            }
        });
    }

    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 processDataBaseUpdate (DataSnapshot data)
    {

        int indexMax = (int) data.child("overviewnodes").getChildrenCount();

        //Festellen ob DB oder eigene GPS-Daten verwendet werden sollen
        if(analyzeForUseOfOwnGPS(data))
        {
            useOwnGPS = true;
        }
        else
        {
            useOwnGPS = false;
        }

        //Wichtig zur Verwendung von GPS-Daten explizit aus der Datenbank
        if(!useOwnGPS && grabGPSandID)
        {
            for (int f = 1; f<=indexMax; f++)
            {
                if(f>=2 && f<=indexMax)
                {
                    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 && permissionToWriteToDataBase; f++)
        {
            if((!analyzeIfAnroidIdIsEmpty(data,f) && !analyzeForOwnAndroidID(data,f) && analyzeForStateOfVibration(data,f) && analyzeForExisitingGPSvalues(data,f) && permissionToWriteToDataBase))
            {
                String breitengradString = data.child("overviewnodes").child("IDG" + f).child("d_breitengrad").getValue().toString();
                String laengengradString = data.child("overviewnodes").child("IDG" + f).child("e_laengengrad").getValue().toString();
                breitengradQuellVibration = breitengradString;
                laengengradQuellVibration = laengengradString;

                f=1;
                if(analyzeForOwnAndroidID(data,f))
                {
                    if (!analyzeForStateOfVibration(data,f))
                    {
                        if(analyzeForExisitingGPSvalues(data,f))
                        {
                            float distanceToEarthquake;
                            distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
                            long wellenAusbreitungsGeschwindigkeit = 4500;    //Meter die Sekunde
                            long delayInSeconds = (long) distanceToEarthquake/wellenAusbreitungsGeschwindigkeit; //s
                            long delayInMilliSeconds = delayInSeconds*1000;
                            setVibrationTimer(delayInMilliSeconds,1500,255,f);
                            permissionToWriteToDataBase = false;
                            break;
                        }
                        else{
                            System.out.println("###Index " + f + " >>>Habe keine GPS daten...");
                        }
                    }else{
                        System.out.println(">>>Index " + f + " >>>Meine Vibration wurde breits true gesetzt. Falscher Alarm");
                        break;
                    }
                }
                else
                {
                    for(f = f; f<=indexMax; f++)
                    {
                        if(analyzeIfAnroidIdIsEmpty(data,f) || analyzeForOwnAndroidID(data,f))
                        {
                            float distanceToEarthquake;
                            distanceToEarthquake = distance(currentLocation.getLatitude(), currentLocation.getLongitude(), Double.parseDouble(breitengradQuellVibration), Double.parseDouble(laengengradQuellVibration));
                            long wellenAusbreitungsGeschwindigkeit = 4500;    //Meter die Sekunde
                            long delayInSeconds = (long) distanceToEarthquake/wellenAusbreitungsGeschwindigkeit; //s
                            long delayInMilliSeconds = delayInSeconds*1000;
                            setVibrationTimer(delayInMilliSeconds,1500,255,f);
                            permissionToWriteToDataBase = false;
                            break;
                        }

                        if(f == indexMax && !analyzeIfAnroidIdIsEmpty(data,f))
                        {
                           System.out.println(">>>Index " + f + " >>>Konnte keine freien Slot finden");
                        }
                    }
                }
            }
        }
    }


    public void allocateIDtoDatabaseSlot(int k)
    {
        mDatenbank = FirebaseDatabase.getInstance().getReference();
        mDatenbank.child("overviewnodes").child("IDG" + k).child("a_androidid").setValue(getandroidid());
    }


    public void setVibrationInDataBase(int k)
    {
        mDatenbank = FirebaseDatabase.getInstance().getReference();
        mDatenbank.child("overviewnodes").child("IDG" + k).child("a_androidid").setValue(getandroidid());
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            mDatenbank.child("overviewnodes").child("IDG" + k).child("b_localdatetime").setValue(LocalDateTime.now().toString());
        }
        mDatenbank.child("overviewnodes").child("IDG" + k).child("c_ip").setValue(getDeviceIpAdress());
        if (useOwnGPS)
        {
            mDatenbank.child("overviewnodes").child("IDG" + k).child("d_breitengrad").setValue(currentLocation.getLatitude());    //aktueller Breitengrad
            mDatenbank.child("overviewnodes").child("IDG" + k).child("e_laengengrad").setValue(currentLocation.getLongitude());   //aktueller Längergrad
        }else{
            mDatenbank.child("overviewnodes").child("IDG" + k).child("d_breitengrad").setValue(breitengrad);    //aktueller Breitengrad
            mDatenbank.child("overviewnodes").child("IDG" + k).child("e_laengengrad").setValue(laengengrad);   //aktueller Längergrad
        }
        mDatenbank.child("overviewnodes").child("IDG" + k).child("f_nativegps").setValue(false);
        mDatenbank.child("overviewnodes").child("IDG" + k).child("g_vibration").setValue(true);
        mDatenbank.child("overviewnodes").child("IDG" + k).child("h_timestamp").setValue(Calendar.getInstance().getTimeInMillis());     //aktueller Zeitstempel wird in Datenbank eingetragen
        mDatenbank.child("overviewnodes").child("IDG" + k).child("i_amplitude").setValue(1000);
    }

    public String getDeviceIpAdress ()
    {
        WifiManager wm = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
        int ip = wm.getConnectionInfo().getIpAddress();
        String ipAddress = String.format("%d.%d.%d.%d",(ip & 0xff),(ip >> 8 & 0xff),(ip >> 16 & 0xff), (ip >> 24 & 0xff));
        return ipAddress;
    }

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

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

    private float distance(double currentlatitude, double currentlongitude, double originLat, double originLon) {

        float[] results = new float[1];
        Location.distanceBetween(currentlatitude, currentlongitude, originLat, originLon, results);
        float distanceInMeters = results[0];

        return distanceInMeters;
    }

    //##################################################################  ^^^^ DB Code ^^^^  #############################################################################
    //#####################################################################################################################################################################

    //TODO @Patrick: Ist backupVonAltemCode noch relevanter Code wenn Viration und das Schreiben in die Datenbank passt und synchron abläuft? Falls nichts relevant, können wir das ja löschen ;)
    public void backupVonAltemCode (DataSnapshot data)
    {
        /*
        //####### Auslesen für boolean-Werte #######:
        int i = 1;
        String vibrationString = data.child("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;
    }
}