MDT5_1_Ueberwachungssystem_G1/app/src/main/java/com/example/ueberwachungssystem/Detector/MicrophoneDetector.java

package com.example.ueberwachungssystem.Detector;

import static java.lang.Math.*;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.AsyncTask;
import android.util.Log;

import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import com.example.ueberwachungssystem.Detector.Signalverarbeitung.Complex;
import com.example.ueberwachungssystem.Detector.Signalverarbeitung.FFT;
import com.example.ueberwachungssystem.Detector.logger.Logger;
import com.jjoe64.graphview.GraphView;
import com.jjoe64.graphview.series.DataPoint;
import com.jjoe64.graphview.series.LineGraphSeries;

public class MicrophoneDetector extends Detector {
    /**
     * Constructor - takes context of current activity
     *
     * @param context
     */

    private static final int RECHTEANFORDERUNG_MIKROFON = 1;

    private AufnahmeTask aufnahmeTask;
    public boolean armed = false;
    public int Schwellwert_Alarm = 100;
    private Activity MainActivityForClass;

    public MicrophoneDetector(Context context) {
        super(context);
        MainActivityForClass = (Activity) context;

        if (!istZugriffAufMikrofonErlaubt()) {
            zugriffAufMikrofonAnfordern();
        }
    }

    @Override
    public void startDetection() {

        if (!istZugriffAufMikrofonErlaubt()) {
            zugriffAufMikrofonAnfordern();
        }
        if (istZugriffAufMikrofonErlaubt()) {
            aufnahmeTask = new AufnahmeTask();
            aufnahmeTask.execute();
        }
    }

    @Override
    public void stopDetection() {
        if (aufnahmeTask != null) {
            aufnahmeTask.cancel(true);
        }
    }

    private boolean istZugriffAufMikrofonErlaubt() {
        if (ContextCompat.checkSelfPermission(MainActivityForClass, android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
            Log.d("0","Zugriff auf Mikrofon ist verboten.");
            return false;
        } else {
            Log.d("0","Zugriff auf Mikrofon ist erlaubt.");
            return true;
        }
    }

    private void zugriffAufMikrofonAnfordern() {
        ActivityCompat.requestPermissions(MainActivityForClass, new String[]{Manifest.permission.RECORD_AUDIO}, RECHTEANFORDERUNG_MIKROFON);
    }

    class AufnahmeTask extends AsyncTask<Long, Verarbeitungsergebnis, Void> {
        private AudioRecord recorder;
        private final int sampleRateInHz = 44100;
        private final int channelConfig = AudioFormat.CHANNEL_IN_MONO;
        private final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
        private int minPufferGroesseInBytes;
        private int pufferGroesseInBytes;
        private RingPuffer ringPuffer = new RingPuffer(10);
        private float kalibierWert;
        private DetectionReport detectionReport;

        AufnahmeTask() {
            minPufferGroesseInBytes = AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat);
            pufferGroesseInBytes = minPufferGroesseInBytes * 2;
            if (ActivityCompat.checkSelfPermission(MainActivityForClass, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
                // TODO: Consider calling
                //    ActivityCompat#requestPermissions
                // here to request the missing permissions, and then overriding
                //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                //                                          int[] grantResults)
                // to handle the case where the user grants the permission. See the documentation
                // for ActivityCompat#requestPermissions for more details.
                ActivityCompat.requestPermissions(MainActivityForClass, new String[]{Manifest.permission.RECORD_AUDIO}, RECHTEANFORDERUNG_MIKROFON);
            }

            recorder = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleRateInHz, channelConfig, audioFormat, pufferGroesseInBytes);

            Log.d("0","Puffergroeße: "+ minPufferGroesseInBytes + " " + pufferGroesseInBytes);
            Log.d("0","Recorder (SR, CH): "+ recorder.getSampleRate() + " " + recorder.getChannelCount());

            int anzahlBytesProAbtastwert;
            String s;
            switch (recorder.getAudioFormat()) {
                case AudioFormat.ENCODING_PCM_8BIT:
                    s = "8 Bit PCM ";
                    anzahlBytesProAbtastwert = 1;
                    break;
                case AudioFormat.ENCODING_PCM_16BIT:
                    s = "16 Bit PCM";
                    anzahlBytesProAbtastwert = 2;
                    break;
                case AudioFormat.ENCODING_PCM_FLOAT:
                    s = "Float PCM";
                    anzahlBytesProAbtastwert = 4;
                    break;
                default:
                    throw new IllegalArgumentException();
            }

            switch (recorder.getChannelConfiguration()) {
                case AudioFormat.CHANNEL_IN_MONO:
                    s = "Mono";
                    break;
                case AudioFormat.CHANNEL_IN_STEREO:
                    s = "Stereo";
                    anzahlBytesProAbtastwert *= 2;
                    break;
                case AudioFormat.CHANNEL_INVALID:
                    s = "ungültig";
                    break;
                default:
                    throw new IllegalArgumentException();
            }

            Log.d("0","Konfiguration: "+ s);

            int pufferGroesseInAnzahlAbtastwerten = pufferGroesseInBytes / anzahlBytesProAbtastwert;
            int pufferGroesseInMillisekunden = 1000 * pufferGroesseInAnzahlAbtastwerten / recorder.getSampleRate();

        }

        @Override
        protected Void doInBackground(Long... params) {
            recorder.startRecording();
            short[] puffer = new short[pufferGroesseInBytes / 2];
            long lastTime = System.currentTimeMillis();
            float verarbeitungsrate = 0;
            final int maxZaehlerZeitMessung = 10;
            int zaehlerZeitMessung = 0;
            int anzahlVerarbeitet = 0;
            GleitenderMittelwert gleitenderMittelwert = new GleitenderMittelwert(0.3f);

            //Kalibrierung
            try {
                Thread.sleep(3000); // Time to lay down the phone
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 0;
            for (i = 0; i < 20; i++) {
                int n = recorder.read(puffer, 0, puffer.length);
                Verarbeitungsergebnis kalibrierErgebnis = verarbeiten(puffer, n);
                kalibierWert += kalibrierErgebnis.maxAmp;
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            kalibierWert = kalibierWert/i;

//            __Part of FFT__
//            Complex[] zeitSignal = new Complex[puffer.length];
//            for (int j = 0; j < puffer.length; j++) {
//                zeitSignal[j] = new Complex(puffer[j], 0);
//            }
//            Complex[] spektrum = FFT.fft(zeitSignal);
//            double[] spektrum = calculateFFT(puffer);
//            DataPoint AddPoint;
//            LineGraphSeries<DataPoint> series = new LineGraphSeries<DataPoint>(new DataPoint[]{});
//            for (i = 0; i < spektrum.length; i++) {
//                AddPoint = new DataPoint(i, spektrum[i]);
//                series.appendData(AddPoint, true, spektrum.length);
//            }
//            graph.addSeries(series);

            for (; ; ) {
                if (aufnahmeTask.isCancelled()) {
                    break;
                } else {
                    int n = recorder.read(puffer, 0, puffer.length);
                    Verarbeitungsergebnis ergebnis = verarbeiten(puffer, n);
                    anzahlVerarbeitet += n;
//                    __Part of FFT__
//                    spektrum = calculateFFT(puffer);
//                    LineGraphSeries<DataPoint> newseries = new LineGraphSeries<DataPoint>(new DataPoint[]{});
//                    for (i = 0; i < spektrum.length; i++) {
//                        AddPoint = new DataPoint(i, spektrum[i]);
//                        newseries.appendData(AddPoint, true, spektrum.length);
//                    }

                    zaehlerZeitMessung++;
                    if (zaehlerZeitMessung == maxZaehlerZeitMessung) {
                        long time = System.currentTimeMillis();
                        long deltaTime = time - lastTime;
                        verarbeitungsrate = 1000.0f * anzahlVerarbeitet / deltaTime;
                        verarbeitungsrate = gleitenderMittelwert.mittel(verarbeitungsrate);
                        zaehlerZeitMessung = 0;
                        anzahlVerarbeitet = 0;
                        lastTime = time;
                    }


                    ergebnis.verarbeitungsrate = (int) verarbeitungsrate;
                    publishProgress(ergebnis);

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            recorder.release();
            return null;
        }

        private Verarbeitungsergebnis verarbeiten(short[] daten, int n) {
            String status;
            short maxAmp = -1;
            if (n == AudioRecord.ERROR_INVALID_OPERATION) {
                status = "ERROR_INVALID_OPERATION";
            } else if (n == AudioRecord.ERROR_BAD_VALUE) {
                status = "ERROR_BAD_VALUE";
            } else {
                status = "OK";
                short max = 0;
                for (int i = 0; i < n; i++) {
                    if (daten[i] > max) {
                        max = daten[i];
                    }
                }

                ringPuffer.hinzufuegen(max);
                maxAmp = ringPuffer.maximum();
                if (maxAmp <= Schwellwert_Alarm+kalibierWert) {
                    armed = true;
                }
            }

            return new Verarbeitungsergebnis(status, maxAmp, 0);
        }

        @Override
        protected void onProgressUpdate(Verarbeitungsergebnis... progress) {
            super.onProgressUpdate(progress);
            float maxAmpPrint = round(20*log10(abs(progress[0].maxAmp/1.0)));
            float kalibierWertPrint = round(20*log10(abs(kalibierWert)));
            Log.d("0","VR, Max, Kal:" + progress[0].verarbeitungsrate + ", " + maxAmpPrint
            + " dB, " + kalibierWertPrint + " dB");

            if (progress[0].maxAmp >= Schwellwert_Alarm+kalibierWert && armed == true) {
                armed = false;
                detectionReport = new DetectionReport("Mic1", "Audio", maxAmpPrint);
                reportViolation("Mic1", "Audio", maxAmpPrint);
                Log.d("1",detectionReport.toString());
            }
        }
    }

    private double[] calculateFFT(short[] zeitsignal)
    {
        byte signal[] = new byte[zeitsignal.length];
        // loops through all the values of a Short
        for (int i = 0; i < zeitsignal.length-1; i++) {
            signal[i] = (byte) (zeitsignal[i]);
            signal[i+1] = (byte) (zeitsignal[i] >> 8);
        }

        final int mNumberOfFFTPoints =1024;
        double mMaxFFTSample;

        double temp;
        Complex[] y;
        Complex[] complexSignal = new Complex[mNumberOfFFTPoints];
        double[] absSignal = new double[mNumberOfFFTPoints/2];

        for(int i = 0; i < mNumberOfFFTPoints; i++){
            temp = (double)((signal[2*i] & 0xFF) | (signal[2*i+1] << 8)) / 32768.0F;
            complexSignal[i] = new Complex(temp,0.0);
        }

        y = FFT.fft(complexSignal);

        mMaxFFTSample = 0.0;
        for(int i = 0; i < (mNumberOfFFTPoints/2); i++)
        {
            absSignal[i] = y[i].abs();
//            absSignal[i] = Math.sqrt(Math.pow(y[i].re(), 2) + Math.pow(y[i].im(), 2));
//            if(absSignal[i] > mMaxFFTSample)
//            {
//                mMaxFFTSample = absSignal[i];
//            }
        }

        return absSignal;

    }

    class Verarbeitungsergebnis {
        String status;
        short maxAmp;
        int verarbeitungsrate;
        Verarbeitungsergebnis(String status, short maxAmp, int verarbeitungsrate) {
            this.status = status;
            this.maxAmp = maxAmp;
            this.verarbeitungsrate = verarbeitungsrate;
        }
    }

    class RingPuffer {
        private short[] puffer;
        private final int laenge;
        private int anzahlEnthaltenerDaten;
        private int position;

        public RingPuffer(int n) {
            laenge = n;
            anzahlEnthaltenerDaten = 0;
            position = 0;
            puffer = new short[laenge];
        }

        public void hinzufuegen(short wert) {
            puffer[position] = wert;
            position++;
            if (position >= laenge) {
                position = 0;
            }
            if (anzahlEnthaltenerDaten < laenge) {
                anzahlEnthaltenerDaten++;
            }
        }

        public void hinzufuegen(short[] daten) {
            for (short d : daten) {
                puffer[position] = d;
                position++;
                if (position >= laenge) {
                    position = 0;
                }
            }
            if (anzahlEnthaltenerDaten < laenge) {
                anzahlEnthaltenerDaten += daten.length;
                if (anzahlEnthaltenerDaten >= laenge) {
                    anzahlEnthaltenerDaten = laenge;
                }
            }
        }

        public short maximum() {
            short max = 0;
            for (int i = 0; i < anzahlEnthaltenerDaten; i++) {
                if (puffer[i] > max) {
                    max = puffer[i];
                }
            }
            return max;
        }

        public float mittelwert() {
            float summe = 0;
            for (int i = 0; i < anzahlEnthaltenerDaten; i++) {
                summe += puffer[i];
            }
            return summe / anzahlEnthaltenerDaten;
        }
    }

    class GleitenderMittelwert {
        private final float wichtungNeuerWert;
        private final float wichtungAlterWert;
        private float mittelwert = 0;
        private boolean istMittelwertGesetzt = false;

        GleitenderMittelwert(float wichtungNeuerWert) {
            this.wichtungNeuerWert = wichtungNeuerWert;
            this.wichtungAlterWert = 1 - this.wichtungNeuerWert;
        }

        float MittelwertPuffer(short[] puffer) {

            for (int i = 0; i < puffer.length; i++) {
                mittelwert = Math.abs(puffer[i]);
            }
            mittelwert = mittelwert/puffer.length;

            return mittelwert;
        }

        float mittel(float wert) {
            if (istMittelwertGesetzt) {
                mittelwert = wert * wichtungNeuerWert + mittelwert * wichtungAlterWert;
            } else {
                mittelwert = wert;
                istMittelwertGesetzt = true;
            }
            return mittelwert;
        }
    }
}