Merge branch 'test' of siebenhaarmi76624/MDT5_1_Ueberwachungssystem_G1 into ms

Initial commit Project Version 0
2023-05-11 13:39:00 +00:00 · 2023-05-11 15:38:14 +02:00
8 changed files with 1 additions and 430 deletions
@@ -36,13 +36,4 @@ dependencies {
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    // Required for CameraX
    def camerax_version = "1.2.2"
    implementation "androidx.camera:camera-core:${camerax_version}"
    implementation "androidx.camera:camera-camera2:${camerax_version}"
    implementation "androidx.camera:camera-lifecycle:${camerax_version}"
    implementation "androidx.camera:camera-video:${camerax_version}"
    implementation "androidx.camera:camera-view:${camerax_version}"
    implementation "androidx.camera:camera-extensions:${camerax_version}"
 }
@@ -2,13 +2,6 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <uses-feature android:name="android.hardware.camera"/>
    <uses-permission android:name="android.permission.CAMERA"/>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
@@ -1,36 +0,0 @@
 package com.example.ueberwachungssystem.Detection;
 import android.util.Log;
 import java.util.Calendar;
 /** Detection Report Class */
 public class DetectionReport {
    public String timeStamp;
    public String detectionType;
    public float detectedValue;
    public String detectorID;
    public DetectionReport(String detectorID, String detectionType, float detectedAmplitude) {
        this.timeStamp = String.valueOf(Calendar.getInstance().getTime());
        this.detectionType = detectionType;
        this.detectedValue = detectedAmplitude;
        this.detectorID = detectorID;
    }
    /** Get Detection Report in String format */
    public String toString() {
        String time = "Time: " + "[" + this.timeStamp + "]";
        String type = "Type: " + "[" + this.detectionType + "]";
        String value = "Value: " + "[" + this.detectedValue + "]";
        String id = "ID: " + "[" + this.detectorID + "]";
        return String.join("\t", time, type, value, id);
    }
    /** Debug Report */
    public void log(String tag) {
        Log.d(tag, this.toString());
    }
 }
@@ -1,38 +0,0 @@
 package com.example.ueberwachungssystem.Detection;
 import androidx.annotation.NonNull;
 abstract public class Detector {
    private OnDetectionListener listener;
    /** Constructor - takes context of current activity */
    public Detector() {}
    /** On Detection Listener - runs when violation is reported */
    public interface OnDetectionListener {
        void onDetection(@NonNull DetectionReport detectionReport);
    }
    public void setOnDetectionListener(@NonNull OnDetectionListener listener) {
        this.listener = listener;
    }
    /** Triggers onDetectionListener - call this to trigger violation/alarm */
    public void reportViolation(String detectorID, String detectionType, float amplitude) {
        if (listener != null) {
            DetectionReport detectionReport = new DetectionReport(detectorID, detectionType, amplitude);
            listener.onDetection(detectionReport);
        } else {
            throw new IllegalStateException("No listener set for violation reporting");
        }
    }
    /** Starts Detection (abstract method: needs to be overridden in child class) */
    public abstract void startDetection();
    /** Stops Detection (abstract method: needs to be overridden in child class) */
    public abstract void stopDetection();
 }
@@ -1,196 +0,0 @@
 package com.example.ueberwachungssystem.Detection;
 import android.content.Context;
 import android.graphics.ImageFormat;
 import android.media.Image;
 import android.util.Size;
 import androidx.annotation.NonNull;
 import androidx.camera.core.CameraSelector;
 import androidx.camera.core.ExperimentalGetImage;
 import androidx.camera.core.ImageAnalysis;
 import androidx.camera.core.Preview;
 import androidx.camera.lifecycle.ProcessCameraProvider;
 import androidx.camera.view.PreviewView;
 import androidx.core.content.ContextCompat;
 import androidx.lifecycle.LifecycleOwner;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.nio.ByteBuffer;
 import java.util.concurrent.ExecutionException;
 /**
 * Video Detector inherits some methods from abstract Detector class (more info there)
 *
 *
 * USE FROM MAIN ACTIVITY:
 *
 * VideoDetector vd = new VideoDetector(this);
 * vd.setPreview(previewView);  //THIS IS OPTIONAL!
 * vd.setOnDetectionListener(new Detector.OnDetectionListener{...});
 * vd.startDetection();
 * vd.stopDetection
 *
 * */
@ExperimentalGetImage
 public class VideoDetector extends Detector {
    // Calling Activity
    private final Context context;
    // Camera Provider
    private ProcessCameraProvider cameraProvider;
    private Boolean isDetectionRunning = false;
    // Preview Camera Image
    private PreviewView previewView = null;
    // Detect Violation
    private static final float PIXEL_THRESHOLD = 30f;  // Luminosity (brightness channel of YUV_420_888)
    private static final float ALARM_THRESHOLD = 0.2f;   // Percent of pixels changed
    private ByteBuffer previousBuffer = null;
    /**
     * Constructor
     * @param context: the context of calling activity (usually "this")
     * */
    public VideoDetector(Context context) {
        super();
        this.context = context;
    }
    /**
     *  Starts the Video Detection
     * */
    @Override
    public void startDetection() {
        if (isDetectionRunning)
            return;
        // Request Camera Provider
        final ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(context);
        //Check for Camera availability
        cameraProviderFuture.addListener(() -> {
            try {
                cameraProvider = cameraProviderFuture.get();
                bindAnalysis(cameraProvider);
                isDetectionRunning = true;
                previousBuffer = null;
            } catch (ExecutionException | InterruptedException e) {
                // No errors need to be handled for this Future. This should never be reached.
            }
        },ContextCompat.getMainExecutor(context));
    }
    /**
     * Stops the Video Detection
     * */
    @Override
    public void stopDetection() {
        if (!isDetectionRunning)
            return;
        cameraProvider.unbindAll();
        isDetectionRunning = false;
    }
    /**
     * Set PreviewView to show video feed while detecting
     * this is optional and does not need to be called
     * */
    public void setPreviewView(PreviewView previewView) {
        this.previewView = previewView;
    }
    /**
     * Binds the Luminosity Analyzer (configure and run Analysis)
     * @param cameraProvider: CameraProvider of Context passed by Constructor
     * */
    private void bindAnalysis(@NonNull ProcessCameraProvider cameraProvider) {
        // Configure and create Image Analysis
        ImageAnalysis.Builder builder = new ImageAnalysis.Builder();
        builder.setTargetResolution(new Size(640, 480));
        builder.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST);
        builder.setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888);
        ImageAnalysis imageAnalysis = builder.build();
        // Set Analyzer
        imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(context), imageProxy -> {
            if (imageProxy.getFormat() == ImageFormat.YUV_420_888) {
                Image image = imageProxy.getImage();
                assert image != null;
                // Changed Pixel Detection
                int pixelChanged = getChangedPixelCount(image);
                int width = image.getWidth();
                int height = image.getHeight();
                float percentPixelChanged = (float) 100f * pixelChanged / (width * height);
                if (percentPixelChanged > ALARM_THRESHOLD)
                    reportViolation("0", "Video", percentPixelChanged);
            }
            imageProxy.close();
        });
        // Create Preview
        Preview preview = new Preview.Builder().build();
        // Specify which Camera to use
        CameraSelector cameraSelector = new CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
        // Update PreviewView if set
        if (previewView != null)
            preview.setSurfaceProvider(previewView.getSurfaceProvider());
        cameraProvider.bindToLifecycle((LifecycleOwner) context, cameraSelector, imageAnalysis, preview);
    }
    /**
     * Calculate Amount of Pixels changed using a threshold
     * @param image
     * */
    private int getChangedPixelCount(Image image) {
        Image.Plane[] planes = image.getPlanes();
        ByteBuffer buffer = planes[0].getBuffer();
        if (previousBuffer == null) {
            previousBuffer = ByteBuffer.allocate(buffer.capacity());
            buffer.rewind();
            previousBuffer.put(buffer);
            previousBuffer.rewind();
            return 0;
        }
        int width = image.getWidth();
        int height = image.getHeight();
        int yRowStride = image.getPlanes()[0].getRowStride();
        int yPixelStride = image.getPlanes()[0].getPixelStride();
        int changedPixelCount = 0;
        // Count changed pixels
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; x++) {
                int index = (y * yRowStride) + (x * yPixelStride);
                int luminosity = (buffer.get(index) & 0xff);
                int previousLuminosity = (previousBuffer.get(index) & 0xff);
                int diff = Math.abs(luminosity - previousLuminosity);
                if (diff > PIXEL_THRESHOLD)
                    changedPixelCount++;
            }
        }
        // Reset and copy Byte Buffer
        buffer.rewind();
        previousBuffer.rewind();
        previousBuffer.put(buffer);
        return changedPixelCount;
    }
 }
@@ -6,22 +6,10 @@ import android.os.Bundle;
 public class MainActivity extends AppCompatActivity {
    WifiCommunication communication;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
-        }
+        //
    @Override
    protected void onResume() {
        super.onResume();
        communication = new WifiCommunication(MainActivity.this, 1234);
    }
    @Override
    protected void onPause() {
        super.onPause();
        communication.stopCommunication();
    }
 }
@@ -1,131 +0,0 @@
 package com.example.ueberwachungssystem;
 import android.annotation.SuppressLint;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.net.UnknownHostException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Enumeration;
 public class WifiCommunication {
    private final MainActivity mainActivity;
    private final InetAddress address;
    private final int port;
    private String messageToSend;
    volatile private boolean send;
    private final DatagramSocket socket;
    volatile private boolean running;
    @SuppressLint("SetTextI18n")
    public WifiCommunication(MainActivity mainActivity, int port) {
        this.mainActivity = mainActivity;
        this.port = port;
        try {
            socket = new DatagramSocket(this.port);
            socket.setBroadcast(true);
            address = InetAddress.getByName("255.255.255.255"); //100.82.255.255
            running = true;
            send = false;
            new ReceiveThread().start();
            new SendThread().start();
        } catch (SocketException | UnknownHostException e) {
            throw new RuntimeException(e);
        }
        //mainActivity.runOnUiThread(() -> mainActivity.tvMessages.setText("Communication running"));
    }
    private class ReceiveThread extends Thread {
        private StringBuffer rxStringBuffer = new StringBuffer();
        private String rxString="";
        private String previousRxString = "";
        @Override
        public void run() {
            try {
                do {
                    byte[] receiveData = new byte[512];
                    InetAddress fromAdress;
                    int fromPort;
                    DatagramPacket rxPacket = new DatagramPacket(receiveData, receiveData.length);
                    socket.receive(rxPacket);
                    fromAdress = rxPacket.getAddress();
                    fromPort = rxPacket.getPort();
                    rxString = new String(rxPacket.getData());
                    if(!previousRxString.equals(rxString)) {
                        rxStringBuffer.append(rxString).append("\n");
                        //mainActivity.runOnUiThread(() -> mainActivity.tvMessages.setText(rxStringBuffer));
                        previousRxString = rxString;
                    }
                } while (running);
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private class SendThread extends Thread {
        private int tmpCnt = 0;
        @Override
        public void run() {
            try {
                do {
                    if(send)
                    {
                        send = false;
                        SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
                        Date curDate = new Date(System.currentTimeMillis());
                        String str = formatter.format(curDate);
                        byte[] send_Data = new byte[512];
                        String txString = (str+ ",Gruppe2," + getLocalIpAddress() + ",An,Video," +messageToSend);
                        send_Data = txString.getBytes();
                        DatagramPacket txPacket = new DatagramPacket(send_Data, txString.length(), address, port);
                        for(int i = 0; i < 500; i++) {
                            socket.send(txPacket);
                            /*try{
                                sleep(10);
                            }catch (InterruptedException e){
                                e.printStackTrace();
                            }*/
                        }
                    }
                } while (running);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static String getLocalIpAddress() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
                NetworkInterface networkInterface = (NetworkInterface) ((Enumeration<?>) en).nextElement();
                for (Enumeration<InetAddress> addresses = networkInterface.getInetAddresses(); addresses.hasMoreElements();) {
                    InetAddress inetAddress = addresses.nextElement();
                    if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
                        return inetAddress.getHostAddress();
                    }
                }
            }
        } catch (SocketException ex) {
            ex.printStackTrace();
        }
        return null;
    }
    public void sendTrue(String message){
        send = true;
        messageToSend = message;
    }
    public void stopCommunication() {
        running = false;
        socket.close();
    }
 }
Author	SHA1	Message	Date
siebenhaarmi76624	35583a4cdd	Merge branch 'test' of siebenhaarmi76624/MDT5_1_Ueberwachungssystem_G1 into ms	2023-05-11 13:39:00 +00:00
siebenhaarmi76624	d22952d83b	Initial commit Project Version 0	2023-05-11 15:38:14 +02:00