From 9e3652e275283a3db62843c187f7df30bb60ebe4 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:17:08 +0200 Subject: [PATCH 01/34] Added AudiodetectionActivity --- .../greenwatch/AudiodetectionActivity.java | 27 +++++++++++++++++++ .../res/layout/activity_audiodetection.xml | 25 +++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java create mode 100644 app/src/main/res/layout/activity_audiodetection.xml diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java new file mode 100644 index 0000000..06913c8 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -0,0 +1,27 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class AudiodetectionActivity extends AppCompatActivity { + + private Button backToMainActivityButton; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_audiodetection); + + backToMainActivityButton = (Button) findViewById(R.id.audiodetectorBackToMainActivity); + + backToMainActivityButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_audiodetection.xml b/app/src/main/res/layout/activity_audiodetection.xml new file mode 100644 index 0000000..12ffd4a --- /dev/null +++ b/app/src/main/res/layout/activity_audiodetection.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From 30f9c6c3f434f643c4c04da8f3d9287bfdff6309 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:17:42 +0200 Subject: [PATCH 02/34] Added VideodetectionActivity --- .../greenwatch/VideodetectionActivity.java | 27 +++++++++++++++++++ .../res/layout/activity_videodetection.xml | 25 +++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/VideodetectionActivity.java create mode 100644 app/src/main/res/layout/activity_videodetection.xml diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java new file mode 100644 index 0000000..2547bde --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -0,0 +1,27 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class VideodetectionActivity extends AppCompatActivity { + + private Button backToMainActivity; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_videodetection); + + backToMainActivity = (Button) findViewById(R.id.videodetectorBackToMainActivity); + + backToMainActivity.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_videodetection.xml b/app/src/main/res/layout/activity_videodetection.xml new file mode 100644 index 0000000..d68362e --- /dev/null +++ b/app/src/main/res/layout/activity_videodetection.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From bd2927ed648f066dd4d17445c4cc96983f4c5462 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:18:04 +0200 Subject: [PATCH 03/34] Added AccelerometerActivity --- .../greenwatch/AccelerometerActivity.java | 28 +++++++++++++++++++ .../res/layout/activity_accelerometer.xml | 25 +++++++++++++++++ 2 files changed, 53 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/AccelerometerActivity.java create mode 100644 app/src/main/res/layout/activity_accelerometer.xml diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java new file mode 100644 index 0000000..69ab8be --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -0,0 +1,28 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class AccelerometerActivity extends AppCompatActivity { + + private Button backToMainActivityButton; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_accelerometer); + + backToMainActivityButton = (Button) findViewById(R.id.accelerometerBackToMainActivity); + + backToMainActivityButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } + +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_accelerometer.xml b/app/src/main/res/layout/activity_accelerometer.xml new file mode 100644 index 0000000..21a94d1 --- /dev/null +++ b/app/src/main/res/layout/activity_accelerometer.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From 1c360e86040ee5d1c54f93bc3dca2582dae7e3a1 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:18:34 +0200 Subject: [PATCH 04/34] Added AudiodetectionAndAccelerometerActivity --- ...udiodetectionAndAccelerometerActivity.java | 27 +++++++++++++++++++ ...ivity_audiodetection_and_accelerometer.xml | 25 +++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java create mode 100644 app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java new file mode 100644 index 0000000..b05e773 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -0,0 +1,27 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity { + + private Button backToMainActivity; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_audiodetection_and_accelerometer); + + backToMainActivity = (Button) findViewById(R.id.audiodetectionAndAccelerometerBackToMainActivity); + + backToMainActivity.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml b/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml new file mode 100644 index 0000000..b6f4599 --- /dev/null +++ b/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From 595d97ef57cd2814c770d6095b0953669ccab3c9 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:19:16 +0200 Subject: [PATCH 05/34] Added VideodetectionAndAccelerometerActivity --- ...ideodetectionAndAccelerometerActivity.java | 27 +++++++++++++++++++ ...ivity_videodetection_and_accelerometer.xml | 25 +++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java create mode 100644 app/src/main/res/layout/activity_videodetection_and_accelerometer.xml diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java new file mode 100644 index 0000000..cd88c99 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -0,0 +1,27 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class VideodetectionAndAccelerometerActivity extends AppCompatActivity { + + private Button backToMainActivity; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_videodetection_and_accelerometer); + + backToMainActivity = (Button) findViewById(R.id.videodetectionAndAccelerometerBackToMainActivity); + + backToMainActivity.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml b/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml new file mode 100644 index 0000000..a4ee20d --- /dev/null +++ b/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From d38e05a4b6097d14b37516b538345df75dceb88f Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:19:39 +0200 Subject: [PATCH 06/34] Added ConnectionActivity --- .../greenwatch/ConnectionActivity.java | 27 +++++++++++++++++++ .../main/res/layout/activity_connection.xml | 25 +++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/ConnectionActivity.java create mode 100644 app/src/main/res/layout/activity_connection.xml diff --git a/app/src/main/java/com/example/greenwatch/ConnectionActivity.java b/app/src/main/java/com/example/greenwatch/ConnectionActivity.java new file mode 100644 index 0000000..ca2cb28 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/ConnectionActivity.java @@ -0,0 +1,27 @@ +package com.example.greenwatch; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; +import android.view.View; +import android.widget.Button; + +public class ConnectionActivity extends AppCompatActivity { + + private Button backToMainActivity; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_connection); + + backToMainActivity = (Button) findViewById(R.id.connectionBackToMainActivity); + + backToMainActivity.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + finish(); + } + }); + } +} \ No newline at end of file diff --git a/app/src/main/res/layout/activity_connection.xml b/app/src/main/res/layout/activity_connection.xml new file mode 100644 index 0000000..15bd57d --- /dev/null +++ b/app/src/main/res/layout/activity_connection.xml @@ -0,0 +1,25 @@ + + + + + + + + + \ No newline at end of file -- 2.47.2 From 9f253b655c3dc08797fd6520ddb3ac370f244bcd Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:23:58 +0200 Subject: [PATCH 07/34] Added Activities to MainActivity and made them accessible --- app/src/main/AndroidManifest.xml | 18 +++++ .../com/example/greenwatch/MainActivity.java | 78 +++++++++++++++++++ app/src/main/res/layout/activity_main.xml | 73 +++++++++++++++-- 3 files changed, 161 insertions(+), 8 deletions(-) diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index e6408bb..467cede 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -9,6 +9,24 @@ android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/Theme.GreenWatch"> + + + + + + diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 98aa213..66cca92 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -2,13 +2,91 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import android.content.Intent; import android.os.Bundle; +import android.view.View; +import android.widget.Button; public class MainActivity extends AppCompatActivity { + private Button audiodetectionButton; + private Button videodetectionButton; + private Button accelerometerButton; + private Button audiodetectionAndAccelerometerButton; + private Button videodetectionAndAccelerometerButton; + private Button connectionButton; + @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); + + audiodetectionButton = (Button) findViewById(R.id.audiodetectionButton); + videodetectionButton = (Button) findViewById(R.id.videodetectionButton); + accelerometerButton = (Button) findViewById(R.id.accelerometerButton); + audiodetectionAndAccelerometerButton = (Button) findViewById(R.id.audiodetectionAndAccelerometerButton); + videodetectionAndAccelerometerButton = (Button) findViewById(R.id.videodetectionAndAccelerometerButton); + connectionButton = (Button) findViewById(R.id.connectionButton); + audiodetectionButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openAudiodetectionActivity(); + } + }); + videodetectionButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openVideodetectionActivity(); + } + }); + accelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openAccelerometerActivity(); + } + }); + audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openAudiodetectionAndAccelerometerActivity(); + } + }); + videodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openVideodetectionAndAccelerometerActivity(); + } + }); + connectionButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openConnectionActivity(); + } + }); } + public void openAudiodetectionActivity(){ + Intent intent = new Intent(this, AudiodetectionActivity.class); + startActivity(intent); + } + public void openVideodetectionActivity(){ + Intent intent = new Intent(this, VideodetectionActivity.class); + startActivity(intent); + } + public void openAccelerometerActivity(){ + Intent intent = new Intent(this, AccelerometerActivity.class); + startActivity(intent); + } + public void openAudiodetectionAndAccelerometerActivity(){ + Intent intent = new Intent(this, AudiodetectionAndAccelerometerActivity.class); + startActivity(intent); + } + public void openVideodetectionAndAccelerometerActivity(){ + Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); + startActivity(intent); + } + public void openConnectionActivity(){ + Intent intent = new Intent(this, ConnectionActivity.class); + startActivity(intent); + } + } \ No newline at end of file diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml index 4fc2444..ac1cba0 100644 --- a/app/src/main/res/layout/activity_main.xml +++ b/app/src/main/res/layout/activity_main.xml @@ -1,18 +1,75 @@ - + android:layout_weight="1"> + + + - \ No newline at end of file + + + + + + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 559a95b1c27b1baf4945b3f55aa0b077c755a3db Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 25 May 2023 11:26:02 +0200 Subject: [PATCH 08/34] Added fundamentals of the Model View Controler Structure of the device handling --- .../com/example/greenwatch/mvc/Device.java | 29 ++++++++++++ .../greenwatch/mvc/DeviceController.java | 33 +++++++++++++ .../example/greenwatch/mvc/DeviceModel.java | 47 +++++++++++++++++++ .../example/greenwatch/mvc/DeviceView.java | 10 ++++ 4 files changed, 119 insertions(+) create mode 100644 app/src/main/java/com/example/greenwatch/mvc/Device.java create mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceController.java create mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java create mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceView.java diff --git a/app/src/main/java/com/example/greenwatch/mvc/Device.java b/app/src/main/java/com/example/greenwatch/mvc/Device.java new file mode 100644 index 0000000..60bd3d0 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/mvc/Device.java @@ -0,0 +1,29 @@ +package com.example.greenwatch.mvc; + + +public class Device { + + private String sensor; + private Boolean isActive; + + public Device(String Sensor, Boolean Status) { + this.sensor = Sensor; + this.isActive = Status; + } + + public void setSensor(String Sensor) { + this.sensor = Sensor; + } + + public String getSensor() { + return sensor; + } + + public void setIsActive(Boolean Status) { + this.isActive = Status; + } + + public Boolean getIsActive() { + return isActive; + } +} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java new file mode 100644 index 0000000..aa7a9ea --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java @@ -0,0 +1,33 @@ +package com.example.greenwatch.mvc; + +public class DeviceController { + + private DeviceModel deviceModel; + private DeviceView deviceView; + + public DeviceController(DeviceView view) { + this.deviceModel = DeviceModel.getInstance(); + this.deviceView = view; + } + + public void createDevice(String Sensor, Boolean Status) { + Device device = new Device(Sensor, Status); + deviceModel.addDevice(device); + // todo: Inform view and sender about changes + } + public void setDeviceSensor(String UUID, String Sensor) { + deviceModel.setDeviceSensor(UUID, Sensor); + } + + public String getDeviceSensor(String UUID) { + return deviceModel.getDeviceSensor(UUID); + } + + public void setDeviceStatus(String UUID, Boolean Status) { + deviceModel.setDeviceStatus(UUID, Status); + } + + public Boolean getDeviceStatus(String UUID) { + return deviceModel.getDeviceStatus(UUID); + } +} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java new file mode 100644 index 0000000..be40f7f --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java @@ -0,0 +1,47 @@ +package com.example.greenwatch.mvc; + +import java.util.Vector; + +public class DeviceModel { + private static DeviceModel itemModelInstance; + // todo: should be a hashmap with UUID Keys + private Vector connectetDevicesList; + + private DeviceModel() { + connectetDevicesList = new Vector(); + } + + public static synchronized DeviceModel getInstance() { + if (itemModelInstance == null){ + itemModelInstance = new DeviceModel(); + } + return itemModelInstance; + } + + public void addDevice(Device device) { + // todo: Check if divece already exist + connectetDevicesList.add(device); + } + + public Vector getConnectetDevicesList() { + return connectetDevicesList; + } + + public void setDeviceSensor(String UUID, String Sensor) { + // todo: iterate through HashMap and find Divece for UUID + } + + public String getDeviceSensor(String UUID) { + // todo: iterate through HashMap and find Divece for UUID + return "hasToBeDone"; + } + + public void setDeviceStatus(String UUID, Boolean Status) { + // todo: iterate through HashMap and find Divece for UUID + } + + public Boolean getDeviceStatus(String UUID) { + // todo: iterate through HashMap and find Divece for UUID + return false; + } +} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java new file mode 100644 index 0000000..55e62a9 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java @@ -0,0 +1,10 @@ +package com.example.greenwatch.mvc; + +import java.util.Vector; + +public class DeviceView { + + public void updateView(Vector deviceVector) { + // todo: what should be displayed + } +} -- 2.47.2 From 28c98ba76625687aab025234f7fab0bb94ffd042 Mon Sep 17 00:00:00 2001 From: Christian Date: Sat, 10 Jun 2023 19:44:58 +0200 Subject: [PATCH 09/34] Added fundamentals of the Model View ViewModel Structure of the device data handling --- .../com/example/greenwatch/models/Device.java | 57 +++++ .../com/example/greenwatch/mvc/Device.java | 29 --- .../greenwatch/mvc/DeviceController.java | 33 --- .../example/greenwatch/mvc/DeviceModel.java | 47 ---- .../example/greenwatch/mvc/DeviceView.java | 10 - .../repositories/DeviceRepository.java | 216 ++++++++++++++++++ .../viewmodels/MainActivityViewModel.java | 78 +++++++ 7 files changed, 351 insertions(+), 119 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/models/Device.java delete mode 100644 app/src/main/java/com/example/greenwatch/mvc/Device.java delete mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceController.java delete mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java delete mode 100644 app/src/main/java/com/example/greenwatch/mvc/DeviceView.java create mode 100644 app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java diff --git a/app/src/main/java/com/example/greenwatch/models/Device.java b/app/src/main/java/com/example/greenwatch/models/Device.java new file mode 100644 index 0000000..d9155e9 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/models/Device.java @@ -0,0 +1,57 @@ +package com.example.greenwatch.models; + + +public class Device { + + private String timeStamp; + private String deviceID; + private boolean sensorStatus; + private String sensorType; + private int sensorMassage; + + public Device(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage) { + this.timeStamp = timeStamp; + this.deviceID = deviceID; + this.sensorStatus = sensorStatus; + this.sensorType = sensorType; + this.sensorMassage = sensorMassage; + } + public void setTimeStamp(String timeStamp) { + this.timeStamp = timeStamp; + } + + public String getTimeStamp() { + return timeStamp; + } + + public void setDeviceID(String deviceID) { + this.deviceID = deviceID; + } + + public String getDeviceID() { + return deviceID; + } + public void setSensorType(String sensorType) { + this.sensorType = sensorType; + } + + public String getSensorType() { + return sensorType; + } + + public void setSensorStatus(boolean sensorStatus) { + this.sensorStatus = sensorStatus; + } + + public Boolean getSensorStatus() { + return sensorStatus; + } + + public void setSensorMassage(int sensorMassage) { + this.sensorMassage = sensorMassage; + } + + public int getSensorMassage() { + return sensorMassage; + } +} diff --git a/app/src/main/java/com/example/greenwatch/mvc/Device.java b/app/src/main/java/com/example/greenwatch/mvc/Device.java deleted file mode 100644 index 60bd3d0..0000000 --- a/app/src/main/java/com/example/greenwatch/mvc/Device.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.example.greenwatch.mvc; - - -public class Device { - - private String sensor; - private Boolean isActive; - - public Device(String Sensor, Boolean Status) { - this.sensor = Sensor; - this.isActive = Status; - } - - public void setSensor(String Sensor) { - this.sensor = Sensor; - } - - public String getSensor() { - return sensor; - } - - public void setIsActive(Boolean Status) { - this.isActive = Status; - } - - public Boolean getIsActive() { - return isActive; - } -} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java deleted file mode 100644 index aa7a9ea..0000000 --- a/app/src/main/java/com/example/greenwatch/mvc/DeviceController.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.example.greenwatch.mvc; - -public class DeviceController { - - private DeviceModel deviceModel; - private DeviceView deviceView; - - public DeviceController(DeviceView view) { - this.deviceModel = DeviceModel.getInstance(); - this.deviceView = view; - } - - public void createDevice(String Sensor, Boolean Status) { - Device device = new Device(Sensor, Status); - deviceModel.addDevice(device); - // todo: Inform view and sender about changes - } - public void setDeviceSensor(String UUID, String Sensor) { - deviceModel.setDeviceSensor(UUID, Sensor); - } - - public String getDeviceSensor(String UUID) { - return deviceModel.getDeviceSensor(UUID); - } - - public void setDeviceStatus(String UUID, Boolean Status) { - deviceModel.setDeviceStatus(UUID, Status); - } - - public Boolean getDeviceStatus(String UUID) { - return deviceModel.getDeviceStatus(UUID); - } -} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java deleted file mode 100644 index be40f7f..0000000 --- a/app/src/main/java/com/example/greenwatch/mvc/DeviceModel.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.example.greenwatch.mvc; - -import java.util.Vector; - -public class DeviceModel { - private static DeviceModel itemModelInstance; - // todo: should be a hashmap with UUID Keys - private Vector connectetDevicesList; - - private DeviceModel() { - connectetDevicesList = new Vector(); - } - - public static synchronized DeviceModel getInstance() { - if (itemModelInstance == null){ - itemModelInstance = new DeviceModel(); - } - return itemModelInstance; - } - - public void addDevice(Device device) { - // todo: Check if divece already exist - connectetDevicesList.add(device); - } - - public Vector getConnectetDevicesList() { - return connectetDevicesList; - } - - public void setDeviceSensor(String UUID, String Sensor) { - // todo: iterate through HashMap and find Divece for UUID - } - - public String getDeviceSensor(String UUID) { - // todo: iterate through HashMap and find Divece for UUID - return "hasToBeDone"; - } - - public void setDeviceStatus(String UUID, Boolean Status) { - // todo: iterate through HashMap and find Divece for UUID - } - - public Boolean getDeviceStatus(String UUID) { - // todo: iterate through HashMap and find Divece for UUID - return false; - } -} diff --git a/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java b/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java deleted file mode 100644 index 55e62a9..0000000 --- a/app/src/main/java/com/example/greenwatch/mvc/DeviceView.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.example.greenwatch.mvc; - -import java.util.Vector; - -public class DeviceView { - - public void updateView(Vector deviceVector) { - // todo: what should be displayed - } -} diff --git a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java new file mode 100644 index 0000000..31f3ee0 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -0,0 +1,216 @@ +package com.example.greenwatch.repositories; + + +import androidx.lifecycle.MutableLiveData; + +import com.example.greenwatch.models.Device; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.UUID; + +public class DeviceRepository { + + private String delimiter = ", "; + private String deviceUUID; + private static DeviceRepository deviceRepositoryInstance; + private MutableLiveData> deviceList = new MutableLiveData<>(); + private HashMap connectedDevicesList = new HashMap<>(); + private HashMap deviceIDMapper = new HashMap<>(); + + public static synchronized DeviceRepository getInstance() { + if (deviceRepositoryInstance == null){ + deviceRepositoryInstance = new DeviceRepository(); + deviceRepositoryInstance.setDeviceUUID(); + } + return deviceRepositoryInstance; + } + + public MutableLiveData> getConnectedDeviceList() { + setMutableLiveDataValue(); + return deviceList; + } + + public void createNewDevice(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage){ + Device newDevice = new Device(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); + addToConnectedDeviceList(newDevice.getDeviceID(), newDevice); + setMutableLiveDataValue(); + } + + public void createNewRemoteDevice(String message) { + String[] messageString = messageStringSplitter(message); + String timeStamp = messageString[0]; + String deviceID = messageString[1]; + boolean sensorStatus = Boolean.valueOf(messageString[1]); + String sensorType = messageString[3]; + int sensorMassage = Integer.valueOf(messageString[4]); + + if(!connectedDevicesList.containsKey(deviceID)) { + createNewDevice(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); + } + } + + public String messageStringBuilder(String deviceID) { + StringBuilder message = new StringBuilder(); + Device device = connectedDevicesList.get(deviceID); + if(device != null) { + message.append(device.getTimeStamp()) + .append(delimiter) + .append(device.getDeviceID()) + .append(delimiter) + .append(device.getSensorStatus()) + .append(delimiter) + .append(device.getSensorType()) + .append(delimiter) + .append(device.getSensorMassage()); + return message.toString(); + } + return message.toString(); + } + + public String getLocalDeviceUUID() { + return deviceUUID; + } + + public void setDevice(String deviceID, String timeStamp, String newDeviceID, boolean sensorStatus, String sensorType, int sensorMassage) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setTimeStamp(timeStamp); + device.setDeviceID(newDeviceID); + device.setSensorStatus(sensorStatus); + device.setSensorType(sensorType); + device.setSensorMassage(sensorMassage); + setDeviceIDMapper(newDeviceID); + connectedDevicesList.remove(checkedDeviceID); + addToConnectedDeviceList(newDeviceID, device); + setMutableLiveDataValue(); + } + } + + public void setTimeStamp(String deviceID, String timeStamp) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setTimeStamp(timeStamp); + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataValue(); + } + } + + public String getTimeStamp(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getTimeStamp(); + } + return ""; + } + + public void setDeviceID(String deviceID, String newDeviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setDeviceID(newDeviceID); + setDeviceIDMapper(newDeviceID); + connectedDevicesList.remove(checkedDeviceID); + addToConnectedDeviceList(newDeviceID, device); + setMutableLiveDataValue(); + } + } + + public String getDeviceID(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getDeviceID(); + } + return ""; + } + + public void setSensorStatus(String deviceID, boolean sensorStatus) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setSensorStatus(sensorStatus); + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataValue(); + } + } + + public boolean getSensorStatus(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getSensorStatus(); + } + return false; + } + + public void setSensorType(String deviceID, String sensorType) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setSensorType(sensorType); + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataValue(); + } + } + + public String getSensorType(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getSensorType(); + } + return ""; + } + + public void setSensorMassage(String deviceID, int sensorMessage) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setSensorMassage(sensorMessage); + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataValue(); + } + } + + public int getSensorMassage(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getSensorMassage(); + } + return 0; + } + + private void setMutableLiveDataValue() { + List list = new ArrayList<>(connectedDevicesList.values()); + deviceList.setValue(list); + } + + private void addToConnectedDeviceList(String key, Device device) { + connectedDevicesList.put(key, device); + } + + private String checkDeviceID(String deviceID) { + if(!deviceIDMapper.isEmpty() && deviceID.equals(deviceUUID)) { + return deviceIDMapper.get(deviceID); + } + return deviceID; + } + + private void setDeviceIDMapper(String deviceID) { + deviceIDMapper.put(deviceUUID, deviceID); + } + + private void setDeviceUUID(){ + this.deviceUUID = UUID.randomUUID().toString(); + } + + private String[] messageStringSplitter(String message) { + return message.split(delimiter); + } +} diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java new file mode 100644 index 0000000..8da05ef --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -0,0 +1,78 @@ +package com.example.greenwatch.viewmodels; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; + +import java.util.List; + +public class MainActivityViewModel extends ViewModel { + + private MutableLiveData> mDeviceList; + private MutableLiveData mLocalDevice; + private DeviceRepository mDeviceRepository; + + public void init() { + if(mDeviceList != null) { + return; + } + mDeviceRepository = DeviceRepository.getInstance(); + mDeviceRepository.createNewDevice("", mDeviceRepository.getLocalDeviceUUID(), false, "", 0); + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + public void setDevice(String deviceID, String timeStamp, String newDeviceID, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.setDevice(deviceID, timeStamp,newDeviceID, sensorStatus, sensorType, sensorMassage); + } + + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } +} -- 2.47.2 From 373ca2d1067bff2605a77d9d011ad5cbb51ab069 Mon Sep 17 00:00:00 2001 From: Christian Date: Sat, 10 Jun 2023 19:46:12 +0200 Subject: [PATCH 10/34] Added test implementation of data handling and ID mapper --- .../com/example/greenwatch/MainActivity.java | 55 +++++++++++++++++-- 1 file changed, 51 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 66cca92..1778dc4 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -1,54 +1,101 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.MainActivityViewModel; + +import java.util.List; public class MainActivity extends AppCompatActivity { + private TextView tvstatusmessage; private Button audiodetectionButton; private Button videodetectionButton; private Button accelerometerButton; private Button audiodetectionAndAccelerometerButton; private Button videodetectionAndAccelerometerButton; private Button connectionButton; + private MainActivityViewModel mMainActivityViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); + tvstatusmessage = (TextView) findViewById(R.id.tvStatusmessage); audiodetectionButton = (Button) findViewById(R.id.audiodetectionButton); videodetectionButton = (Button) findViewById(R.id.videodetectionButton); accelerometerButton = (Button) findViewById(R.id.accelerometerButton); audiodetectionAndAccelerometerButton = (Button) findViewById(R.id.audiodetectionAndAccelerometerButton); videodetectionAndAccelerometerButton = (Button) findViewById(R.id.videodetectionAndAccelerometerButton); connectionButton = (Button) findViewById(R.id.connectionButton); + + mMainActivityViewModel = new ViewModelProvider(this).get(MainActivityViewModel.class); + mMainActivityViewModel.init(); + mMainActivityViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + StringBuilder sb = new StringBuilder(); + sb.append("Time Stamp: "); + sb.append(mMainActivityViewModel.getTimeStamp(mMainActivityViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("DeviceID: "); + sb.append(mMainActivityViewModel.getDeviceID(mMainActivityViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Status: "); + sb.append(mMainActivityViewModel.getSensorStatus(mMainActivityViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Type: "); + sb.append(mMainActivityViewModel.getSensorType(mMainActivityViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Massage: "); + sb.append(mMainActivityViewModel.getSensorMassage(mMainActivityViewModel.getLocalDeviceUUID())); + tvstatusmessage.setText(sb); + Toast.makeText(MainActivity.this, "onChanged", Toast.LENGTH_LONG).show(); + } + }); + audiodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - openAudiodetectionActivity(); + //openAudiodetectionActivity(); + mMainActivityViewModel.setDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", "12345", false, "Audio", 10); } }); videodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - openVideodetectionActivity(); + //openVideodetectionActivity(); + mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "Video"); + mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "12:50"); + mMainActivityViewModel.setDeviceID(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getLocalDeviceUUID()); } }); accelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - openAccelerometerActivity(); + //openAccelerometerActivity(); + mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "Accelerometer"); + mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "24:00"); } }); audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - openAudiodetectionAndAccelerometerActivity(); + //openAudiodetectionAndAccelerometerActivity(); + mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "AudiodetectionAndAccelerometer"); + mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "00:00"); + mMainActivityViewModel.setDeviceID(mMainActivityViewModel.getLocalDeviceUUID(), "6789"); } }); videodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { -- 2.47.2 From ccdff78a4a31c5bea14b6c4ae3da5b863dbe9431 Mon Sep 17 00:00:00 2001 From: Christian Date: Sun, 11 Jun 2023 23:41:10 +0200 Subject: [PATCH 11/34] Added Accelerometer to Project --- .../greenwatch/AccelerometerActivity.java | 111 +++++++++++++- .../com/example/greenwatch/MainActivity.java | 3 +- .../viewmodels/AccelerometerViewModel.java | 143 ++++++++++++++++++ .../viewmodels/MainActivityViewModel.java | 1 - .../res/layout/activity_accelerometer.xml | 16 +- 5 files changed, 269 insertions(+), 5 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index 69ab8be..27f4e0d 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -1,20 +1,42 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; -public class AccelerometerActivity extends AppCompatActivity { +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.AccelerometerViewModel; +import java.util.List; + +public class AccelerometerActivity extends AppCompatActivity implements SensorEventListener { + + private SensorManager accelerometerManager; + private Sensor accelerometerSensor; + private TextView accelerometerStatusMessage; + private TextView accelerometerDataTV; + private TextView accelerometerWarningTV; private Button backToMainActivityButton; + private AccelerometerViewModel mAccelerometerViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_accelerometer); + accelerometerStatusMessage = (TextView) findViewById(R.id.tvAccelerometerStatusmessage); + accelerometerDataTV = (TextView) findViewById(R.id.tvAccelerometerData); + accelerometerWarningTV = (TextView) findViewById(R.id.tvAccelerometerWarning); backToMainActivityButton = (Button) findViewById(R.id.accelerometerBackToMainActivity); backToMainActivityButton.setOnClickListener(new View.OnClickListener() { @@ -23,6 +45,93 @@ public class AccelerometerActivity extends AppCompatActivity { finish(); } }); + + mAccelerometerViewModel = new ViewModelProvider(this).get(AccelerometerViewModel.class); + mAccelerometerViewModel.init(); + mAccelerometerViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + StringBuilder sb = new StringBuilder(); + sb.append("Time Stamp: "); + sb.append(mAccelerometerViewModel.getTimeStamp(mAccelerometerViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("DeviceID: "); + sb.append(mAccelerometerViewModel.getDeviceID(mAccelerometerViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Status: "); + sb.append(mAccelerometerViewModel.getSensorStatus(mAccelerometerViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Type: "); + sb.append(mAccelerometerViewModel.getSensorType(mAccelerometerViewModel.getLocalDeviceUUID())); + sb.append(";\n"); + sb.append("Sensor Massage: "); + sb.append(mAccelerometerViewModel.getSensorMassage(mAccelerometerViewModel.getLocalDeviceUUID())); + accelerometerStatusMessage.setText(sb); + Toast.makeText(AccelerometerActivity.this, "onChanged", Toast.LENGTH_LONG).show(); + } + }); + + mAccelerometerViewModel.getMovementDetectedValue().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mAccelerometerViewModel.setDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), mAccelerometerViewModel.getLocalDeviceUUID(), true, "Accelerometer", 10); + } + else { + mAccelerometerViewModel.setDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), mAccelerometerViewModel.getLocalDeviceUUID(), false, "Accelerometer", 0); + } + + } + }); + + accelerometerManager = (SensorManager) getSystemService(SENSOR_SERVICE); + if (accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).size() == 0) { + accelerometerSensor = null; + Toast.makeText(AccelerometerActivity.this, "No accelerometer sensor available", Toast.LENGTH_LONG).show(); + } + else { + accelerometerSensor = accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).get(0); + } } + @Override + public void onSensorChanged(SensorEvent event) { + StringBuilder sb = new StringBuilder(); + sb.append("x=") + .append(event.values[0]) + .append("\ny=") + .append(event.values[1]) + .append("\nz=") + .append(event.values[2]); + accelerometerDataTV.setText(sb.toString()); + mAccelerometerViewModel.addValueToGesamtBE(event.values[0] + event.values[1] + event.values[2]); + mAccelerometerViewModel.meanValueCalculation(); + mAccelerometerViewModel.calibrateAccelerometerSensor(); + mAccelerometerViewModel.checkAlarmCondition(); + + } + + @Override + public void onAccuracyChanged(Sensor sensor, int accuracy) { + } + + @Override + protected void onResume() { + super.onResume(); + if (accelerometerSensor != null) { + if (accelerometerManager.registerListener(this, accelerometerSensor, SensorManager.SENSOR_DELAY_GAME)) { + Toast.makeText(AccelerometerActivity.this, "We registered to the sensor", Toast.LENGTH_LONG).show(); + } else { + Toast.makeText(AccelerometerActivity.this, "Registration did not work", Toast.LENGTH_LONG).show(); + } + } + } + + @Override + protected void onPause() { + super.onPause(); + if (accelerometerSensor != null) { + accelerometerManager.unregisterListener(this, accelerometerSensor); + } + } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 1778dc4..3f6a220 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -84,9 +84,8 @@ public class MainActivity extends AppCompatActivity { accelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - //openAccelerometerActivity(); + openAccelerometerActivity(); mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "Accelerometer"); - mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "24:00"); } }); audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java new file mode 100644 index 0000000..9c2f860 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -0,0 +1,143 @@ +package com.example.greenwatch.viewmodels; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +public class AccelerometerViewModel extends ViewModel { + + private MutableLiveData> mDeviceList; + private MutableLiveData mMovementDetected = new MutableLiveData<>(); + private DeviceRepository mDeviceRepository; + private ArrayList Gesamt_be; + int arraySize = 500; + int functionCallCount; + float meanValue; + float offsetValue; + float thresholdValue; + boolean startMeasuring; + + public void init() { + if (mDeviceList == null) { + mDeviceRepository = DeviceRepository.getInstance(); + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + initGesamtBE(); + mMovementDetected.setValue(false); + functionCallCount = 0; + meanValue = 0f; + offsetValue = 0.1f; + thresholdValue = 0.15f; + startMeasuring = false; + } + + public void initGesamtBE() { + Gesamt_be = new ArrayList<>(arraySize); + for (int i = 0; i < arraySize; i++) { + Gesamt_be.add(0f); + } + } + + public void addValueToGesamtBE(float newValue) { + if (Gesamt_be.size() == arraySize) { + Gesamt_be.remove(Gesamt_be.size() -1); + } + Gesamt_be.add(0, newValue); + functionCallCount++; + } + + public void meanValueCalculation() { + for (float element : Gesamt_be) { + meanValue += Math.abs(element); + } + meanValue = meanValue/arraySize; + } + + public void calibrateAccelerometerSensor() { + if (functionCallCount <= arraySize) { + offsetValue = meanValue; + } + else { + startMeasuring = true; + } + } + + public void checkAlarmCondition() { + if (meanValue > (thresholdValue + offsetValue) && startMeasuring && !mMovementDetected.getValue()) { + mMovementDetected.setValue(true); + } + else if (meanValue < (thresholdValue + offsetValue) && mMovementDetected.getValue()){ + mMovementDetected.setValue(false); + } + } + + public String getSystemTimeStamp() { + SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss"); + Date date = new Date(System.currentTimeMillis()); + return formatter.format(date); + } + + public LiveData getMovementDetectedValue() { + return mMovementDetected; + } + + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + public void setDevice(String deviceID, String timeStamp, String newDeviceID, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.setDevice(deviceID, timeStamp,newDeviceID, sensorStatus, sensorType, sensorMassage); + } + + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } +} diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index 8da05ef..9a4f555 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -12,7 +12,6 @@ import java.util.List; public class MainActivityViewModel extends ViewModel { private MutableLiveData> mDeviceList; - private MutableLiveData mLocalDevice; private DeviceRepository mDeviceRepository; public void init() { diff --git a/app/src/main/res/layout/activity_accelerometer.xml b/app/src/main/res/layout/activity_accelerometer.xml index 21a94d1..9f929a4 100644 --- a/app/src/main/res/layout/activity_accelerometer.xml +++ b/app/src/main/res/layout/activity_accelerometer.xml @@ -12,7 +12,21 @@ android:id="@+id/tvAccelerometerStatusmessage" android:layout_width="match_parent" android:layout_height="wrap_content" - android:text="Accelerometer Activity"> + android:text=""> + + + + + + - - \ No newline at end of file -- 2.47.2 From 032ab2788dd43d5ade030f8f5babfee5270d6316 Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 14 Jun 2023 21:58:44 +0200 Subject: [PATCH 16/34] Added alarm history to project and renaming --- .../greenwatch/AccelerometerActivity.java | 46 +++++--- .../com/example/greenwatch/MainActivity.java | 48 ++++---- .../adapters/AlarmHistoryListAdapter.java | 62 +++++++++++ .../repositories/DeviceRepository.java | 103 ++++++++++++------ .../viewmodels/AccelerometerViewModel.java | 12 +- .../viewmodels/MainActivityViewModel.java | 11 +- .../res/layout/activity_accelerometer.xml | 23 ++++ app/src/main/res/layout/activity_main.xml | 12 +- .../main/res/layout/alarm_history_item.xml | 51 +++++++++ 9 files changed, 279 insertions(+), 89 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/adapters/AlarmHistoryListAdapter.java create mode 100644 app/src/main/res/layout/alarm_history_item.xml diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index c175d40..9ee6d6a 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -3,6 +3,8 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; import androidx.lifecycle.Observer; import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; import android.hardware.Sensor; import android.hardware.SensorEvent; @@ -14,6 +16,8 @@ import android.widget.Button; import android.widget.TextView; import android.widget.Toast; +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; +import com.example.greenwatch.adapters.DeviceListAdapter; import com.example.greenwatch.models.Device; import com.example.greenwatch.viewmodels.AccelerometerViewModel; @@ -39,6 +43,20 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv accelerometerWarningTV = (TextView) findViewById(R.id.tvAccelerometerWarning); backToMainActivityButton = (Button) findViewById(R.id.accelerometerBackToMainActivity); + RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); + recyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + backToMainActivityButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { @@ -51,34 +69,26 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv mAccelerometerViewModel.getConnectedDeviceList().observe(this, new Observer>() { @Override public void onChanged(List devices) { - StringBuilder sb = new StringBuilder(); - sb.append("Time Stamp: "); - sb.append(mAccelerometerViewModel.getTimeStamp(mAccelerometerViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("DeviceID: "); - sb.append(mAccelerometerViewModel.getDeviceID(mAccelerometerViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Status: "); - sb.append(mAccelerometerViewModel.getSensorStatus(mAccelerometerViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Type: "); - sb.append(mAccelerometerViewModel.getSensorType(mAccelerometerViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Massage: "); - sb.append(mAccelerometerViewModel.getSensorMassage(mAccelerometerViewModel.getLocalDeviceUUID())); - accelerometerStatusMessage.setText(sb); + deviceListAdapter.setDevices(devices); Toast.makeText(AccelerometerActivity.this, "onChanged", Toast.LENGTH_LONG).show(); } }); + mAccelerometerViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + mAccelerometerViewModel.getMovementDetectedValue().observe(this, new Observer() { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mAccelerometerViewModel.setDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); } else { - mAccelerometerViewModel.setDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0); + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0); } } diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 28c3003..6d449bc 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -10,9 +10,9 @@ import android.content.Intent; import android.os.Bundle; import android.view.View; import android.widget.Button; -import android.widget.TextView; import android.widget.Toast; +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; import com.example.greenwatch.adapters.DeviceListAdapter; import com.example.greenwatch.models.Device; import com.example.greenwatch.viewmodels.MainActivityViewModel; @@ -21,7 +21,6 @@ import java.util.List; public class MainActivity extends AppCompatActivity { - private TextView tvstatusmessage; private Button audiodetectionButton; private Button videodetectionButton; private Button accelerometerButton; @@ -35,7 +34,6 @@ public class MainActivity extends AppCompatActivity { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); - tvstatusmessage = (TextView) findViewById(R.id.tvStatusmessage); audiodetectionButton = (Button) findViewById(R.id.audiodetectionButton); videodetectionButton = (Button) findViewById(R.id.videodetectionButton); accelerometerButton = (Button) findViewById(R.id.accelerometerButton); @@ -43,12 +41,19 @@ public class MainActivity extends AppCompatActivity { videodetectionAndAccelerometerButton = (Button) findViewById(R.id.videodetectionAndAccelerometerButton); connectionButton = (Button) findViewById(R.id.connectionButton); - RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); - recyclerView.setLayoutManager(new LinearLayoutManager(this)); - recyclerView.setHasFixedSize(true); + RecyclerView deviceListRecyclerView = findViewById(R.id.deviceListRecyclerView); + deviceListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + deviceListRecyclerView.setHasFixedSize(true); final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); - recyclerView.setAdapter(deviceListAdapter); + deviceListRecyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); mMainActivityViewModel = new ViewModelProvider(this).get(MainActivityViewModel.class); mMainActivityViewModel.init(); @@ -56,31 +61,22 @@ public class MainActivity extends AppCompatActivity { @Override public void onChanged(List devices) { deviceListAdapter.setDevices(devices); - StringBuilder sb = new StringBuilder(); - sb.append("Time Stamp: "); - sb.append(mMainActivityViewModel.getTimeStamp(mMainActivityViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("DeviceID: "); - sb.append(mMainActivityViewModel.getDeviceID(mMainActivityViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Status: "); - sb.append(mMainActivityViewModel.getSensorStatus(mMainActivityViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Type: "); - sb.append(mMainActivityViewModel.getSensorType(mMainActivityViewModel.getLocalDeviceUUID())); - sb.append(";\n"); - sb.append("Sensor Massage: "); - sb.append(mMainActivityViewModel.getSensorMassage(mMainActivityViewModel.getLocalDeviceUUID())); - tvstatusmessage.setText(sb); Toast.makeText(MainActivity.this, "onChanged", Toast.LENGTH_LONG).show(); } }); + mMainActivityViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + audiodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //openAudiodetectionActivity(); - mMainActivityViewModel.setDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", false, "Audio", 10); + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", false, "Audio", 10); } }); videodetectionButton.setOnClickListener(new View.OnClickListener() { @@ -140,12 +136,12 @@ public class MainActivity extends AppCompatActivity { public void openVideodetectionAndAccelerometerActivity(){ //Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); //startActivity(intent); - mMainActivityViewModel.setDevice(mMainActivityViewModel.getLocalDeviceUUID(), "24:00", false, "Video", 0); + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "24:00", false, "Video", 0); } public void openConnectionActivity(){ //Intent intent = new Intent(this, ConnectionActivity.class); //startActivity(intent); - mMainActivityViewModel.setDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", true, "Audio", 10); + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", true, "Audio", 10); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/adapters/AlarmHistoryListAdapter.java b/app/src/main/java/com/example/greenwatch/adapters/AlarmHistoryListAdapter.java new file mode 100644 index 0000000..51cc29c --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/adapters/AlarmHistoryListAdapter.java @@ -0,0 +1,62 @@ +package com.example.greenwatch.adapters; + +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +import com.example.greenwatch.R; +import com.example.greenwatch.models.Device; + +import java.util.ArrayList; +import java.util.List; + +public class AlarmHistoryListAdapter extends RecyclerView.Adapter { + private List alarmHistoryList = new ArrayList<>(); + + + @NonNull + @Override + public AlarmHistoryListHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { + View itemView = LayoutInflater.from(parent.getContext()) + .inflate(R.layout.alarm_history_item, parent, false); + return new AlarmHistoryListHolder(itemView); + } + + @Override + public void onBindViewHolder(@NonNull AlarmHistoryListHolder holder, int position) { + Device currentDevice = alarmHistoryList.get(position); + holder.textViewSensorType.setText(holder.itemView.getContext().getString(R.string.sensor_type_placeholder, currentDevice.getSensorType())); + holder.textViewDeviceID.setText(holder.itemView.getContext().getString(R.string.deviceID_placeholder, currentDevice.getDeviceID())); + holder.textViewTimeStamp.setText(holder.itemView.getContext().getString(R.string.sensor_time_stamp_placeholder, currentDevice.getTimeStamp())); + holder.textViewSensorMessage.setText(holder.itemView.getContext().getString(R.string.sensor_message_placeholder, currentDevice.getSensorMassage())); + } + + @Override + public int getItemCount() { + return alarmHistoryList.size(); + } + + public void setAlarmHistoryList(List alarmHistoryList) { + this.alarmHistoryList = alarmHistoryList; + notifyDataSetChanged(); + } + + class AlarmHistoryListHolder extends RecyclerView.ViewHolder { + private TextView textViewSensorType; + private TextView textViewDeviceID; + private TextView textViewTimeStamp; + private TextView textViewSensorMessage; + + public AlarmHistoryListHolder(View itemView) { + super(itemView); + textViewSensorType = (TextView) itemView.findViewById(R.id.tvAlarmHistoryDeviceSensorType); + textViewDeviceID = (TextView) itemView.findViewById(R.id.tvAlarmHistoryDeviceID); + textViewTimeStamp = (TextView) itemView.findViewById(R.id.tvAlarmHistoryDeviceTimeStamp); + textViewSensorMessage = (TextView) itemView.findViewById(R.id.tvAlarmHistoryDeviceSensorMassage); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java index b98d09f..11a463b 100644 --- a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -6,21 +6,26 @@ import androidx.lifecycle.MutableLiveData; import com.example.greenwatch.models.Device; import com.example.greenwatch.communication.WiFiCommunication; +import java.text.SimpleDateFormat; import java.util.ArrayList; +import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.UUID; public class DeviceRepository { + private final int maxAlarmHistoryListSize = 20; private final String delimiter = ", "; private final String SensorStatusKey = "An"; private String localDeviceUUID; private static DeviceRepository deviceRepositoryInstance; private WiFiCommunication mWiFiCommunication; private MutableLiveData> deviceList = new MutableLiveData<>(); + private MutableLiveData> alarmHistoryList = new MutableLiveData<>(); private HashMap connectedDevicesList = new HashMap<>(); private HashMap deviceIDMapper = new HashMap<>(); + private List alarmHistoryDeviceList = new ArrayList<>(); private DeviceRepository() { setLocalDeviceUUID(); @@ -38,15 +43,42 @@ public class DeviceRepository { } public MutableLiveData> getConnectedDeviceList() { - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); return deviceList; } + public MutableLiveData> getAlarmHistoryDeviceList() { + setMutableLiveDataAlarmHistoryList(); + return alarmHistoryList; + } + public void createNewDevice(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage){ Device newDevice = new Device(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); - setDeviceIDMapper(deviceID); + if (sensorStatus) { + setAlarmHistoryDeviceList(newDevice); + } addToConnectedDeviceList(newDevice.getDeviceID(), newDevice); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); + } + + public void getNewReceivedMessage(String newMessage) { + String[] messageString = messageStringSplitter(newMessage); + String timeStamp = messageString[0]; + String deviceID = messageString[1]; + boolean sensorStatus = convertSensorStatus(messageString[2]); + String sensorType = messageString[3]; + int sensorMassage = Integer.valueOf(messageString[4]); + + if (deviceID.equals(checkDeviceID(localDeviceUUID))) { + return; + } + + if(!connectedDevicesList.containsKey(deviceID)) { + createNewDevice(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); + } + else { + updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } } private String messageStringBuilder(String deviceID) { @@ -62,7 +94,6 @@ public class DeviceRepository { .append(device.getSensorType()) .append(delimiter) .append(device.getSensorMassage()); - return message.toString(); } else { message.append("") @@ -74,8 +105,8 @@ public class DeviceRepository { .append("") .append(delimiter) .append(""); - return message.toString(); } + return message.toString(); } public String getLocalDeviceUUID() { @@ -87,11 +118,14 @@ public class DeviceRepository { Device device = connectedDevicesList.get(checkedDeviceID); if(device != null) { device.setTimeStamp(timeStamp); - device.setSensorStatus(sensorStatus); device.setSensorType(sensorType); device.setSensorMassage(sensorMassage); + if (!device.getSensorStatus() && sensorStatus) { + setAlarmHistoryDeviceList(device); + } + device.setSensorStatus(sensorStatus); addToConnectedDeviceList(checkedDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); } } @@ -101,7 +135,7 @@ public class DeviceRepository { if(device != null) { device.setTimeStamp(timeStamp); addToConnectedDeviceList(checkedDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); } } @@ -122,7 +156,7 @@ public class DeviceRepository { setDeviceIDMapper(newDeviceID); connectedDevicesList.remove(checkedDeviceID); addToConnectedDeviceList(newDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); } } @@ -139,9 +173,13 @@ public class DeviceRepository { String checkedDeviceID = checkDeviceID(deviceID); Device device = connectedDevicesList.get(checkedDeviceID); if(device != null) { + if (!device.getSensorStatus() && sensorStatus) { + setAlarmHistoryDeviceList(device); + } device.setSensorStatus(sensorStatus); addToConnectedDeviceList(checkedDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); + } } @@ -160,7 +198,7 @@ public class DeviceRepository { if(device != null) { device.setSensorType(sensorType); addToConnectedDeviceList(checkedDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); } } @@ -179,7 +217,7 @@ public class DeviceRepository { if(device != null) { device.setSensorMassage(sensorMessage); addToConnectedDeviceList(checkedDeviceID, device); - setMutableLiveDataValue(); + setMutableLiveDataDeviceList(); } } @@ -192,11 +230,21 @@ public class DeviceRepository { return 0; } - private void setMutableLiveDataValue() { + public String getSystemTimeStamp() { + SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss"); + Date date = new Date(System.currentTimeMillis()); + return formatter.format(date); + } + + private void setMutableLiveDataDeviceList() { List list = new ArrayList<>(connectedDevicesList.values()); deviceList.setValue(list); } + private void setMutableLiveDataAlarmHistoryList() { + alarmHistoryList.setValue(alarmHistoryDeviceList); + } + private void addToConnectedDeviceList(String key, Device device) { connectedDevicesList.put(key, device); if (key.equals(checkDeviceID(localDeviceUUID))) { @@ -223,27 +271,16 @@ public class DeviceRepository { return message.split(delimiter); } - public void getNewReceivedMessage(String newMessage) { - String[] messageString = messageStringSplitter(newMessage); - String timeStamp = messageString[0]; - String deviceID = messageString[1]; - boolean sensorStatus = convertSensorStatus(messageString[2]); - String sensorType = messageString[3]; - int sensorMassage = Integer.valueOf(messageString[4]); - - if (deviceID.equals(checkDeviceID(localDeviceUUID))) { - return; - } - - if(!connectedDevicesList.containsKey(deviceID)) { - createNewDevice(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); - } - else { - updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); - } - } - private boolean convertSensorStatus(String status) { return status.equals(SensorStatusKey); } + + private void setAlarmHistoryDeviceList(Device device) { + if (alarmHistoryDeviceList.size() == maxAlarmHistoryListSize) { + alarmHistoryDeviceList.remove(alarmHistoryDeviceList.size() -1); + } + Device alarmHistoryDevice = new Device(device.getTimeStamp(), device.getDeviceID(), device.getSensorStatus(), device.getSensorType(), device.getSensorMassage()); + alarmHistoryDeviceList.add(0, alarmHistoryDevice); + setMutableLiveDataAlarmHistoryList(); + } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index 8bd6322..93e42ef 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -16,6 +16,7 @@ public class AccelerometerViewModel extends ViewModel { private MutableLiveData> mDeviceList; private MutableLiveData mMovementDetected = new MutableLiveData<>(); + private MutableLiveData> mAlarmHistoryList; private DeviceRepository mDeviceRepository; private ArrayList Gesamt_be; int arraySize = 500; @@ -29,6 +30,7 @@ public class AccelerometerViewModel extends ViewModel { if (mDeviceList == null) { mDeviceRepository = DeviceRepository.getInstance(); mDeviceList = mDeviceRepository.getConnectedDeviceList(); + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); } initGesamtBE(); mMovementDetected.setValue(false); @@ -80,9 +82,7 @@ public class AccelerometerViewModel extends ViewModel { } public String getSystemTimeStamp() { - SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss"); - Date date = new Date(System.currentTimeMillis()); - return formatter.format(date); + return mDeviceRepository.getSystemTimeStamp(); } public LiveData getMovementDetectedValue() { @@ -93,7 +93,11 @@ public class AccelerometerViewModel extends ViewModel { return mDeviceList; } - public void setDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index d5eb2cf..84b2e9f 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -13,6 +13,7 @@ import java.util.List; public class MainActivityViewModel extends ViewModel { private MutableLiveData> mDeviceList; + private MutableLiveData> mAlarmHistoryList; private DeviceRepository mDeviceRepository; @@ -26,15 +27,21 @@ public class MainActivityViewModel extends ViewModel { mWiFiCommunication = WiFiCommunication.getInstance(); mDeviceRepository.setWiFiCommunication(mWiFiCommunication); mWiFiCommunication.setDeviceRepository(mDeviceRepository); - mDeviceRepository.createNewDevice("", mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0); + mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0); + mDeviceRepository.createNewDevice("00:00", "1234", true, "Test", 21); mDeviceList = mDeviceRepository.getConnectedDeviceList(); + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); } public LiveData> getConnectedDeviceList() { return mDeviceList; } - public void setDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } diff --git a/app/src/main/res/layout/activity_accelerometer.xml b/app/src/main/res/layout/activity_accelerometer.xml index 9f929a4..b90e124 100644 --- a/app/src/main/res/layout/activity_accelerometer.xml +++ b/app/src/main/res/layout/activity_accelerometer.xml @@ -36,4 +36,27 @@ android:text="Back to MainActivity"> + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml index 2401650..ca28180 100644 --- a/app/src/main/res/layout/activity_main.xml +++ b/app/src/main/res/layout/activity_main.xml @@ -8,19 +8,19 @@ android:padding="10dp" tools:context=".MainActivity"> - - + android:layout_weight="3" + tools:listitem="@layout/alarm_history_item"> + diff --git a/app/src/main/res/layout/alarm_history_item.xml b/app/src/main/res/layout/alarm_history_item.xml new file mode 100644 index 0000000..543a2d1 --- /dev/null +++ b/app/src/main/res/layout/alarm_history_item.xml @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 317bef2b59d2f65ccc8783fbdd45559f0507455b Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 14 Jun 2023 22:19:22 +0200 Subject: [PATCH 17/34] Added ViewModelInterface --- .../viewmodels/AccelerometerViewModel.java | 17 ++++++++++++- .../viewmodels/MainActivityViewModel.java | 18 +++++++++++-- .../viewmodels/ViewModelInterface.java | 25 +++++++++++++++++++ 3 files changed, 57 insertions(+), 3 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index 93e42ef..14bec64 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -12,7 +12,7 @@ import java.util.ArrayList; import java.util.Date; import java.util.List; -public class AccelerometerViewModel extends ViewModel { +public class AccelerometerViewModel extends ViewModel implements ViewModelInterface { private MutableLiveData> mDeviceList; private MutableLiveData mMovementDetected = new MutableLiveData<>(); @@ -26,6 +26,7 @@ public class AccelerometerViewModel extends ViewModel { float thresholdValue; boolean startMeasuring; + @Override public void init() { if (mDeviceList == null) { mDeviceRepository = DeviceRepository.getInstance(); @@ -89,58 +90,72 @@ public class AccelerometerViewModel extends ViewModel { return mMovementDetected; } + @Override public LiveData> getConnectedDeviceList() { return mDeviceList; } + @Override public LiveData> getAlarmHistoryList() { return mAlarmHistoryList; } + @Override public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } + @Override public void setTimeStamp(String deviceID, String timeStamp) { mDeviceRepository.setTimeStamp(deviceID, timeStamp); } + @Override public String getTimeStamp(String deviceID) { return mDeviceRepository.getTimeStamp(deviceID); } + @Override public void setDeviceID(String deviceID, String newDeviceID) { mDeviceRepository.setDeviceID(deviceID, newDeviceID); } + @Override public String getDeviceID(String deviceID) { return mDeviceRepository.getDeviceID(deviceID); } + @Override public void setSensorStatus(String deviceID, boolean sensorStatus) { mDeviceRepository.setSensorStatus(deviceID, sensorStatus); } + @Override public boolean getSensorStatus(String deviceID) { return mDeviceRepository.getSensorStatus(deviceID); } + @Override public void setSensorType(String deviceID, String sensorType) { mDeviceRepository.setSensorType(deviceID, sensorType); } + @Override public String getSensorType(String deviceID) { return mDeviceRepository.getSensorType(deviceID); } + @Override public void setSensorMassage(String deviceID, int sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } + @Override public int getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } + @Override public String getLocalDeviceUUID() { return mDeviceRepository.getLocalDeviceUUID(); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index 84b2e9f..0405d93 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -10,13 +10,13 @@ import com.example.greenwatch.repositories.DeviceRepository; import java.util.List; -public class MainActivityViewModel extends ViewModel { +public class MainActivityViewModel extends ViewModel implements ViewModelInterface { private MutableLiveData> mDeviceList; private MutableLiveData> mAlarmHistoryList; private DeviceRepository mDeviceRepository; - + @Override public void init() { WiFiCommunication mWiFiCommunication; if(mDeviceList != null) { @@ -33,58 +33,72 @@ public class MainActivityViewModel extends ViewModel { mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); } + @Override public LiveData> getConnectedDeviceList() { return mDeviceList; } + @Override public LiveData> getAlarmHistoryList() { return mAlarmHistoryList; } + @Override public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } + @Override public void setTimeStamp(String deviceID, String timeStamp) { mDeviceRepository.setTimeStamp(deviceID, timeStamp); } + @Override public String getTimeStamp(String deviceID) { return mDeviceRepository.getTimeStamp(deviceID); } + @Override public void setDeviceID(String deviceID, String newDeviceID) { mDeviceRepository.setDeviceID(deviceID, newDeviceID); } + @Override public String getDeviceID(String deviceID) { return mDeviceRepository.getDeviceID(deviceID); } + @Override public void setSensorStatus(String deviceID, boolean sensorStatus) { mDeviceRepository.setSensorStatus(deviceID, sensorStatus); } + @Override public boolean getSensorStatus(String deviceID) { return mDeviceRepository.getSensorStatus(deviceID); } + @Override public void setSensorType(String deviceID, String sensorType) { mDeviceRepository.setSensorType(deviceID, sensorType); } + @Override public String getSensorType(String deviceID) { return mDeviceRepository.getSensorType(deviceID); } + @Override public void setSensorMassage(String deviceID, int sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } + @Override public int getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } + @Override public String getLocalDeviceUUID() { return mDeviceRepository.getLocalDeviceUUID(); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java new file mode 100644 index 0000000..45c6839 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java @@ -0,0 +1,25 @@ +package com.example.greenwatch.viewmodels; + +import androidx.lifecycle.LiveData; + +import com.example.greenwatch.models.Device; + +import java.util.List; + +public interface ViewModelInterface { + void init(); + LiveData> getConnectedDeviceList(); + LiveData> getAlarmHistoryList(); + void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage); + void setTimeStamp(String deviceID, String timeStamp); + String getTimeStamp(String deviceID); + void setDeviceID(String deviceID, String newDeviceID); + String getDeviceID(String deviceID); + void setSensorStatus(String deviceID, boolean sensorStatus); + boolean getSensorStatus(String deviceID); + void setSensorType(String deviceID, String sensorType); + String getSensorType(String deviceID); + void setSensorMassage(String deviceID, int sensorMessage); + int getSensorMassage(String deviceID); + String getLocalDeviceUUID(); +} -- 2.47.2 From 8dd4c6d56a5c6ae061be4c0976480e020df0de71 Mon Sep 17 00:00:00 2001 From: Christian Date: Sun, 18 Jun 2023 20:57:48 +0200 Subject: [PATCH 18/34] Added Video detection to project --- app/build.gradle | 6 + app/src/main/AndroidManifest.xml | 3 + .../com/example/greenwatch/MainActivity.java | 12 +- .../greenwatch/VideodetectionActivity.java | 71 ++++++++++ .../greenwatch/sensors/CameraSensor.java | 126 +++++++++++++++++ .../viewmodels/AccelerometerViewModel.java | 9 +- .../viewmodels/MainActivityViewModel.java | 21 ++- .../viewmodels/VideodetectionViewModel.java | 131 ++++++++++++++++++ .../viewmodels/ViewModelInterface.java | 1 + .../res/layout/activity_videodetection.xml | 23 +++ 10 files changed, 394 insertions(+), 9 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java diff --git a/app/build.gradle b/app/build.gradle index e5afc91..a919618 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -35,4 +35,10 @@ dependencies { testImplementation 'junit:junit:4.13.2' androidTestImplementation 'androidx.test.ext:junit:1.1.5' androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1' + + def camerax_version = "1.2.3" + implementation "androidx.camera:camera-camera2:${camerax_version}" + implementation "androidx.camera:camera-lifecycle:${camerax_version}" + implementation "androidx.camera:camera-view:${camerax_version}" + } \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 803c5b5..e348435 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -3,6 +3,9 @@ package="com.example.greenwatch"> + + + >() { @Override public void onChanged(List devices) { @@ -82,10 +83,13 @@ public class MainActivity extends AppCompatActivity { videodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - //openVideodetectionActivity(); - mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "Video"); - mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "12:50"); - mMainActivityViewModel.setDeviceID(mMainActivityViewModel.getLocalDeviceUUID(), "12345"); + if (mMainActivityViewModel.isCameraAccessAllowed(MainActivity.this)) { + openVideodetectionActivity(); + } + else { + mMainActivityViewModel.accessRequestCamera(MainActivity.this); + } + } }); accelerometerButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java index 2547bde..cd119a2 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -1,14 +1,32 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.camera.lifecycle.ProcessCameraProvider; +import androidx.core.content.ContextCompat; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.Toast; + +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; +import com.example.greenwatch.adapters.DeviceListAdapter; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.AccelerometerViewModel; +import com.example.greenwatch.viewmodels.VideodetectionViewModel; +import com.google.common.util.concurrent.ListenableFuture; + +import java.util.List; +import java.util.concurrent.ExecutionException; public class VideodetectionActivity extends AppCompatActivity { private Button backToMainActivity; + private VideodetectionViewModel mVideoDetectionViewModel; @Override protected void onCreate(Bundle savedInstanceState) { @@ -17,11 +35,64 @@ public class VideodetectionActivity extends AppCompatActivity { backToMainActivity = (Button) findViewById(R.id.videodetectorBackToMainActivity); + RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); + recyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + backToMainActivity.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { finish(); } }); + + mVideoDetectionViewModel = new ViewModelProvider(this).get(VideodetectionViewModel.class); + mVideoDetectionViewModel.init(); + mVideoDetectionViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + Toast.makeText(VideodetectionActivity.this, "onChanged", Toast.LENGTH_LONG).show(); + } + }); + + mVideoDetectionViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mVideoDetectionViewModel.getVideoAlarmDetectedValue().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), true, "Video", 10); + } + else { + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), false, "Video", 0); + } + + } + }); + + final ListenableFuture cameraProviderFuture = ProcessCameraProvider.getInstance(this); + cameraProviderFuture.addListener(() -> { + try { + mVideoDetectionViewModel.bindImageAnalysis(cameraProviderFuture.get(), this, this); + } catch (ExecutionException | InterruptedException e) { + e.printStackTrace(); + } + }, ContextCompat.getMainExecutor(this)); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java new file mode 100644 index 0000000..7933115 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java @@ -0,0 +1,126 @@ +package com.example.greenwatch.sensors; + +import android.content.Context; +import android.graphics.ImageFormat; +import android.media.Image; +import android.util.Size; + +import androidx.camera.core.CameraSelector; +import androidx.camera.core.ImageAnalysis; +import androidx.camera.lifecycle.ProcessCameraProvider; +import androidx.core.content.ContextCompat; +import androidx.lifecycle.LifecycleOwner; +import androidx.lifecycle.MutableLiveData; + +import java.nio.ByteBuffer; + +public class CameraSensor { + private final MutableLiveData mVideoAlarmDetected = new MutableLiveData<>(); + private static CameraSensor cameraSensorInstance; + private boolean videoAlarmDetected; + private ByteBuffer previousBuffer; + private int previousWidth; + private int previousHeight; + + private CameraSensor() { + videoAlarmDetected = false; + } + + public static synchronized CameraSensor getInstance() { + if (cameraSensorInstance == null){ + cameraSensorInstance = new CameraSensor(); + } + return cameraSensorInstance; + } + + public MutableLiveData getVideoAlarmDetectedValue() { + setMutableLiveDataVideoMovementDetected(); + return mVideoAlarmDetected; + } + + private void setMutableLiveDataVideoMovementDetected() { + mVideoAlarmDetected.setValue(videoAlarmDetected); + } + + public void bindImageAnalysis(ProcessCameraProvider cameraProvider, LifecycleOwner lifecycleOwner, Context context) { + ImageAnalysis.Builder builder = new ImageAnalysis.Builder(); + builder.setTargetResolution(new Size(640, 480)); + builder.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST); + ImageAnalysis imageAnalysis = builder.build(); + imageAnalysis.setAnalyzer( + ContextCompat.getMainExecutor(context), + imageProxy -> { + + int imageFormat = imageProxy.getFormat(); + + if (imageFormat == ImageFormat.YUV_420_888) { + + Image currentImage = imageProxy.getImage(); + + if (previousHeight != 0) { + assert currentImage != null; + videoAlarmDetected = compareFrames(currentImage); + } + + assert currentImage != null; + Image.Plane[] planes = currentImage.getPlanes(); + ByteBuffer buffer = planes[0].getBuffer().duplicate(); + previousBuffer = ByteBuffer.allocateDirect(buffer.remaining()); + previousBuffer.put(buffer); + previousWidth = currentImage.getWidth(); + previousHeight = currentImage.getHeight(); + + currentImage.close(); + + checkAlarmCondition(); + + } + + imageProxy.close(); + }); + + CameraSelector cameraSelector = new CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build(); + + cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, imageAnalysis); + } + + private boolean compareFrames(Image currentImage) { + + ByteBuffer currentBuffer = currentImage.getPlanes()[0].getBuffer(); + + int currentWidth = currentImage.getWidth(); + int currentHeight = currentImage.getHeight(); + + if (previousWidth != currentWidth || previousHeight != currentHeight) { + return false; + } + + for (int row = 0; row < previousHeight; row++) { + for (int col = 0; col < previousWidth; col++) { + + int previousIndex = row * previousWidth + col; + int currentIndex = row * currentWidth + col; + + int previousPixel = previousBuffer.get(previousIndex) & 0xFF; + int currentPixel = currentBuffer.get(currentIndex) & 0xFF; + + int pixelDifference = Math.abs(previousPixel - currentPixel); + int threshold = 120; + + if (pixelDifference > threshold) { + return true; + } + } + } + return false; + } + + public void checkAlarmCondition() { + if (videoAlarmDetected && !mVideoAlarmDetected.getValue()) { + setMutableLiveDataVideoMovementDetected(); + } + else if (!videoAlarmDetected && mVideoAlarmDetected.getValue()){ + setMutableLiveDataVideoMovementDetected(); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index 14bec64..bd767ab 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -82,10 +82,6 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf } } - public String getSystemTimeStamp() { - return mDeviceRepository.getSystemTimeStamp(); - } - public LiveData getMovementDetectedValue() { return mMovementDetected; } @@ -159,4 +155,9 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf public String getLocalDeviceUUID() { return mDeviceRepository.getLocalDeviceUUID(); } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index 0405d93..cce6ee0 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -1,5 +1,11 @@ package com.example.greenwatch.viewmodels; +import android.app.Activity; +import android.content.Context; +import android.content.pm.PackageManager; + +import androidx.core.app.ActivityCompat; +import androidx.core.content.ContextCompat; import androidx.lifecycle.LiveData; import androidx.lifecycle.MutableLiveData; import androidx.lifecycle.ViewModel; @@ -15,6 +21,7 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa private MutableLiveData> mDeviceList; private MutableLiveData> mAlarmHistoryList; private DeviceRepository mDeviceRepository; + private static final int RECHTEANFORDERUNG_KAMERA = 10; @Override public void init() { @@ -28,11 +35,18 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa mDeviceRepository.setWiFiCommunication(mWiFiCommunication); mWiFiCommunication.setDeviceRepository(mDeviceRepository); mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0); - mDeviceRepository.createNewDevice("00:00", "1234", true, "Test", 21); mDeviceList = mDeviceRepository.getConnectedDeviceList(); mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); } + public boolean isCameraAccessAllowed(Context context) { + return ContextCompat.checkSelfPermission(context, android.Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED; + } + + public void accessRequestCamera(Activity activity) { + ActivityCompat.requestPermissions(activity, new String[]{android.Manifest.permission.CAMERA}, RECHTEANFORDERUNG_KAMERA); + } + @Override public LiveData> getConnectedDeviceList() { return mDeviceList; @@ -102,4 +116,9 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa public String getLocalDeviceUUID() { return mDeviceRepository.getLocalDeviceUUID(); } + + @Override + public String getSystemTimeStamp() { + return null; + } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java new file mode 100644 index 0000000..1fa0018 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java @@ -0,0 +1,131 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; + +import androidx.camera.lifecycle.ProcessCameraProvider; +import androidx.lifecycle.LifecycleOwner; +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.CameraSensor; + +import java.util.List; + +public class VideodetectionViewModel extends ViewModel implements ViewModelInterface { + + private MutableLiveData> mDeviceList; + private MutableLiveData mVideoAlarmDetected; + private MutableLiveData> mAlarmHistoryList; + private DeviceRepository mDeviceRepository; + private CameraSensor mCameraSensor; + + + public LiveData getVideoMovementDetectedValue() { + return mVideoAlarmDetected; + } + + @Override + public void init() { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mCameraSensor == null) { + mCameraSensor = CameraSensor.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mVideoAlarmDetected == null) { + mVideoAlarmDetected = mCameraSensor.getVideoAlarmDetectedValue(); + } + } + + public void bindImageAnalysis(ProcessCameraProvider cameraProvider, LifecycleOwner lifecycleOwner, Context context) { + mCameraSensor.bindImageAnalysis(cameraProvider, lifecycleOwner, context); + } + + public LiveData getVideoAlarmDetectedValue() { + return mVideoAlarmDetected; + } + + @Override + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + @Override + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + @Override + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } + + @Override + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + @Override + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + @Override + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + @Override + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + @Override + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + @Override + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + @Override + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + @Override + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + @Override + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } +} diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java index 45c6839..35372c3 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java @@ -22,4 +22,5 @@ public interface ViewModelInterface { void setSensorMassage(String deviceID, int sensorMessage); int getSensorMassage(String deviceID); String getLocalDeviceUUID(); + String getSystemTimeStamp(); } diff --git a/app/src/main/res/layout/activity_videodetection.xml b/app/src/main/res/layout/activity_videodetection.xml index d68362e..d7bfb3c 100644 --- a/app/src/main/res/layout/activity_videodetection.xml +++ b/app/src/main/res/layout/activity_videodetection.xml @@ -22,4 +22,27 @@ android:text="Back to MainActivity"> + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 1094b0f75d1bd302a078a83fc18d817ae7dc8935 Mon Sep 17 00:00:00 2001 From: Christian Date: Sun, 18 Jun 2023 22:01:52 +0200 Subject: [PATCH 19/34] Added Alarm Handling to Project --- .../greenwatch/AccelerometerActivity.java | 13 +++++- .../com/example/greenwatch/MainActivity.java | 14 ++++++- .../greenwatch/VideodetectionActivity.java | 13 +++++- .../repositories/DeviceRepository.java | 40 ++++++++++++++++++- .../viewmodels/AccelerometerViewModel.java | 7 ++++ .../viewmodels/MainActivityViewModel.java | 11 ++++- .../viewmodels/VideodetectionViewModel.java | 9 +++++ .../viewmodels/ViewModelInterface.java | 1 + 8 files changed, 100 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index 9ee6d6a..873a971 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -70,7 +70,6 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv @Override public void onChanged(List devices) { deviceListAdapter.setDevices(devices); - Toast.makeText(AccelerometerActivity.this, "onChanged", Toast.LENGTH_LONG).show(); } }); @@ -81,6 +80,18 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv } }); + mAccelerometerViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(AccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(AccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + mAccelerometerViewModel.getMovementDetectedValue().observe(this, new Observer() { @Override public void onChanged(Boolean aBoolean) { diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 00ebdbf..915d312 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -62,7 +62,6 @@ public class MainActivity extends AppCompatActivity { @Override public void onChanged(List devices) { deviceListAdapter.setDevices(devices); - Toast.makeText(MainActivity.this, "onChanged", Toast.LENGTH_LONG).show(); } }); @@ -73,6 +72,18 @@ public class MainActivity extends AppCompatActivity { } }); + mMainActivityViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(MainActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + audiodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { @@ -89,7 +100,6 @@ public class MainActivity extends AppCompatActivity { else { mMainActivityViewModel.accessRequestCamera(MainActivity.this); } - } }); accelerometerButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java index cd119a2..e6a7f95 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -62,7 +62,6 @@ public class VideodetectionActivity extends AppCompatActivity { @Override public void onChanged(List devices) { deviceListAdapter.setDevices(devices); - Toast.makeText(VideodetectionActivity.this, "onChanged", Toast.LENGTH_LONG).show(); } }); @@ -73,6 +72,18 @@ public class VideodetectionActivity extends AppCompatActivity { } }); + mVideoDetectionViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(VideodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(VideodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + mVideoDetectionViewModel.getVideoAlarmDetectedValue().observe(this, new Observer() { @Override public void onChanged(Boolean aBoolean) { diff --git a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java index 11a463b..6df1250 100644 --- a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -17,10 +17,12 @@ public class DeviceRepository { private final int maxAlarmHistoryListSize = 20; private final String delimiter = ", "; - private final String SensorStatusKey = "An"; + private final String sensorStatusKey = "An"; private String localDeviceUUID; private static DeviceRepository deviceRepositoryInstance; private WiFiCommunication mWiFiCommunication; + private boolean startAlarmRecordingValue; + private MutableLiveData startAlarmRecording = new MutableLiveData<>(); private MutableLiveData> deviceList = new MutableLiveData<>(); private MutableLiveData> alarmHistoryList = new MutableLiveData<>(); private HashMap connectedDevicesList = new HashMap<>(); @@ -29,6 +31,7 @@ public class DeviceRepository { private DeviceRepository() { setLocalDeviceUUID(); + startAlarmRecordingValue = false; } public static synchronized DeviceRepository getInstance() { @@ -52,11 +55,21 @@ public class DeviceRepository { return alarmHistoryList; } + public MutableLiveData getStartAlarmRecording() { + setMutableLiveDataStartAlarmRecording(); + return startAlarmRecording; + } + public void createNewDevice(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage){ Device newDevice = new Device(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); if (sensorStatus) { setAlarmHistoryDeviceList(newDevice); } + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } addToConnectedDeviceList(newDevice.getDeviceID(), newDevice); setMutableLiveDataDeviceList(); } @@ -124,6 +137,11 @@ public class DeviceRepository { setAlarmHistoryDeviceList(device); } device.setSensorStatus(sensorStatus); + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } addToConnectedDeviceList(checkedDeviceID, device); setMutableLiveDataDeviceList(); } @@ -177,6 +195,11 @@ public class DeviceRepository { setAlarmHistoryDeviceList(device); } device.setSensorStatus(sensorStatus); + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } addToConnectedDeviceList(checkedDeviceID, device); setMutableLiveDataDeviceList(); @@ -245,6 +268,10 @@ public class DeviceRepository { alarmHistoryList.setValue(alarmHistoryDeviceList); } + private void setMutableLiveDataStartAlarmRecording() { + startAlarmRecording.setValue(startAlarmRecordingValue); + } + private void addToConnectedDeviceList(String key, Device device) { connectedDevicesList.put(key, device); if (key.equals(checkDeviceID(localDeviceUUID))) { @@ -272,7 +299,7 @@ public class DeviceRepository { } private boolean convertSensorStatus(String status) { - return status.equals(SensorStatusKey); + return status.equals(sensorStatusKey); } private void setAlarmHistoryDeviceList(Device device) { @@ -283,4 +310,13 @@ public class DeviceRepository { alarmHistoryDeviceList.add(0, alarmHistoryDevice); setMutableLiveDataAlarmHistoryList(); } + + private boolean checkDeviceStatus() { + for (Device device : connectedDevicesList.values()) { + if (device.getSensorStatus()) { + return true; + } + } + return false; + } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index bd767ab..74070fc 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -17,6 +17,7 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf private MutableLiveData> mDeviceList; private MutableLiveData mMovementDetected = new MutableLiveData<>(); private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; private DeviceRepository mDeviceRepository; private ArrayList Gesamt_be; int arraySize = 500; @@ -32,6 +33,7 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf mDeviceRepository = DeviceRepository.getInstance(); mDeviceList = mDeviceRepository.getConnectedDeviceList(); mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); } initGesamtBE(); mMovementDetected.setValue(false); @@ -96,6 +98,11 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf return mAlarmHistoryList; } + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + @Override public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index cce6ee0..8f74ef1 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -20,8 +20,9 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa private MutableLiveData> mDeviceList; private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; private DeviceRepository mDeviceRepository; - private static final int RECHTEANFORDERUNG_KAMERA = 10; + private static final int RIGHTS_REQUEST_CAMERA = 10; @Override public void init() { @@ -37,6 +38,7 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0); mDeviceList = mDeviceRepository.getConnectedDeviceList(); mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); } public boolean isCameraAccessAllowed(Context context) { @@ -44,7 +46,7 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa } public void accessRequestCamera(Activity activity) { - ActivityCompat.requestPermissions(activity, new String[]{android.Manifest.permission.CAMERA}, RECHTEANFORDERUNG_KAMERA); + ActivityCompat.requestPermissions(activity, new String[]{android.Manifest.permission.CAMERA}, RIGHTS_REQUEST_CAMERA); } @Override @@ -57,6 +59,11 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa return mAlarmHistoryList; } + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + @Override public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java index 1fa0018..1a252c5 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java @@ -19,6 +19,7 @@ public class VideodetectionViewModel extends ViewModel implements ViewModelInter private MutableLiveData> mDeviceList; private MutableLiveData mVideoAlarmDetected; private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; private DeviceRepository mDeviceRepository; private CameraSensor mCameraSensor; @@ -41,6 +42,9 @@ public class VideodetectionViewModel extends ViewModel implements ViewModelInter if (mAlarmHistoryList == null) { mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } if (mVideoAlarmDetected == null) { mVideoAlarmDetected = mCameraSensor.getVideoAlarmDetectedValue(); } @@ -64,6 +68,11 @@ public class VideodetectionViewModel extends ViewModel implements ViewModelInter return mAlarmHistoryList; } + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + @Override public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java index 35372c3..eb290b4 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java @@ -10,6 +10,7 @@ public interface ViewModelInterface { void init(); LiveData> getConnectedDeviceList(); LiveData> getAlarmHistoryList(); + LiveData getStartAlarmRecording(); void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage); void setTimeStamp(String deviceID, String timeStamp); String getTimeStamp(String deviceID); -- 2.47.2 From 6c4b6b67a45851774205eeaa09d7b40d3e3fc003 Mon Sep 17 00:00:00 2001 From: Christian Date: Sun, 18 Jun 2023 23:00:30 +0200 Subject: [PATCH 20/34] Move the acceleration sensor to its own class --- .../greenwatch/AccelerometerActivity.java | 2 +- .../sensors/AccelerometerSensor.java | 85 +++++++++++++++++++ .../greenwatch/sensors/CameraSensor.java | 8 +- .../viewmodels/AccelerometerViewModel.java | 69 +++++---------- 4 files changed, 111 insertions(+), 53 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index 873a971..ec863b2 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -92,7 +92,7 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv } }); - mAccelerometerViewModel.getMovementDetectedValue().observe(this, new Observer() { + mAccelerometerViewModel.getAccelerometerAlarmDetected().observe(this, new Observer() { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { diff --git a/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java new file mode 100644 index 0000000..70bc6a1 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java @@ -0,0 +1,85 @@ +package com.example.greenwatch.sensors; + +import androidx.lifecycle.MutableLiveData; + +import java.util.ArrayList; + +public class AccelerometerSensor { + private MutableLiveData mAccelerometerAlarmDetected = new MutableLiveData<>(); + private static AccelerometerSensor accelerometerSensorInstance; + private boolean accelerometerAlarmDetected; + private ArrayList Gesamt_be; + int arraySize = 500; + int functionCallCount; + float meanValue; + float offsetValue; + float thresholdValue; + boolean startMeasuring; + + private AccelerometerSensor() { + initGesamtBE(); + accelerometerAlarmDetected = false; + setMutableLiveDataAccelerometerAlarmDetected(); + functionCallCount = 0; + meanValue = 0.0f; + offsetValue = 0.1f; + thresholdValue = 0.15f; + startMeasuring = false; + } + + public static synchronized AccelerometerSensor getInstance() { + if (accelerometerSensorInstance == null){ + accelerometerSensorInstance = new AccelerometerSensor(); + } + return accelerometerSensorInstance; + } + + public MutableLiveData getAccelerometerAlarmDetected() { + setMutableLiveDataAccelerometerAlarmDetected(); + return mAccelerometerAlarmDetected; + } + + private void setMutableLiveDataAccelerometerAlarmDetected() { + mAccelerometerAlarmDetected.setValue(accelerometerAlarmDetected); + } + + private void initGesamtBE() { + Gesamt_be = new ArrayList<>(arraySize); + for (int i = 0; i < arraySize; i++) { + Gesamt_be.add(0.0f); + } + } + + public void addValueToGesamtBE(float newValue) { + if (Gesamt_be.size() == arraySize) { + Gesamt_be.remove(Gesamt_be.size() -1); + } + Gesamt_be.add(0, newValue); + functionCallCount++; + } + + public void meanValueCalculation() { + for (float element : Gesamt_be) { + meanValue += Math.abs(element); + } + meanValue = meanValue/arraySize; + } + + public void calibrateAccelerometerSensor() { + if (functionCallCount <= arraySize) { + offsetValue = meanValue; + } + else { + startMeasuring = true; + } + } + + public void checkAlarmCondition() { + if (meanValue > (thresholdValue + offsetValue) && startMeasuring && !mAccelerometerAlarmDetected.getValue()) { + mAccelerometerAlarmDetected.setValue(true); + } + else if (meanValue < (thresholdValue + offsetValue) && mAccelerometerAlarmDetected.getValue()){ + mAccelerometerAlarmDetected.setValue(false); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java index 7933115..47cd07f 100644 --- a/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java +++ b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java @@ -34,11 +34,11 @@ public class CameraSensor { } public MutableLiveData getVideoAlarmDetectedValue() { - setMutableLiveDataVideoMovementDetected(); + setMutableLiveDataVideoAlarmDetected(); return mVideoAlarmDetected; } - private void setMutableLiveDataVideoMovementDetected() { + private void setMutableLiveDataVideoAlarmDetected() { mVideoAlarmDetected.setValue(videoAlarmDetected); } @@ -117,10 +117,10 @@ public class CameraSensor { public void checkAlarmCondition() { if (videoAlarmDetected && !mVideoAlarmDetected.getValue()) { - setMutableLiveDataVideoMovementDetected(); + setMutableLiveDataVideoAlarmDetected(); } else if (!videoAlarmDetected && mVideoAlarmDetected.getValue()){ - setMutableLiveDataVideoMovementDetected(); + setMutableLiveDataVideoAlarmDetected(); } } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index 74070fc..344480f 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -6,86 +6,59 @@ import androidx.lifecycle.ViewModel; import com.example.greenwatch.models.Device; import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.AccelerometerSensor; -import java.text.SimpleDateFormat; -import java.util.ArrayList; -import java.util.Date; import java.util.List; public class AccelerometerViewModel extends ViewModel implements ViewModelInterface { private MutableLiveData> mDeviceList; - private MutableLiveData mMovementDetected = new MutableLiveData<>(); + private MutableLiveData mAccelerometerAlarmDetected; private MutableLiveData> mAlarmHistoryList; private MutableLiveData mStartAlarmRecording; + private AccelerometerSensor mAccelerometerSensor; private DeviceRepository mDeviceRepository; - private ArrayList Gesamt_be; - int arraySize = 500; - int functionCallCount; - float meanValue; - float offsetValue; - float thresholdValue; - boolean startMeasuring; @Override public void init() { - if (mDeviceList == null) { + if (mDeviceRepository == null) { mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mDeviceList == null) { mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); } - initGesamtBE(); - mMovementDetected.setValue(false); - functionCallCount = 0; - meanValue = 0f; - offsetValue = 0.1f; - thresholdValue = 0.15f; - startMeasuring = false; - } - - public void initGesamtBE() { - Gesamt_be = new ArrayList<>(arraySize); - for (int i = 0; i < arraySize; i++) { - Gesamt_be.add(0f); + if (mAccelerometerAlarmDetected == null) { + mAccelerometerAlarmDetected = mAccelerometerSensor.getAccelerometerAlarmDetected(); } } public void addValueToGesamtBE(float newValue) { - if (Gesamt_be.size() == arraySize) { - Gesamt_be.remove(Gesamt_be.size() -1); - } - Gesamt_be.add(0, newValue); - functionCallCount++; + mAccelerometerSensor.addValueToGesamtBE(newValue); } public void meanValueCalculation() { - for (float element : Gesamt_be) { - meanValue += Math.abs(element); - } - meanValue = meanValue/arraySize; + mAccelerometerSensor.meanValueCalculation(); } public void calibrateAccelerometerSensor() { - if (functionCallCount <= arraySize) { - offsetValue = meanValue; - } - else { - startMeasuring = true; - } + mAccelerometerSensor.calibrateAccelerometerSensor(); } public void checkAlarmCondition() { - if (meanValue > (thresholdValue + offsetValue) && startMeasuring && !mMovementDetected.getValue()) { - mMovementDetected.setValue(true); - } - else if (meanValue < (thresholdValue + offsetValue) && mMovementDetected.getValue()){ - mMovementDetected.setValue(false); - } + mAccelerometerSensor.checkAlarmCondition(); } - public LiveData getMovementDetectedValue() { - return mMovementDetected; + public LiveData getAccelerometerAlarmDetected() { + return mAccelerometerAlarmDetected; } @Override -- 2.47.2 From e3df8b63b8bf9ae9963c0e28845dbb5a4f1bf448 Mon Sep 17 00:00:00 2001 From: Christian Date: Mon, 19 Jun 2023 19:22:49 +0200 Subject: [PATCH 21/34] Added Video and Accelerometer to Project --- .../com/example/greenwatch/MainActivity.java | 5 +- ...ideodetectionAndAccelerometerActivity.java | 146 ++++++++++++- ...deodetectionAndAccelerometerViewModel.java | 196 ++++++++++++++++++ ...ivity_videodetection_and_accelerometer.xml | 41 +++- 4 files changed, 382 insertions(+), 6 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 915d312..683f40c 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -148,9 +148,8 @@ public class MainActivity extends AppCompatActivity { startActivity(intent); } public void openVideodetectionAndAccelerometerActivity(){ - //Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); - //startActivity(intent); - mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "24:00", false, "Video", 0); + Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); + startActivity(intent); } public void openConnectionActivity(){ //Intent intent = new Intent(this, ConnectionActivity.class); diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java index cd88c99..f6118dd 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -1,27 +1,171 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.camera.lifecycle.ProcessCameraProvider; +import androidx.core.content.ContextCompat; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; -public class VideodetectionAndAccelerometerActivity extends AppCompatActivity { +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; +import com.example.greenwatch.adapters.DeviceListAdapter; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.AccelerometerViewModel; +import com.example.greenwatch.viewmodels.VideodetectionAndAccelerometerViewModel; +import com.example.greenwatch.viewmodels.VideodetectionViewModel; +import com.google.common.util.concurrent.ListenableFuture; +import java.util.List; +import java.util.concurrent.ExecutionException; + +public class VideodetectionAndAccelerometerActivity extends AppCompatActivity implements SensorEventListener { + private SensorManager accelerometerManager; + private Sensor accelerometerSensor; + private TextView videodetectionAndAccelerometerStatusMessage; + private TextView videodetectionAndAccelerometerDataTV; + private TextView videodetectionAndAccelerometerWarningTV; private Button backToMainActivity; + private VideodetectionAndAccelerometerViewModel mVideodetectionAndAccelerometerViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_videodetection_and_accelerometer); + videodetectionAndAccelerometerStatusMessage = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerStatusmessage); + videodetectionAndAccelerometerDataTV = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerData); + videodetectionAndAccelerometerWarningTV = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerWarning); backToMainActivity = (Button) findViewById(R.id.videodetectionAndAccelerometerBackToMainActivity); + RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); + recyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + backToMainActivity.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { finish(); } }); + + mVideodetectionAndAccelerometerViewModel = new ViewModelProvider(this).get(VideodetectionAndAccelerometerViewModel.class); + mVideodetectionAndAccelerometerViewModel.init(); + mVideodetectionAndAccelerometerViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mVideodetectionAndAccelerometerViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mVideodetectionAndAccelerometerViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + mVideodetectionAndAccelerometerViewModel.getVideodetectionAndAccelerometerAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + } + else { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0); + } + + } + }); + + final ListenableFuture cameraProviderFuture = ProcessCameraProvider.getInstance(this); + cameraProviderFuture.addListener(() -> { + try { + mVideodetectionAndAccelerometerViewModel.bindImageAnalysis(cameraProviderFuture.get(), this, this); + } catch (ExecutionException | InterruptedException e) { + e.printStackTrace(); + } + }, ContextCompat.getMainExecutor(this)); + + accelerometerManager = (SensorManager) getSystemService(SENSOR_SERVICE); + if (accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).size() == 0) { + accelerometerSensor = null; + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "No accelerometer sensor available", Toast.LENGTH_LONG).show(); + } + else { + accelerometerSensor = accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).get(0); + } + } + + @Override + public void onSensorChanged(SensorEvent event) { + StringBuilder sb = new StringBuilder(); + sb.append("x=") + .append(event.values[0]) + .append("\ny=") + .append(event.values[1]) + .append("\nz=") + .append(event.values[2]); + videodetectionAndAccelerometerDataTV.setText(sb.toString()); + mVideodetectionAndAccelerometerViewModel.addValueToGesamtBE(event.values[0] + event.values[1] + event.values[2]); + mVideodetectionAndAccelerometerViewModel.meanValueCalculation(); + mVideodetectionAndAccelerometerViewModel.calibrateAccelerometerSensor(); + mVideodetectionAndAccelerometerViewModel.checkAlarmCondition(); + } + + @Override + public void onAccuracyChanged(Sensor sensor, int accuracy) { + + } + @Override + protected void onResume() { + super.onResume(); + if (accelerometerSensor != null) { + if (accelerometerManager.registerListener(this, accelerometerSensor, SensorManager.SENSOR_DELAY_GAME)) { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "We registered to the sensor", Toast.LENGTH_LONG).show(); + } else { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Registration did not work", Toast.LENGTH_LONG).show(); + } + } + } + + @Override + protected void onPause() { + super.onPause(); + if (accelerometerSensor != null) { + accelerometerManager.unregisterListener(this, accelerometerSensor); + } } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java new file mode 100644 index 0000000..79d7500 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java @@ -0,0 +1,196 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; + +import androidx.camera.lifecycle.ProcessCameraProvider; +import androidx.lifecycle.LifecycleOwner; +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.AccelerometerSensor; +import com.example.greenwatch.sensors.CameraSensor; + +import java.util.List; + +public class VideodetectionAndAccelerometerViewModel extends ViewModel implements ViewModelInterface{ + private MutableLiveData> mDeviceList; + private MutableLiveData mAccelerometerAlarmDetected; + private MutableLiveData mVideoAlarmDetected; + private MutableLiveData mVideodetectionAndAccelerometerAlarmDetected = new MutableLiveData<>(); + private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; + private AccelerometerSensor mAccelerometerSensor; + private CameraSensor mCameraSensor; + private DeviceRepository mDeviceRepository; + private boolean VideodetectionAndAccelerometerAlarmDetected; + + @Override + public void init() { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mCameraSensor == null) { + mCameraSensor = CameraSensor.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } + if (mAccelerometerAlarmDetected == null) { + mAccelerometerAlarmDetected = mAccelerometerSensor.getAccelerometerAlarmDetected(); + } + if (mVideoAlarmDetected == null) { + mVideoAlarmDetected = mCameraSensor.getVideoAlarmDetectedValue(); + } + VideodetectionAndAccelerometerAlarmDetected = false; + registerAlarmObserver(); + } + + public void addValueToGesamtBE(float newValue) { + mAccelerometerSensor.addValueToGesamtBE(newValue); + } + + public void meanValueCalculation() { + mAccelerometerSensor.meanValueCalculation(); + } + + public void calibrateAccelerometerSensor() { + mAccelerometerSensor.calibrateAccelerometerSensor(); + } + + public void checkAlarmCondition() { + mAccelerometerSensor.checkAlarmCondition(); + } + + public void bindImageAnalysis(ProcessCameraProvider cameraProvider, LifecycleOwner lifecycleOwner, Context context) { + mCameraSensor.bindImageAnalysis(cameraProvider, lifecycleOwner, context); + } + + public LiveData getVideodetectionAndAccelerometerAlarmDetected() { + setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); + return mVideodetectionAndAccelerometerAlarmDetected; + } + + private void setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected() { + mVideodetectionAndAccelerometerAlarmDetected.setValue(VideodetectionAndAccelerometerAlarmDetected); + } + + Observer observer = new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (mVideoAlarmDetected.getValue() || mAccelerometerAlarmDetected.getValue() && !VideodetectionAndAccelerometerAlarmDetected) { + VideodetectionAndAccelerometerAlarmDetected = true; + setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); + + } + else if (!mVideoAlarmDetected.getValue() && !mAccelerometerAlarmDetected.getValue() && VideodetectionAndAccelerometerAlarmDetected) { + VideodetectionAndAccelerometerAlarmDetected = false; + setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); + } + } + }; + + private void registerAlarmObserver() { + mVideoAlarmDetected.observeForever(observer); + mAccelerometerAlarmDetected.observeForever(observer); + } + + @Override + protected void onCleared() { + super.onCleared(); + mVideoAlarmDetected.removeObserver(observer); + mAccelerometerAlarmDetected.removeObserver(observer); + } + + @Override + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + @Override + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + + @Override + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } + + @Override + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + @Override + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + @Override + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + @Override + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + @Override + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + @Override + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + @Override + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + @Override + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + @Override + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } +} diff --git a/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml b/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml index a4ee20d..7a024b1 100644 --- a/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml +++ b/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml @@ -9,10 +9,24 @@ tools:context=".VideodetectionAndAccelerometerActivity"> + android:text=""> + + + + + + + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 99117277bedae1f92a66a7e3c7e1716a76ba3e29 Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 21 Jun 2023 16:54:21 +0200 Subject: [PATCH 22/34] Add Microfon Sensor to Project --- app/src/main/AndroidManifest.xml | 1 + .../greenwatch/AudiodetectionActivity.java | 86 +++++++- .../com/example/greenwatch/MainActivity.java | 9 +- .../GleitenderMittelwert.java | 23 ++ .../MicrofonHelperClasses/RingPuffer.java | 38 ++++ .../Verarbeitungsergebnis.java | 37 ++++ .../greenwatch/sensors/MicrofonSensor.java | 202 ++++++++++++++++++ .../viewmodels/AccelerometerViewModel.java | 1 - .../viewmodels/MainActivityViewModel.java | 10 + .../viewmodels/MicrofonViewModel.java | 142 ++++++++++++ .../res/layout/activity_audiodetection.xml | 25 ++- 11 files changed, 569 insertions(+), 5 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/GleitenderMittelwert.java create mode 100644 app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/RingPuffer.java create mode 100644 app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/Verarbeitungsergebnis.java create mode 100644 app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index e348435..e66c2b5 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -4,6 +4,7 @@ + diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index 06913c8..a4b0f80 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -1,27 +1,111 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import android.hardware.SensorManager; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; + +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; +import com.example.greenwatch.adapters.DeviceListAdapter; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.AccelerometerViewModel; +import com.example.greenwatch.viewmodels.MicrofonViewModel; + +import java.util.List; public class AudiodetectionActivity extends AppCompatActivity { - + private TextView microfonStatusMessage; private Button backToMainActivityButton; + private MicrofonViewModel mMicrofonViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_audiodetection); + microfonStatusMessage = (TextView) findViewById(R.id.tvAudiodetectionStatusmessage); backToMainActivityButton = (Button) findViewById(R.id.audiodetectorBackToMainActivity); + RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); + recyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + backToMainActivityButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { finish(); } }); + + mMicrofonViewModel = new ViewModelProvider(this).get(MicrofonViewModel.class); + mMicrofonViewModel.init(); + mMicrofonViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mMicrofonViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mMicrofonViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(AudiodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(AudiodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + mMicrofonViewModel.getMicrofonAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Microfon", (int) mMicrofonViewModel.getAmplitudeInDB()); + } + else { + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Microfon", (int) mMicrofonViewModel.getAmplitudeInDB()); + } + + } + }); + } + + @Override + protected void onResume() { + super.onResume(); + mMicrofonViewModel.startMicrofonSensor(); + } + + @Override + protected void onPause() { + super.onPause(); + mMicrofonViewModel.stopMicrofonSensor(); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 683f40c..d878ff7 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -58,6 +58,7 @@ public class MainActivity extends AppCompatActivity { mMainActivityViewModel = new ViewModelProvider(this).get(MainActivityViewModel.class); mMainActivityViewModel.init(); mMainActivityViewModel.accessRequestCamera(this); + mMainActivityViewModel.accessRequestMicrofon(this); mMainActivityViewModel.getConnectedDeviceList().observe(this, new Observer>() { @Override public void onChanged(List devices) { @@ -87,8 +88,12 @@ public class MainActivity extends AppCompatActivity { audiodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - //openAudiodetectionActivity(); - mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", false, "Audio", 10); + if (mMainActivityViewModel.isMicrofonAccessAllowed(MainActivity.this)) { + openAudiodetectionActivity(); + } + else { + mMainActivityViewModel.accessRequestMicrofon(MainActivity.this); + } } }); videodetectionButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/GleitenderMittelwert.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/GleitenderMittelwert.java new file mode 100644 index 0000000..3dfd410 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/GleitenderMittelwert.java @@ -0,0 +1,23 @@ +package com.example.greenwatch.sensors.MicrofonHelperClasses; + +public class GleitenderMittelwert { + private final float wichtungNeuerWert; + private final float wichtungAlterWert; + private float mittelwert = 0; + + private boolean istMittelwertGesetzt = false; + + public GleitenderMittelwert(float wichtungNeuerWert) { + this.wichtungNeuerWert = wichtungNeuerWert; + this.wichtungAlterWert = 1 - this.wichtungNeuerWert; + } + + public float mittel(float wert) { + if (istMittelwertGesetzt) { + mittelwert = wert * wichtungNeuerWert + mittelwert * wichtungAlterWert; + } else { + mittelwert = wert; + istMittelwertGesetzt = true; + } + return mittelwert; + }} diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/RingPuffer.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/RingPuffer.java new file mode 100644 index 0000000..bd5d7cc --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/RingPuffer.java @@ -0,0 +1,38 @@ +package com.example.greenwatch.sensors.MicrofonHelperClasses; + +public 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 short maximum() { + short max = 0; + for (int i = 0; i < anzahlEnthaltenerDaten; i++) { + if (puffer[i] > max) { + max = puffer[i]; + } + } + return max; + } +} diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/Verarbeitungsergebnis.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/Verarbeitungsergebnis.java new file mode 100644 index 0000000..672773d --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonHelperClasses/Verarbeitungsergebnis.java @@ -0,0 +1,37 @@ +package com.example.greenwatch.sensors.MicrofonHelperClasses; + +public class Verarbeitungsergebnis { + private String status; + private short maxAmp; + private float db; + // + public Verarbeitungsergebnis(String status, short maxAmp, int db) { + this.status = status; + this.maxAmp = maxAmp; + this.db = db; + } + + public String getStatus() { + return status; + } + + public void setStatus(String status) { + this.status = status; + } + + public short getMaxAmp() { + return maxAmp; + } + + public void setMaxAmp(short maxAmp) { + this.maxAmp = maxAmp; + } + + public float getDB() { + return db; + } + + public void setDB(float db) { + this.db = db; + } +} diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java new file mode 100644 index 0000000..8f1270d --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java @@ -0,0 +1,202 @@ +package com.example.greenwatch.sensors; + +import android.media.AudioFormat; +import android.media.AudioRecord; +import android.media.MediaRecorder; +import android.os.AsyncTask; + +import androidx.lifecycle.MutableLiveData; + +import com.example.greenwatch.sensors.MicrofonHelperClasses.GleitenderMittelwert; +import com.example.greenwatch.sensors.MicrofonHelperClasses.RingPuffer; +import com.example.greenwatch.sensors.MicrofonHelperClasses.Verarbeitungsergebnis; + + public class MicrofonSensor { + + private MutableLiveData mMicrofonAlarmDetected = new MutableLiveData<>(); + private AufnahmeTask aufnahmeTask; + private static MicrofonSensor microfonSensorInstance; + private boolean microfonAlarmDetected = false; + private boolean kalibrierung_do = true; + private float threshold = 40; + private float sensitivity = 5; + + private float amplitudeInDB = 0; + + private RingPuffer ringPuffer = new RingPuffer(10); + + private MicrofonSensor() { + } + + public static synchronized MicrofonSensor getInstance() { + if (microfonSensorInstance == null){ + microfonSensorInstance = new MicrofonSensor(); + } + return microfonSensorInstance; + } + + public void start() { + aufnahmeTask = new AufnahmeTask(); + aufnahmeTask.execute(); + } + + public void stop() { + if(aufnahmeTask !=null) { + aufnahmeTask.cancel(true); + aufnahmeTask = null; + } + } + + public void doRecalibration() { + stop(); + microfonAlarmDetected = false; + kalibrierung_do = true; + threshold = 40; + sensitivity = 5; + amplitudeInDB = 0; + start(); + } + + public float getAmplitudeInDB() { + return amplitudeInDB; + } + + private void setAmplitudeInDB(float amplitudeInDB) { + this.amplitudeInDB = amplitudeInDB; + } + + public MutableLiveData getAccelerometerAlarmDetected() { + setMutableLiveDataMicrofonAlarmDetected(); + return mMicrofonAlarmDetected; + } + + private void setMutableLiveDataMicrofonAlarmDetected() { + mMicrofonAlarmDetected.setValue(microfonAlarmDetected); + } + + class AufnahmeTask extends AsyncTask { + 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; + public AufnahmeTask() { + minPufferGroesseInBytes = AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat); + pufferGroesseInBytes = minPufferGroesseInBytes * 2; + recorder = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleRateInHz, channelConfig, audioFormat, pufferGroesseInBytes); + } + public float kalibrieren(short[] puffer){ + try { + Thread.sleep(3000); + + } catch (InterruptedException e) { + e.printStackTrace(); + } + int anzahlIterationen = 100; + float sum = 0.0f; + for(int i = 0; i < anzahlIterationen; i++){ + int z = recorder.read(puffer, 0, puffer.length); + Verarbeitungsergebnis kalibrierung = verarbeiten(puffer, z); + sum += kalibrierung.getDB(); + } + return sum/anzahlIterationen; + } + + public void Detektion(Verarbeitungsergebnis ergebnis){ + if(ergebnis.getDB() >= (threshold+sensitivity)){ + microfonAlarmDetected = true; + } + else if (ergebnis.getDB() <= (threshold)) { + microfonAlarmDetected = false; + } + } + + @Override + protected Void doInBackground(Long... params) { + + recorder.startRecording(); + short[] puffer = new short[pufferGroesseInBytes / 2]; + GleitenderMittelwert gleitenderMittelwertdB = new GleitenderMittelwert(0.2f); + float db = 0.0f; + + //kalibrierung + if(kalibrierung_do){ + threshold = kalibrieren(puffer); + kalibrierung_do = false; + } + + + for (; ; ) { + if (isCancelled()) { + break; + } + else { + //ergebnis ermitteln + int n = recorder.read(puffer, 0, puffer.length); + Verarbeitungsergebnis ergebnis = verarbeiten(puffer, n); + + //Mittelwertberechnnung + db = ergebnis.getDB(); + db = gleitenderMittelwertdB.mittel(db); + ergebnis.setDB(db); + + //Db Wert mit Schwellwert vergleichen und Warnung setzen + Detektion(ergebnis); + 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; + int db = 0, db_wert = 0; + + 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(); + } + //Umwandlung Amplitudenwert in dB + db_wert = (int) (20*Math.log10(maxAmp)); + if (db_wert > 0){ + db = db_wert; + } + + + return new Verarbeitungsergebnis(status, maxAmp, db); + } + @Override + protected void onProgressUpdate(Verarbeitungsergebnis... progress) { + super.onProgressUpdate(progress); + + setAmplitudeInDB(progress[0].getDB()); + + if (microfonAlarmDetected != mMicrofonAlarmDetected.getValue()){ + setMutableLiveDataMicrofonAlarmDetected(); + } + //textViewMaxAmpdb.setText("" + progress[0].db); + } + + } +} + diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index 344480f..bc8fcff 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -11,7 +11,6 @@ import com.example.greenwatch.sensors.AccelerometerSensor; import java.util.List; public class AccelerometerViewModel extends ViewModel implements ViewModelInterface { - private MutableLiveData> mDeviceList; private MutableLiveData mAccelerometerAlarmDetected; private MutableLiveData> mAlarmHistoryList; diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index 8f74ef1..a4446db 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -1,5 +1,6 @@ package com.example.greenwatch.viewmodels; +import android.Manifest; import android.app.Activity; import android.content.Context; import android.content.pm.PackageManager; @@ -23,6 +24,7 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa private MutableLiveData mStartAlarmRecording; private DeviceRepository mDeviceRepository; private static final int RIGHTS_REQUEST_CAMERA = 10; + private static final int RIGHTS_REQUEST_CAMERA_MICROFON = 1; @Override public void init() { @@ -41,6 +43,14 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); } + public boolean isMicrofonAccessAllowed(Context context) { + return ContextCompat.checkSelfPermission(context, android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED; + } + + public void accessRequestMicrofon(Activity activity) { + ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.RECORD_AUDIO}, RIGHTS_REQUEST_CAMERA_MICROFON); + } + public boolean isCameraAccessAllowed(Context context) { return ContextCompat.checkSelfPermission(context, android.Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED; } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java new file mode 100644 index 0000000..1a48e53 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java @@ -0,0 +1,142 @@ +package com.example.greenwatch.viewmodels; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.MicrofonSensor; + +import java.util.List; + +public class MicrofonViewModel extends ViewModel implements ViewModelInterface { + private MutableLiveData> mDeviceList; + private MutableLiveData mMicrofonAlarmDetected; + private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; + private MicrofonSensor mMicrofonSensor; + private DeviceRepository mDeviceRepository; + + @Override + public void init() { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mMicrofonSensor == null) { + mMicrofonSensor = MicrofonSensor.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } + if (mMicrofonAlarmDetected == null) { + mMicrofonAlarmDetected = mMicrofonSensor.getAccelerometerAlarmDetected(); + } + } + + public void startMicrofonSensor() { + mMicrofonSensor.start(); + } + + public void stopMicrofonSensor() { + mMicrofonSensor.stop(); + } + + public void recalibrationMicrofonSensor() { + mMicrofonSensor.doRecalibration(); + } + + public float getAmplitudeInDB() { + return mMicrofonSensor.getAmplitudeInDB(); + } + + public LiveData getMicrofonAlarmDetected() { + return mMicrofonAlarmDetected; + } + + @Override + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + @Override + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + + @Override + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } + + @Override + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + @Override + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + @Override + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + @Override + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + @Override + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + @Override + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + @Override + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + @Override + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + @Override + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } +} diff --git a/app/src/main/res/layout/activity_audiodetection.xml b/app/src/main/res/layout/activity_audiodetection.xml index 12ffd4a..95ca5e4 100644 --- a/app/src/main/res/layout/activity_audiodetection.xml +++ b/app/src/main/res/layout/activity_audiodetection.xml @@ -12,7 +12,7 @@ android:id="@+id/tvAudiodetectionStatusmessage" android:layout_width="match_parent" android:layout_height="wrap_content" - android:text="Audiodetection Activity"> + android:text=""> + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 5d7b949e5434b60c43f40af7b4a91560930894fa Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 21 Jun 2023 17:29:15 +0200 Subject: [PATCH 23/34] Add Microfon and Accelerometer Aktivity to Project --- ...udiodetectionAndAccelerometerActivity.java | 136 ++++++++++- .../com/example/greenwatch/MainActivity.java | 10 +- ...diodetectionAndAccelerometerViewModel.java | 226 ++++++++++++++++++ ...ivity_audiodetection_and_accelerometer.xml | 23 ++ 4 files changed, 390 insertions(+), 5 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index b05e773..fbe13d5 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -1,13 +1,34 @@ package com.example.greenwatch; import androidx.appcompat.app.AppCompatActivity; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; import android.os.Bundle; import android.view.View; import android.widget.Button; +import android.widget.TextView; +import android.widget.Toast; -public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity { +import com.example.greenwatch.adapters.AlarmHistoryListAdapter; +import com.example.greenwatch.adapters.DeviceListAdapter; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.viewmodels.AudiodetectionAndAccelerometerViewModel; +import com.example.greenwatch.viewmodels.VideodetectionAndAccelerometerViewModel; +import java.util.List; + +public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity implements SensorEventListener { + private SensorManager accelerometerManager; + private Sensor accelerometerSensor; + private TextView audiodetectionAndAccelerometerStatusMessage; + private AudiodetectionAndAccelerometerViewModel mAudiodetectionAndAccelerometerViewModel; private Button backToMainActivity; @Override @@ -15,13 +36,126 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity { super.onCreate(savedInstanceState); setContentView(R.layout.activity_audiodetection_and_accelerometer); + audiodetectionAndAccelerometerStatusMessage = (TextView) findViewById(R.id.tvAudiodetectionAndAccelerometerStatusmessage); backToMainActivity = (Button) findViewById(R.id.audiodetectionAndAccelerometerBackToMainActivity); + RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + recyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new DeviceListAdapter(); + recyclerView.setAdapter(deviceListAdapter); + + RecyclerView alarmHistoryListRecyclerView = findViewById(R.id.alarmHistoryListRecyclerView); + alarmHistoryListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + alarmHistoryListRecyclerView.setHasFixedSize(true); + + final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); + alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + backToMainActivity.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { finish(); } }); + + mAudiodetectionAndAccelerometerViewModel = new ViewModelProvider(this).get(AudiodetectionAndAccelerometerViewModel.class); + mAudiodetectionAndAccelerometerViewModel.init(); + mAudiodetectionAndAccelerometerViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mAudiodetectionAndAccelerometerViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mAudiodetectionAndAccelerometerViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + } + else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + mAudiodetectionAndAccelerometerViewModel.getAudiodetectionAndAccelerometerAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + } + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Microfon", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + } + } + else { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0); + } + + } + }); + + accelerometerManager = (SensorManager) getSystemService(SENSOR_SERVICE); + if (accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).size() == 0) { + accelerometerSensor = null; + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "No accelerometer sensor available", Toast.LENGTH_LONG).show(); + } + else { + accelerometerSensor = accelerometerManager.getSensorList(Sensor.TYPE_GYROSCOPE).get(0); + } + } + + @Override + public void onSensorChanged(SensorEvent event) { + StringBuilder sb = new StringBuilder(); + sb.append("x=") + .append(event.values[0]) + .append("\ny=") + .append(event.values[1]) + .append("\nz=") + .append(event.values[2]); + audiodetectionAndAccelerometerStatusMessage.setText(sb.toString()); + mAudiodetectionAndAccelerometerViewModel.addValueToGesamtBE(event.values[0] + event.values[1] + event.values[2]); + mAudiodetectionAndAccelerometerViewModel.meanValueCalculation(); + mAudiodetectionAndAccelerometerViewModel.calibrateAccelerometerSensor(); + mAudiodetectionAndAccelerometerViewModel.checkAlarmCondition(); + } + + @Override + public void onAccuracyChanged(Sensor sensor, int accuracy) { + + } + + @Override + protected void onResume() { + super.onResume(); + mAudiodetectionAndAccelerometerViewModel.startMicrofonSensor(); + if (accelerometerSensor != null) { + if (accelerometerManager.registerListener(this, accelerometerSensor, SensorManager.SENSOR_DELAY_GAME)) { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "We registered to the sensor", Toast.LENGTH_LONG).show(); + } else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Registration did not work", Toast.LENGTH_LONG).show(); + } + } + } + + @Override + protected void onPause() { + super.onPause(); + mAudiodetectionAndAccelerometerViewModel.stopMicrofonSensor(); + if (accelerometerSensor != null) { + accelerometerManager.unregisterListener(this, accelerometerSensor); + } } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index d878ff7..43a534b 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -117,10 +117,12 @@ public class MainActivity extends AppCompatActivity { audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - //openAudiodetectionAndAccelerometerActivity(); - mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "AudiodetectionAndAccelerometer"); - mMainActivityViewModel.setTimeStamp(mMainActivityViewModel.getLocalDeviceUUID(), "00:00"); - mMainActivityViewModel.setDeviceID(mMainActivityViewModel.getLocalDeviceUUID(), "6789"); + if (mMainActivityViewModel.isMicrofonAccessAllowed(MainActivity.this)) { + openAudiodetectionAndAccelerometerActivity(); + } + else { + mMainActivityViewModel.accessRequestMicrofon(MainActivity.this); + } } }); videodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java new file mode 100644 index 0000000..628c17d --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java @@ -0,0 +1,226 @@ +package com.example.greenwatch.viewmodels; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.AccelerometerSensor; +import com.example.greenwatch.sensors.MicrofonSensor; + +import java.util.List; + +public class AudiodetectionAndAccelerometerViewModel extends ViewModel implements ViewModelInterface { + private MutableLiveData> mDeviceList; + private MutableLiveData mAccelerometerAlarmDetected; + private MutableLiveData mMicrofonAlarmDetected; + private MutableLiveData mAudiodetectionAndAccelerometerAlarmDetected = new MutableLiveData<>(); + private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; + private AccelerometerSensor mAccelerometerSensor; + private MicrofonSensor mMicrofonSensor; + private DeviceRepository mDeviceRepository; + private boolean microfonAlarmDetected; + private boolean accelerometerAlarmDetected; + private boolean microfondetectionAndAccelerometerAlarmDetected; + + @Override + public void init() { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mMicrofonSensor == null) { + mMicrofonSensor = MicrofonSensor.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } + if (mAccelerometerAlarmDetected == null) { + mAccelerometerAlarmDetected = mAccelerometerSensor.getAccelerometerAlarmDetected(); + } + if (mMicrofonAlarmDetected == null) { + mMicrofonAlarmDetected = mMicrofonSensor.getAccelerometerAlarmDetected(); + } + microfondetectionAndAccelerometerAlarmDetected = false; + accelerometerAlarmDetected = false; + microfonAlarmDetected = false; + registerAlarmObserver(); + } + + public void addValueToGesamtBE(float newValue) { + mAccelerometerSensor.addValueToGesamtBE(newValue); + } + + public void meanValueCalculation() { + mAccelerometerSensor.meanValueCalculation(); + } + + public void calibrateAccelerometerSensor() { + mAccelerometerSensor.calibrateAccelerometerSensor(); + } + + public void checkAlarmCondition() { + mAccelerometerSensor.checkAlarmCondition(); + } + + public LiveData getAudiodetectionAndAccelerometerAlarmDetected() { + setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); + return mAudiodetectionAndAccelerometerAlarmDetected; + } + + public void startMicrofonSensor() { + mMicrofonSensor.start(); + } + + public void stopMicrofonSensor() { + mMicrofonSensor.stop(); + } + + public void recalibrationMicrofonSensor() { + mMicrofonSensor.doRecalibration(); + } + + public float getAmplitudeInDB() { + return mMicrofonSensor.getAmplitudeInDB(); + } + + private void setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected() { + mAudiodetectionAndAccelerometerAlarmDetected.setValue(microfondetectionAndAccelerometerAlarmDetected); + } + + private void setAccelerometerAlarmDetected(boolean accelerometerAlarmDetected) { + this.accelerometerAlarmDetected = accelerometerAlarmDetected; + } + + public boolean getAccelerometerAlarmDetected() { + return accelerometerAlarmDetected; + } + + private void setMicrofonAlarmDetected(boolean microfonAlarmDetected) { + this.microfonAlarmDetected = microfonAlarmDetected; + } + + public boolean getMicrofonAlarmDetected() { + return microfonAlarmDetected; + } + + Observer observer = new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + setAccelerometerAlarmDetected(mAccelerometerAlarmDetected.getValue()); + setMicrofonAlarmDetected(mMicrofonAlarmDetected.getValue()); + if (microfonAlarmDetected || accelerometerAlarmDetected && !microfondetectionAndAccelerometerAlarmDetected) { + microfondetectionAndAccelerometerAlarmDetected = true; + setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); + + } + else if (!microfonAlarmDetected && !accelerometerAlarmDetected && microfondetectionAndAccelerometerAlarmDetected) { + microfondetectionAndAccelerometerAlarmDetected = false; + setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); + } + } + }; + + private void registerAlarmObserver() { + mMicrofonAlarmDetected.observeForever(observer); + mAccelerometerAlarmDetected.observeForever(observer); + } + + @Override + protected void onCleared() { + super.onCleared(); + mMicrofonAlarmDetected.removeObserver(observer); + mAccelerometerAlarmDetected.removeObserver(observer); + } + + @Override + public LiveData> getConnectedDeviceList() { + return mDeviceList; + } + + @Override + public LiveData> getAlarmHistoryList() { + return mAlarmHistoryList; + } + + @Override + public LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + + @Override + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } + + @Override + public void setTimeStamp(String deviceID, String timeStamp) { + mDeviceRepository.setTimeStamp(deviceID, timeStamp); + } + + @Override + public String getTimeStamp(String deviceID) { + return mDeviceRepository.getTimeStamp(deviceID); + } + + @Override + public void setDeviceID(String deviceID, String newDeviceID) { + mDeviceRepository.setDeviceID(deviceID, newDeviceID); + } + + @Override + public String getDeviceID(String deviceID) { + return mDeviceRepository.getDeviceID(deviceID); + } + + @Override + public void setSensorStatus(String deviceID, boolean sensorStatus) { + mDeviceRepository.setSensorStatus(deviceID, sensorStatus); + } + + @Override + public boolean getSensorStatus(String deviceID) { + return mDeviceRepository.getSensorStatus(deviceID); + } + + @Override + public void setSensorType(String deviceID, String sensorType) { + mDeviceRepository.setSensorType(deviceID, sensorType); + } + + @Override + public String getSensorType(String deviceID) { + return mDeviceRepository.getSensorType(deviceID); + } + + @Override + public void setSensorMassage(String deviceID, int sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public int getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } +} diff --git a/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml b/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml index b6f4599..4ecd973 100644 --- a/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml +++ b/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml @@ -22,4 +22,27 @@ android:text="Back to MainActivity"> + + + + + + + + + + \ No newline at end of file -- 2.47.2 From 97c3d2c937b098ea50f2bf9de2961cf7092ba8ed Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 21 Jun 2023 17:47:32 +0200 Subject: [PATCH 24/34] Improved Video and Accelerometer detection in Project --- ...ideodetectionAndAccelerometerActivity.java | 13 ++- .../greenwatch/sensors/CameraSensor.java | 86 ++++++++++++++++--- ...deodetectionAndAccelerometerViewModel.java | 36 ++++++-- 3 files changed, 113 insertions(+), 22 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java index f6118dd..3cbdfa5 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -101,12 +101,19 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + } + else if (mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Video", 10); + } + else if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "2VideoAndAccelerometer", 10); + } } else { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0); + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0); } - } }); diff --git a/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java index 47cd07f..c238df8 100644 --- a/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java +++ b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java @@ -3,6 +3,7 @@ package com.example.greenwatch.sensors; import android.content.Context; import android.graphics.ImageFormat; import android.media.Image; +import android.os.Handler; import android.util.Size; import androidx.camera.core.CameraSelector; @@ -18,9 +19,18 @@ public class CameraSensor { private final MutableLiveData mVideoAlarmDetected = new MutableLiveData<>(); private static CameraSensor cameraSensorInstance; private boolean videoAlarmDetected; + private boolean isMotionDetected; private ByteBuffer previousBuffer; private int previousWidth; private int previousHeight; + private final int threshold = 50; + private int startX; + private int startY; + private int endX; + private int endY; + private static final long ALARM_RESET_DELAY = 5000; + private Runnable alarmResetRunnable; + private final Handler alarmResetHandler = new Handler(); private CameraSensor() { videoAlarmDetected = false; @@ -59,7 +69,7 @@ public class CameraSensor { if (previousHeight != 0) { assert currentImage != null; - videoAlarmDetected = compareFrames(currentImage); + isMotionDetected = compareFrames(currentImage); } assert currentImage != null; @@ -72,6 +82,18 @@ public class CameraSensor { currentImage.close(); + if (isMotionDetected) { + + videoAlarmDetected = true; + + if(alarmResetRunnable != null) { + alarmResetHandler.removeCallbacks(alarmResetRunnable); + } + + alarmResetRunnable = this::resetAlarmStatus; + alarmResetHandler.postDelayed(alarmResetRunnable, ALARM_RESET_DELAY); + } + checkAlarmCondition(); } @@ -85,36 +107,76 @@ public class CameraSensor { } private boolean compareFrames(Image currentImage) { - - ByteBuffer currentBuffer = currentImage.getPlanes()[0].getBuffer(); - + Image.Plane[] planes = currentImage.getPlanes(); + ByteBuffer currentBuffer = planes[0].getBuffer(); int currentWidth = currentImage.getWidth(); int currentHeight = currentImage.getHeight(); + int yRowStride = planes[0].getRowStride(); + int yPixelStride = planes[0].getPixelStride(); if (previousWidth != currentWidth || previousHeight != currentHeight) { return false; } - for (int row = 0; row < previousHeight; row++) { - for (int col = 0; col < previousWidth; col++) { + int blockSize = kleinstesQuadrat(previousHeight, previousWidth) / 8; - int previousIndex = row * previousWidth + col; - int currentIndex = row * currentWidth + col; + int numBlocksX = currentWidth / blockSize; + int numBlocksY = currentHeight / blockSize; - int previousPixel = previousBuffer.get(previousIndex) & 0xFF; - int currentPixel = currentBuffer.get(currentIndex) & 0xFF; + for (int blockY = 0; blockY < numBlocksY; blockY++) { + for (int blockX = 0; blockX < numBlocksX; blockX++) { + startX = blockX * blockSize; + startY = blockY * blockSize; + endX = startX + blockSize; + endY = startY + blockSize; - int pixelDifference = Math.abs(previousPixel - currentPixel); - int threshold = 120; + float currentLuminance = berechneMittlereLuminanz(currentBuffer, yRowStride, yPixelStride); + float previousLuminance = berechneMittlereLuminanz(previousBuffer, yRowStride, yPixelStride); + + int pixelDifference = Math.abs((int) previousLuminance - (int) currentLuminance); if (pixelDifference > threshold) { + System.out.println(pixelDifference); return true; } } } + return false; } + private float berechneMittlereLuminanz(ByteBuffer buffer, int rowStride, int pixelStride) { + int sumLuminance = 0; + int countPixels = 0; + + for (int row = startY; row < endY; row++) { + for (int col = startX; col < endX; col++) { + int bufferIndex = row * rowStride + col * pixelStride; + int currentPixel = buffer.get(bufferIndex) & 0xFF; + + sumLuminance += currentPixel; + countPixels++; + } + } + + return (float) sumLuminance / countPixels; + } + + private int kleinstesQuadrat(int height, int width) { + if (height == width) { + return height; + } else if (height > width) { + return kleinstesQuadrat(height - width, width); + } else { + return kleinstesQuadrat(height, width - height); + } + } + + private void resetAlarmStatus() { + videoAlarmDetected = false; + alarmResetRunnable = null; + } + public void checkAlarmCondition() { if (videoAlarmDetected && !mVideoAlarmDetected.getValue()) { setMutableLiveDataVideoAlarmDetected(); diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java index 79d7500..ac290a8 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java @@ -26,7 +26,9 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement private AccelerometerSensor mAccelerometerSensor; private CameraSensor mCameraSensor; private DeviceRepository mDeviceRepository; - private boolean VideodetectionAndAccelerometerAlarmDetected; + private boolean videoAlarmDetected; + private boolean accelerometerAlarmDetected; + private boolean videodetectionAndAccelerometerAlarmDetected; @Override public void init() { @@ -54,7 +56,9 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement if (mVideoAlarmDetected == null) { mVideoAlarmDetected = mCameraSensor.getVideoAlarmDetectedValue(); } - VideodetectionAndAccelerometerAlarmDetected = false; + videodetectionAndAccelerometerAlarmDetected = false; + videoAlarmDetected = false; + accelerometerAlarmDetected = false; registerAlarmObserver(); } @@ -84,19 +88,37 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement } private void setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected() { - mVideodetectionAndAccelerometerAlarmDetected.setValue(VideodetectionAndAccelerometerAlarmDetected); + mVideodetectionAndAccelerometerAlarmDetected.setValue(videodetectionAndAccelerometerAlarmDetected); + } + + private void setAccelerometerAlarmDetected(boolean accelerometerAlarmDetected) { + this.accelerometerAlarmDetected = accelerometerAlarmDetected; + } + + public boolean getAccelerometerAlarmDetected() { + return accelerometerAlarmDetected; + } + + private void setVideoAlarmDetected(boolean videoAlarmDetected) { + this.videoAlarmDetected = videoAlarmDetected; + } + + public boolean getVideoAlarmDetected() { + return videoAlarmDetected; } Observer observer = new Observer() { @Override public void onChanged(Boolean aBoolean) { - if (mVideoAlarmDetected.getValue() || mAccelerometerAlarmDetected.getValue() && !VideodetectionAndAccelerometerAlarmDetected) { - VideodetectionAndAccelerometerAlarmDetected = true; + setAccelerometerAlarmDetected(mAccelerometerAlarmDetected.getValue()); + setVideoAlarmDetected(mVideoAlarmDetected.getValue()); + if (videoAlarmDetected || accelerometerAlarmDetected && !videodetectionAndAccelerometerAlarmDetected) { + videodetectionAndAccelerometerAlarmDetected = true; setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); } - else if (!mVideoAlarmDetected.getValue() && !mAccelerometerAlarmDetected.getValue() && VideodetectionAndAccelerometerAlarmDetected) { - VideodetectionAndAccelerometerAlarmDetected = false; + else if (!videoAlarmDetected && !accelerometerAlarmDetected && videodetectionAndAccelerometerAlarmDetected) { + videodetectionAndAccelerometerAlarmDetected = false; setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); } } -- 2.47.2 From 74f0fdb798e54f68101199860a24e9b4d86afac3 Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 21 Jun 2023 18:40:49 +0200 Subject: [PATCH 25/34] Improved Microfon and Accelerometer detection in Project --- .../example/greenwatch/AudiodetectionActivity.java | 3 +++ .../AudiodetectionAndAccelerometerActivity.java | 11 ++++++++--- .../example/greenwatch/sensors/MicrofonSensor.java | 5 ++--- .../AudiodetectionAndAccelerometerViewModel.java | 4 ++-- 4 files changed, 15 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index a4b0f80..175df5c 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -106,6 +106,9 @@ public class AudiodetectionActivity extends AppCompatActivity { @Override protected void onPause() { super.onPause(); + if (isFinishing()){ + mMicrofonViewModel.recalibrationMicrofonSensor(); + } mMicrofonViewModel.stopMicrofonSensor(); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index fbe13d5..0aa04af 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -92,14 +92,19 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedTrue", Toast.LENGTH_LONG).show(); + if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); } - else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Microfon", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Audio", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + } + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "2AudioAndAccelerometer", 10); } } else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedFalse", Toast.LENGTH_LONG).show(); mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0); } diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java index 8f1270d..40b78c9 100644 --- a/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java @@ -19,7 +19,7 @@ import com.example.greenwatch.sensors.MicrofonHelperClasses.Verarbeitungsergebni private boolean microfonAlarmDetected = false; private boolean kalibrierung_do = true; private float threshold = 40; - private float sensitivity = 5; + private float sensitivity = 10; private float amplitudeInDB = 0; @@ -52,9 +52,8 @@ import com.example.greenwatch.sensors.MicrofonHelperClasses.Verarbeitungsergebni microfonAlarmDetected = false; kalibrierung_do = true; threshold = 40; - sensitivity = 5; + sensitivity = 10; amplitudeInDB = 0; - start(); } public float getAmplitudeInDB() { diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java index 628c17d..074ba2f 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java @@ -120,12 +120,12 @@ public class AudiodetectionAndAccelerometerViewModel extends ViewModel implement public void onChanged(Boolean aBoolean) { setAccelerometerAlarmDetected(mAccelerometerAlarmDetected.getValue()); setMicrofonAlarmDetected(mMicrofonAlarmDetected.getValue()); - if (microfonAlarmDetected || accelerometerAlarmDetected && !microfondetectionAndAccelerometerAlarmDetected) { + if (microfonAlarmDetected || accelerometerAlarmDetected) { microfondetectionAndAccelerometerAlarmDetected = true; setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); } - else if (!microfonAlarmDetected && !accelerometerAlarmDetected && microfondetectionAndAccelerometerAlarmDetected) { + else if (!microfonAlarmDetected && !accelerometerAlarmDetected) { microfondetectionAndAccelerometerAlarmDetected = false; setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); } -- 2.47.2 From cb425cce5658a01cc83a1559fb03750e9d9bc1aa Mon Sep 17 00:00:00 2001 From: Christian Date: Wed, 21 Jun 2023 18:40:49 +0200 Subject: [PATCH 26/34] Improved Microfon and Accelerometer detection in Project --- .../example/greenwatch/AudiodetectionActivity.java | 3 +++ .../AudiodetectionAndAccelerometerActivity.java | 14 +++++++++++--- .../example/greenwatch/sensors/MicrofonSensor.java | 5 ++--- .../AudiodetectionAndAccelerometerViewModel.java | 4 ++-- 4 files changed, 18 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index a4b0f80..175df5c 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -106,6 +106,9 @@ public class AudiodetectionActivity extends AppCompatActivity { @Override protected void onPause() { super.onPause(); + if (isFinishing()){ + mMicrofonViewModel.recalibrationMicrofonSensor(); + } mMicrofonViewModel.stopMicrofonSensor(); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index fbe13d5..56d26a2 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -92,14 +92,19 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedTrue", Toast.LENGTH_LONG).show(); + if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); } - else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Microfon", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Audio", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + } + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "2AudioAndAccelerometer", 10); } } else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedFalse", Toast.LENGTH_LONG).show(); mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0); } @@ -153,6 +158,9 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im @Override protected void onPause() { super.onPause(); + if (isFinishing()){ + mAudiodetectionAndAccelerometerViewModel.recalibrationMicrofonSensor(); + } mAudiodetectionAndAccelerometerViewModel.stopMicrofonSensor(); if (accelerometerSensor != null) { accelerometerManager.unregisterListener(this, accelerometerSensor); diff --git a/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java index 8f1270d..40b78c9 100644 --- a/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java @@ -19,7 +19,7 @@ import com.example.greenwatch.sensors.MicrofonHelperClasses.Verarbeitungsergebni private boolean microfonAlarmDetected = false; private boolean kalibrierung_do = true; private float threshold = 40; - private float sensitivity = 5; + private float sensitivity = 10; private float amplitudeInDB = 0; @@ -52,9 +52,8 @@ import com.example.greenwatch.sensors.MicrofonHelperClasses.Verarbeitungsergebni microfonAlarmDetected = false; kalibrierung_do = true; threshold = 40; - sensitivity = 5; + sensitivity = 10; amplitudeInDB = 0; - start(); } public float getAmplitudeInDB() { diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java index 628c17d..074ba2f 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java @@ -120,12 +120,12 @@ public class AudiodetectionAndAccelerometerViewModel extends ViewModel implement public void onChanged(Boolean aBoolean) { setAccelerometerAlarmDetected(mAccelerometerAlarmDetected.getValue()); setMicrofonAlarmDetected(mMicrofonAlarmDetected.getValue()); - if (microfonAlarmDetected || accelerometerAlarmDetected && !microfondetectionAndAccelerometerAlarmDetected) { + if (microfonAlarmDetected || accelerometerAlarmDetected) { microfondetectionAndAccelerometerAlarmDetected = true; setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); } - else if (!microfonAlarmDetected && !accelerometerAlarmDetected && microfondetectionAndAccelerometerAlarmDetected) { + else if (!microfonAlarmDetected && !accelerometerAlarmDetected) { microfondetectionAndAccelerometerAlarmDetected = false; setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); } -- 2.47.2 From c6d33925beb15f74cad61226338619e958568646 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 22 Jun 2023 00:00:09 +0200 Subject: [PATCH 27/34] adapted SensorMessage Type to float --- .../com/example/greenwatch/AccelerometerActivity.java | 4 ++-- .../com/example/greenwatch/AudiodetectionActivity.java | 4 ++-- .../AudiodetectionAndAccelerometerActivity.java | 6 +++--- .../VideodetectionAndAccelerometerActivity.java | 8 ++++---- .../java/com/example/greenwatch/models/Device.java | 8 ++++---- .../greenwatch/repositories/DeviceRepository.java | 10 +++++----- .../greenwatch/sensors/AccelerometerSensor.java | 4 ++++ .../greenwatch/viewmodels/AccelerometerViewModel.java | 10 +++++++--- .../AudiodetectionAndAccelerometerViewModel.java | 10 +++++++--- .../greenwatch/viewmodels/MainActivityViewModel.java | 6 +++--- .../greenwatch/viewmodels/MicrofonViewModel.java | 6 +++--- .../VideodetectionAndAccelerometerViewModel.java | 10 +++++++--- .../greenwatch/viewmodels/VideodetectionViewModel.java | 6 +++--- .../greenwatch/viewmodels/ViewModelInterface.java | 6 +++--- app/src/main/res/values/strings.xml | 2 +- 15 files changed, 58 insertions(+), 42 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index ec863b2..2abe196 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -96,10 +96,10 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mAccelerometerViewModel.getAccelerometerSensorMeanValue()); } else { - mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0); + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0.0f); } } diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index 175df5c..cb43329 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -87,10 +87,10 @@ public class AudiodetectionActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Microfon", (int) mMicrofonViewModel.getAmplitudeInDB()); + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Microfon", mMicrofonViewModel.getAmplitudeInDB()); } else { - mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Microfon", (int) mMicrofonViewModel.getAmplitudeInDB()); + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Microfon", mMicrofonViewModel.getAmplitudeInDB()); } } diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index 56d26a2..7b6a4ae 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -94,13 +94,13 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im if (aBoolean) { Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedTrue", Toast.LENGTH_LONG).show(); if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mAudiodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); } else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Audio", (int) mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Audio", mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); } else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "2AudioAndAccelerometer", 10); + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "AudioAndAccelerometer", mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); } } else { diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java index 3cbdfa5..0b0435e 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -102,17 +102,17 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im public void onChanged(Boolean aBoolean) { if (aBoolean) { if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", 10); + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mVideodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); } else if (mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Video", 10); + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Video", 1.0f); } else if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "2VideoAndAccelerometer", 10); + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "VideoAndAccelerometer", mVideodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); } } else { - mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0); + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0.0f); } } }); diff --git a/app/src/main/java/com/example/greenwatch/models/Device.java b/app/src/main/java/com/example/greenwatch/models/Device.java index d9155e9..3a5ef1a 100644 --- a/app/src/main/java/com/example/greenwatch/models/Device.java +++ b/app/src/main/java/com/example/greenwatch/models/Device.java @@ -7,9 +7,9 @@ public class Device { private String deviceID; private boolean sensorStatus; private String sensorType; - private int sensorMassage; + private float sensorMassage; - public Device(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage) { + public Device(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, float sensorMassage) { this.timeStamp = timeStamp; this.deviceID = deviceID; this.sensorStatus = sensorStatus; @@ -47,11 +47,11 @@ public class Device { return sensorStatus; } - public void setSensorMassage(int sensorMassage) { + public void setSensorMassage(float sensorMassage) { this.sensorMassage = sensorMassage; } - public int getSensorMassage() { + public float getSensorMassage() { return sensorMassage; } } diff --git a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java index 6df1250..c601337 100644 --- a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -60,7 +60,7 @@ public class DeviceRepository { return startAlarmRecording; } - public void createNewDevice(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, int sensorMassage){ + public void createNewDevice(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, float sensorMassage){ Device newDevice = new Device(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); if (sensorStatus) { setAlarmHistoryDeviceList(newDevice); @@ -80,7 +80,7 @@ public class DeviceRepository { String deviceID = messageString[1]; boolean sensorStatus = convertSensorStatus(messageString[2]); String sensorType = messageString[3]; - int sensorMassage = Integer.valueOf(messageString[4]); + float sensorMassage = Float.valueOf(messageString[4]); if (deviceID.equals(checkDeviceID(localDeviceUUID))) { return; @@ -126,7 +126,7 @@ public class DeviceRepository { return localDeviceUUID; } - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { String checkedDeviceID = checkDeviceID(deviceID); Device device = connectedDevicesList.get(checkedDeviceID); if(device != null) { @@ -234,7 +234,7 @@ public class DeviceRepository { return ""; } - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { String checkedDeviceID = checkDeviceID(deviceID); Device device = connectedDevicesList.get(checkedDeviceID); if(device != null) { @@ -244,7 +244,7 @@ public class DeviceRepository { } } - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { String checkedDeviceID = checkDeviceID(deviceID); Device device = connectedDevicesList.get(checkedDeviceID); if(device != null) { diff --git a/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java index 70bc6a1..52ad5eb 100644 --- a/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java +++ b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java @@ -82,4 +82,8 @@ public class AccelerometerSensor { mAccelerometerAlarmDetected.setValue(false); } } + + public float getAccelerometerSensorMeanValue() { + return meanValue; + } } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java index bc8fcff..94d1aa4 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -56,6 +56,10 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf mAccelerometerSensor.checkAlarmCondition(); } + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + public LiveData getAccelerometerAlarmDetected() { return mAccelerometerAlarmDetected; } @@ -76,7 +80,7 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -121,12 +125,12 @@ public class AccelerometerViewModel extends ViewModel implements ViewModelInterf } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java index 074ba2f..c5656d5 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java @@ -74,6 +74,10 @@ public class AudiodetectionAndAccelerometerViewModel extends ViewModel implement mAccelerometerSensor.checkAlarmCondition(); } + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + public LiveData getAudiodetectionAndAccelerometerAlarmDetected() { setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); return mAudiodetectionAndAccelerometerAlarmDetected; @@ -160,7 +164,7 @@ public class AudiodetectionAndAccelerometerViewModel extends ViewModel implement } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -205,12 +209,12 @@ public class AudiodetectionAndAccelerometerViewModel extends ViewModel implement } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index a4446db..a737f07 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -75,7 +75,7 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -120,12 +120,12 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java index 1a48e53..b428516 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java @@ -76,7 +76,7 @@ public class MicrofonViewModel extends ViewModel implements ViewModelInterface { } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -121,12 +121,12 @@ public class MicrofonViewModel extends ViewModel implements ViewModelInterface { } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java index ac290a8..2c0de60 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java @@ -78,6 +78,10 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement mAccelerometerSensor.checkAlarmCondition(); } + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + public void bindImageAnalysis(ProcessCameraProvider cameraProvider, LifecycleOwner lifecycleOwner, Context context) { mCameraSensor.bindImageAnalysis(cameraProvider, lifecycleOwner, context); } @@ -152,7 +156,7 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -197,12 +201,12 @@ public class VideodetectionAndAccelerometerViewModel extends ViewModel implement } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java index 1a252c5..71ee0d2 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java @@ -74,7 +74,7 @@ public class VideodetectionViewModel extends ViewModel implements ViewModelInter } @Override - public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage) { + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage) { mDeviceRepository.updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); } @@ -119,12 +119,12 @@ public class VideodetectionViewModel extends ViewModel implements ViewModelInter } @Override - public void setSensorMassage(String deviceID, int sensorMessage) { + public void setSensorMassage(String deviceID, float sensorMessage) { mDeviceRepository.setSensorMassage(deviceID, sensorMessage); } @Override - public int getSensorMassage(String deviceID) { + public float getSensorMassage(String deviceID) { return mDeviceRepository.getSensorMassage(deviceID); } diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java index eb290b4..e9bd65a 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java @@ -11,7 +11,7 @@ public interface ViewModelInterface { LiveData> getConnectedDeviceList(); LiveData> getAlarmHistoryList(); LiveData getStartAlarmRecording(); - void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, int sensorMassage); + void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float sensorMassage); void setTimeStamp(String deviceID, String timeStamp); String getTimeStamp(String deviceID); void setDeviceID(String deviceID, String newDeviceID); @@ -20,8 +20,8 @@ public interface ViewModelInterface { boolean getSensorStatus(String deviceID); void setSensorType(String deviceID, String sensorType); String getSensorType(String deviceID); - void setSensorMassage(String deviceID, int sensorMessage); - int getSensorMassage(String deviceID); + void setSensorMassage(String deviceID, float sensorMessage); + float getSensorMassage(String deviceID); String getLocalDeviceUUID(); String getSystemTimeStamp(); } diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c0c8d74..4bbef69 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -4,5 +4,5 @@ Sensorstatus: %s Sensor-ID: %s Timestamp: %s - Sensormessage: %d + Sensormessage: %f \ No newline at end of file -- 2.47.2 From 14c30a1c808bbcc12a9baf8f7905952aaa19e17e Mon Sep 17 00:00:00 2001 From: nutzma75019 Date: Thu, 22 Jun 2023 00:38:17 +0200 Subject: [PATCH 28/34] Permissions --- app/src/main/AndroidManifest.xml | 2 + .../greenwatch/AccelerometerActivity.java | 14 +- .../greenwatch/AudiodetectionActivity.java | 14 +- ...udiodetectionAndAccelerometerActivity.java | 15 +- .../com/example/greenwatch/MainActivity.java | 47 +++++-- .../com/example/greenwatch/Permission.java | 128 ++++++++++++++++++ .../greenwatch/VideodetectionActivity.java | 14 +- ...ideodetectionAndAccelerometerActivity.java | 14 +- .../viewmodels/MainActivityViewModel.java | 18 --- 9 files changed, 233 insertions(+), 33 deletions(-) create mode 100644 app/src/main/java/com/example/greenwatch/Permission.java diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index e66c2b5..eef709a 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -5,6 +5,8 @@ + + diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index ec863b2..819f05e 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -32,6 +32,7 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv private TextView accelerometerWarningTV; private Button backToMainActivityButton; private AccelerometerViewModel mAccelerometerViewModel; + private Permission permission = new Permission(); @Override protected void onCreate(Bundle savedInstanceState) { @@ -84,7 +85,18 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(AccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(AccelerometerActivity.this, AccelerometerActivity.this)){ + Toast.makeText(AccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(AccelerometerActivity.this); + if(permission.alarmRechtePruefen(AccelerometerActivity.this, AccelerometerActivity.this)){ + Toast.makeText(AccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(AccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(AccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index 175df5c..a4fbe93 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -24,6 +24,7 @@ import java.util.List; public class AudiodetectionActivity extends AppCompatActivity { private TextView microfonStatusMessage; private Button backToMainActivityButton; + private Permission permission = new Permission(); private MicrofonViewModel mMicrofonViewModel; @Override @@ -75,7 +76,18 @@ public class AudiodetectionActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(AudiodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(AudiodetectionActivity.this, AudiodetectionActivity.this)){ + Toast.makeText(AudiodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(AudiodetectionActivity.this); + if(permission.alarmRechtePruefen(AudiodetectionActivity.this, AudiodetectionActivity.this)){ + Toast.makeText(AudiodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(AudiodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(AudiodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index 56d26a2..0185e93 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -31,6 +31,8 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im private AudiodetectionAndAccelerometerViewModel mAudiodetectionAndAccelerometerViewModel; private Button backToMainActivity; + private Permission permission = new Permission(); + @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); @@ -80,7 +82,18 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(AudiodetectionAndAccelerometerActivity.this, AudiodetectionAndAccelerometerActivity.this)){ + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(AudiodetectionAndAccelerometerActivity.this); + if(permission.alarmRechtePruefen(AudiodetectionAndAccelerometerActivity.this, AudiodetectionAndAccelerometerActivity.this)){ + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 43a534b..1cc147a 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -6,6 +6,8 @@ import androidx.lifecycle.ViewModelProvider; import androidx.recyclerview.widget.LinearLayoutManager; import androidx.recyclerview.widget.RecyclerView; +import android.app.Activity; +import android.content.Context; import android.content.Intent; import android.os.Bundle; import android.view.View; @@ -17,6 +19,7 @@ import com.example.greenwatch.adapters.DeviceListAdapter; import com.example.greenwatch.models.Device; import com.example.greenwatch.viewmodels.MainActivityViewModel; + import java.util.List; public class MainActivity extends AppCompatActivity { @@ -28,12 +31,19 @@ public class MainActivity extends AppCompatActivity { private Button videodetectionAndAccelerometerButton; private Button connectionButton; private MainActivityViewModel mMainActivityViewModel; + private Permission permission = new Permission(); + + private Activity activity = new Activity(); + private Context context; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); + activity = MainActivity.this; + context = MainActivity.this; + audiodetectionButton = (Button) findViewById(R.id.audiodetectionButton); videodetectionButton = (Button) findViewById(R.id.videodetectionButton); accelerometerButton = (Button) findViewById(R.id.accelerometerButton); @@ -55,10 +65,10 @@ public class MainActivity extends AppCompatActivity { final AlarmHistoryListAdapter alarmHistoryListAdapter = new AlarmHistoryListAdapter(); alarmHistoryListRecyclerView.setAdapter(alarmHistoryListAdapter); + permission.startRechtePruefen(this, this); + mMainActivityViewModel = new ViewModelProvider(this).get(MainActivityViewModel.class); mMainActivityViewModel.init(); - mMainActivityViewModel.accessRequestCamera(this); - mMainActivityViewModel.accessRequestMicrofon(this); mMainActivityViewModel.getConnectedDeviceList().observe(this, new Observer>() { @Override public void onChanged(List devices) { @@ -77,7 +87,18 @@ public class MainActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(context, activity)){ + Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(activity); + if(permission.alarmRechtePruefen(context, activity)){ + Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(MainActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(MainActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); @@ -88,22 +109,23 @@ public class MainActivity extends AppCompatActivity { audiodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - if (mMainActivityViewModel.isMicrofonAccessAllowed(MainActivity.this)) { + + if (permission.microRechtePruefen(context, activity)) { openAudiodetectionActivity(); } else { - mMainActivityViewModel.accessRequestMicrofon(MainActivity.this); + permission.microRechteAnfordern(activity); } } }); videodetectionButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - if (mMainActivityViewModel.isCameraAccessAllowed(MainActivity.this)) { + if (permission.kameraRechtePruefen(context, activity)) { openVideodetectionActivity(); } else { - mMainActivityViewModel.accessRequestCamera(MainActivity.this); + permission.kameraRechteAnfordern(activity); } } }); @@ -117,18 +139,23 @@ public class MainActivity extends AppCompatActivity { audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - if (mMainActivityViewModel.isMicrofonAccessAllowed(MainActivity.this)) { + if (permission.microRechtePruefen(context, activity)) { openAudiodetectionAndAccelerometerActivity(); } else { - mMainActivityViewModel.accessRequestMicrofon(MainActivity.this); + permission.microRechteAnfordern(activity); } } }); videodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { - openVideodetectionAndAccelerometerActivity(); + if (permission.kameraRechtePruefen(context, activity)) { + openVideodetectionAndAccelerometerActivity(); + } + else { + permission.kameraRechteAnfordern(activity); + } } }); connectionButton.setOnClickListener(new View.OnClickListener() { diff --git a/app/src/main/java/com/example/greenwatch/Permission.java b/app/src/main/java/com/example/greenwatch/Permission.java new file mode 100644 index 0000000..e7de2f9 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/Permission.java @@ -0,0 +1,128 @@ +package com.example.greenwatch; + +import static android.Manifest.permission.CAMERA; +import static android.Manifest.permission.RECORD_AUDIO; +import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE; +import static android.Manifest.permission.READ_EXTERNAL_STORAGE; + +import static androidx.core.app.ActivityCompat.requestPermissions; +import static androidx.core.content.ContextCompat.checkSelfPermission; + +import android.Manifest; +import android.app.Activity; +import android.content.Context; +import android.content.DialogInterface; +import android.content.pm.PackageManager; +import android.os.Bundle; +import android.util.Log; +import android.view.View; + +import androidx.appcompat.app.AlertDialog; +import androidx.appcompat.app.AppCompatActivity; +import androidx.core.app.ActivityCompat; +import androidx.core.content.ContextCompat; + + + +public class Permission { + private static final int PERMISSION_REQUEST_MICRO = 1; + private static final int PERMISSION_REQUEST_CAMERA = 2; + private static final int PERMISSION_REQUEST_ALARM = 1234; + private static final int PERMISSION_REQUEST_START = 1235; + + public void startRechtePruefen(Context context, Activity activity){ + boolean rechtKamera = checkSelfPermission(context, CAMERA) == PackageManager.PERMISSION_GRANTED; + boolean rechtAudio = checkSelfPermission(context, RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED; + boolean rechtSchreiben = checkSelfPermission(context, WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED; + boolean rechtLesen = checkSelfPermission(context, READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED; + + Log.d("Kamera Rechte", String.valueOf(rechtKamera)); + Log.d("Audio Rechte", String.valueOf(rechtAudio)); + Log.d("Schreib Rechte", String.valueOf(rechtSchreiben)); + Log.d("Lese Rechte", String.valueOf(rechtLesen)); + + if(rechtKamera && rechtAudio && rechtSchreiben && rechtLesen){ + Log.d("Rechte", "erteilt"); + } else { + startRechteAnfordern(activity); + } + } + + public boolean kameraRechtePruefen(Context context, Activity activity){ + boolean rechtKamera = checkSelfPermission(context, CAMERA) == PackageManager.PERMISSION_GRANTED; + Log.d("Kamera Rechte", String.valueOf(rechtKamera)); + + if(rechtKamera){ + Log.d("Kamerarechte", "erteilt"); + return true; + } else { + kameraRechteAnfordern(activity); + if(checkSelfPermission(context, CAMERA) == PackageManager.PERMISSION_GRANTED){ + return true; + } else { + return false; + } + } + } + + public boolean microRechtePruefen(Context context, Activity activity){ + boolean rechtAudio = checkSelfPermission(context, RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED; + Log.d("Audio Rechte", String.valueOf(rechtAudio)); + + if(rechtAudio){ + Log.d("Rechte", "erteilt"); + return true; + } else { + microRechteAnfordern(activity); + if(checkSelfPermission(context, RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED){ + return true; + } else { + return false; + } + } + } + + public boolean alarmRechtePruefen(Context context, Activity activity){ + boolean rechtKamera = checkSelfPermission(context, CAMERA) == PackageManager.PERMISSION_GRANTED; + boolean rechtAudio = checkSelfPermission(context, RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED; + boolean rechtSchreiben = checkSelfPermission(context, WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED; + boolean rechtLesen = checkSelfPermission(context, READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED; + + Log.d("Kamera Rechte", String.valueOf(rechtKamera)); + Log.d("Audio Rechte", String.valueOf(rechtAudio)); + Log.d("Schreib Rechte", String.valueOf(rechtSchreiben)); + Log.d("Lese Rechte", String.valueOf(rechtLesen)); + + if(rechtKamera && rechtAudio && rechtSchreiben && rechtLesen){ + Log.d("Rechte", "erteilt"); + return true; + } else { + alarmRechteAnfordern(activity); + if(checkSelfPermission(context, CAMERA) == PackageManager.PERMISSION_GRANTED + && checkSelfPermission(context, RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED + && checkSelfPermission(context, WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED + && checkSelfPermission(context, READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED){ + return true; + } else { + return false; + } + } + } + + public void startRechteAnfordern(Activity activity){ + ActivityCompat.requestPermissions(activity, new String[]{CAMERA, RECORD_AUDIO, WRITE_EXTERNAL_STORAGE, READ_EXTERNAL_STORAGE}, PERMISSION_REQUEST_START); + } + + public void kameraRechteAnfordern(Activity activity){ + ActivityCompat.requestPermissions(activity, new String[]{CAMERA}, PERMISSION_REQUEST_CAMERA); + } + + public void microRechteAnfordern(Activity activity){ + ActivityCompat.requestPermissions(activity, new String[]{RECORD_AUDIO}, PERMISSION_REQUEST_MICRO); + } + + public void alarmRechteAnfordern(Activity activity){ + ActivityCompat.requestPermissions(activity, new String[]{CAMERA, RECORD_AUDIO, WRITE_EXTERNAL_STORAGE, READ_EXTERNAL_STORAGE}, PERMISSION_REQUEST_ALARM); + } + +} diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java index e6a7f95..aeca11c 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -27,6 +27,7 @@ public class VideodetectionActivity extends AppCompatActivity { private Button backToMainActivity; private VideodetectionViewModel mVideoDetectionViewModel; + private Permission permission = new Permission(); @Override protected void onCreate(Bundle savedInstanceState) { @@ -76,7 +77,18 @@ public class VideodetectionActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(VideodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(VideodetectionActivity.this, VideodetectionActivity.this)){ + Toast.makeText(VideodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(VideodetectionActivity.this); + if(permission.alarmRechtePruefen(VideodetectionActivity.this, VideodetectionActivity.this)){ + Toast.makeText(VideodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(VideodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(VideodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java index 3cbdfa5..fb3a815 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -37,6 +37,7 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im private TextView videodetectionAndAccelerometerWarningTV; private Button backToMainActivity; private VideodetectionAndAccelerometerViewModel mVideodetectionAndAccelerometerViewModel; + private Permission permission = new Permission(); @Override protected void onCreate(Bundle savedInstanceState) { @@ -89,7 +90,18 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + if(permission.alarmRechtePruefen(VideodetectionAndAccelerometerActivity.this, VideodetectionAndAccelerometerActivity.this)){ + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(VideodetectionAndAccelerometerActivity.this); + if(permission.alarmRechtePruefen(VideodetectionAndAccelerometerActivity.this, VideodetectionAndAccelerometerActivity.this)){ + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } } else { Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index a4446db..39f555d 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -23,8 +23,6 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa private MutableLiveData> mAlarmHistoryList; private MutableLiveData mStartAlarmRecording; private DeviceRepository mDeviceRepository; - private static final int RIGHTS_REQUEST_CAMERA = 10; - private static final int RIGHTS_REQUEST_CAMERA_MICROFON = 1; @Override public void init() { @@ -43,22 +41,6 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); } - public boolean isMicrofonAccessAllowed(Context context) { - return ContextCompat.checkSelfPermission(context, android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED; - } - - public void accessRequestMicrofon(Activity activity) { - ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.RECORD_AUDIO}, RIGHTS_REQUEST_CAMERA_MICROFON); - } - - public boolean isCameraAccessAllowed(Context context) { - return ContextCompat.checkSelfPermission(context, android.Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED; - } - - public void accessRequestCamera(Activity activity) { - ActivityCompat.requestPermissions(activity, new String[]{android.Manifest.permission.CAMERA}, RIGHTS_REQUEST_CAMERA); - } - @Override public LiveData> getConnectedDeviceList() { return mDeviceList; -- 2.47.2 From cca1311b74223053a067931e2e19d33985a1aee0 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 22 Jun 2023 00:48:18 +0200 Subject: [PATCH 29/34] adapted datahandling and communication strings --- .../greenwatch/AudiodetectionActivity.java | 4 +- ...udiodetectionAndAccelerometerActivity.java | 2 +- .../com/example/greenwatch/MainActivity.java | 25 +++++++++--- .../greenwatch/VideodetectionActivity.java | 4 +- .../communication/WiFiCommunication.java | 3 +- .../repositories/DeviceRepository.java | 39 ++++++++++++------- .../viewmodels/MainActivityViewModel.java | 6 +-- 7 files changed, 52 insertions(+), 31 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index cb43329..721134c 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -87,10 +87,10 @@ public class AudiodetectionActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Microfon", mMicrofonViewModel.getAmplitudeInDB()); + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Audio", mMicrofonViewModel.getAmplitudeInDB()); } else { - mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Microfon", mMicrofonViewModel.getAmplitudeInDB()); + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Audio", 0.0f); } } diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index 7b6a4ae..7694b73 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -105,7 +105,7 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im } else { Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedFalse", Toast.LENGTH_LONG).show(); - mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0); + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0.0f); } } diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index 43a534b..cafe1c0 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -7,6 +7,7 @@ import androidx.recyclerview.widget.LinearLayoutManager; import androidx.recyclerview.widget.RecyclerView; import android.content.Intent; +import android.hardware.SensorManager; import android.os.Bundle; import android.view.View; import android.widget.Button; @@ -138,30 +139,42 @@ public class MainActivity extends AppCompatActivity { } }); } - public void openAudiodetectionActivity(){ + + @Override + protected void onResume() { + super.onResume(); + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "No Sensor selected", 0.0f); + } + + public void openAudiodetectionActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "Audio", 0.0f); Intent intent = new Intent(this, AudiodetectionActivity.class); startActivity(intent); } - public void openVideodetectionActivity(){ + public void openVideodetectionActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "Video", 0.0f); Intent intent = new Intent(this, VideodetectionActivity.class); startActivity(intent); } - public void openAccelerometerActivity(){ + public void openAccelerometerActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "Accelerometer", 0.0f); Intent intent = new Intent(this, AccelerometerActivity.class); startActivity(intent); } - public void openAudiodetectionAndAccelerometerActivity(){ + public void openAudiodetectionAndAccelerometerActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0.0f); Intent intent = new Intent(this, AudiodetectionAndAccelerometerActivity.class); startActivity(intent); } - public void openVideodetectionAndAccelerometerActivity(){ + public void openVideodetectionAndAccelerometerActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0.0f); Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); startActivity(intent); } public void openConnectionActivity(){ //Intent intent = new Intent(this, ConnectionActivity.class); //startActivity(intent); - mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", true, "Audio", 10); + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", false, "Audio", 10); } } \ No newline at end of file diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java index e6a7f95..3f0ac9e 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -88,10 +88,10 @@ public class VideodetectionActivity extends AppCompatActivity { @Override public void onChanged(Boolean aBoolean) { if (aBoolean) { - mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), true, "Video", 10); + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), true, "Video", 1.0f); } else { - mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), false, "Video", 0); + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), false, "Video", 0.0f); } } diff --git a/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java b/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java index 065bbdc..abb2c49 100644 --- a/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java +++ b/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java @@ -88,8 +88,7 @@ public class WiFiCommunication { if(isNewMessage) { isNewMessage = false; - //todo: adapt send String - String txString = getLocalIpAddress() + " sends. #" + tmpCnt++ + sendMessage; + String txString = sendMessage; byte[] txBuffer = txString.getBytes(); DatagramPacket txPacket = new DatagramPacket(txBuffer, txBuffer.length, address, port); diff --git a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java index c601337..7d3e54a 100644 --- a/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -76,21 +76,22 @@ public class DeviceRepository { public void getNewReceivedMessage(String newMessage) { String[] messageString = messageStringSplitter(newMessage); - String timeStamp = messageString[0]; - String deviceID = messageString[1]; - boolean sensorStatus = convertSensorStatus(messageString[2]); - String sensorType = messageString[3]; - float sensorMassage = Float.valueOf(messageString[4]); + if(messageString[0]=="1" && messageString.length == 7) { + String timeStamp = messageString[1]; + String deviceID = messageString[3]; + boolean sensorStatus = convertSensorStatus(messageString[4]); + String sensorType = messageString[5]; + float sensorMassage = Float.valueOf(messageString[6]); - if (deviceID.equals(checkDeviceID(localDeviceUUID))) { - return; - } + if (deviceID.equals(checkDeviceID(localDeviceUUID))) { + return; + } - if(!connectedDevicesList.containsKey(deviceID)) { - createNewDevice(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); - } - else { - updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + if (!connectedDevicesList.containsKey(deviceID)) { + createNewDevice(timeStamp, deviceID, sensorStatus, sensorType, sensorMassage); + } else { + updateDevice(deviceID, timeStamp, sensorStatus, sensorType, sensorMassage); + } } } @@ -98,7 +99,11 @@ public class DeviceRepository { StringBuilder message = new StringBuilder(); Device device = connectedDevicesList.get(deviceID); if(device != null) { - message.append(device.getTimeStamp()) + message.append("1") + .append(delimiter) + .append(device.getTimeStamp()) + .append(delimiter) + .append("Gruppe3") .append(delimiter) .append(device.getDeviceID()) .append(delimiter) @@ -109,7 +114,11 @@ public class DeviceRepository { .append(device.getSensorMassage()); } else { - message.append("") + message.append("1") + .append(delimiter) + .append("") + .append(delimiter) + .append("Gruppe3") .append(delimiter) .append("") .append(delimiter) diff --git a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java index a737f07..12c6986 100644 --- a/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -32,12 +32,12 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa if(mDeviceList != null) { return; } - //todo: check if WiFi instanz can be hold only by the repository mDeviceRepository = DeviceRepository.getInstance(); mWiFiCommunication = WiFiCommunication.getInstance(); mDeviceRepository.setWiFiCommunication(mWiFiCommunication); mWiFiCommunication.setDeviceRepository(mDeviceRepository); - mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0); + mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0.0f); + mDeviceRepository.setDeviceID(mDeviceRepository.getLocalDeviceUUID(), WiFiCommunication.getLocalIpAddress()); mDeviceList = mDeviceRepository.getConnectedDeviceList(); mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); @@ -136,6 +136,6 @@ public class MainActivityViewModel extends ViewModel implements ViewModelInterfa @Override public String getSystemTimeStamp() { - return null; + return mDeviceRepository.getSystemTimeStamp(); } } -- 2.47.2 From 60bf036b408d48fd52ba704c020ea774c63ae649 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 22 Jun 2023 08:40:24 +0200 Subject: [PATCH 30/34] adapted Layout MainActivity --- .../com/example/greenwatch/MainActivity.java | 14 --- app/src/main/res/layout/activity_main.xml | 108 +++++++++++------- 2 files changed, 67 insertions(+), 55 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index aa20940..e2f9721 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -30,7 +30,6 @@ public class MainActivity extends AppCompatActivity { private Button accelerometerButton; private Button audiodetectionAndAccelerometerButton; private Button videodetectionAndAccelerometerButton; - private Button connectionButton; private MainActivityViewModel mMainActivityViewModel; private Permission permission = new Permission(); @@ -50,7 +49,6 @@ public class MainActivity extends AppCompatActivity { accelerometerButton = (Button) findViewById(R.id.accelerometerButton); audiodetectionAndAccelerometerButton = (Button) findViewById(R.id.audiodetectionAndAccelerometerButton); videodetectionAndAccelerometerButton = (Button) findViewById(R.id.videodetectionAndAccelerometerButton); - connectionButton = (Button) findViewById(R.id.connectionButton); RecyclerView deviceListRecyclerView = findViewById(R.id.deviceListRecyclerView); deviceListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); @@ -159,12 +157,6 @@ public class MainActivity extends AppCompatActivity { } } }); - connectionButton.setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View v) { - openConnectionActivity(); - } - }); } @Override @@ -198,10 +190,4 @@ public class MainActivity extends AppCompatActivity { Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); startActivity(intent); } - public void openConnectionActivity(){ - //Intent intent = new Intent(this, ConnectionActivity.class); - //startActivity(intent); - mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), "10:51", false, "Audio", 10); - } - } \ No newline at end of file diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml index ca28180..6490ad6 100644 --- a/app/src/main/res/layout/activity_main.xml +++ b/app/src/main/res/layout/activity_main.xml @@ -5,9 +5,10 @@ android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" - android:padding="10dp" + android:padding="5dp" tools:context=".MainActivity"> + - + - + android:layout_height="match_parent" + android:orientation="horizontal" + android:layout_weight="1"> - + - + - + - + android:layout_height="match_parent" + android:orientation="horizontal" + android:layout_weight="1"> - + + + + - + android:layout_height="match_parent" + android:orientation="horizontal" + android:layout_weight="1"> + + + + + + -- 2.47.2 From efb6dc97870969a1793ff631e275d7a3a87eb863 Mon Sep 17 00:00:00 2001 From: Christian Date: Thu, 22 Jun 2023 11:49:37 +0200 Subject: [PATCH 31/34] adapted Layout Activitys --- .../greenwatch/AccelerometerActivity.java | 6 ++-- .../greenwatch/AudiodetectionActivity.java | 4 +++ ...udiodetectionAndAccelerometerActivity.java | 4 +++ .../com/example/greenwatch/MainActivity.java | 6 ++++ .../greenwatch/VideodetectionActivity.java | 6 ++++ ...ideodetectionAndAccelerometerActivity.java | 6 ++-- .../res/layout/activity_accelerometer.xml | 33 ++++++++++++----- .../res/layout/activity_audiodetection.xml | 31 ++++++++++++++++ ...ivity_audiodetection_and_accelerometer.xml | 26 +++++++++++++- app/src/main/res/layout/activity_main.xml | 35 +++++++++++++++---- .../res/layout/activity_videodetection.xml | 24 +++++++++++++ ...ivity_videodetection_and_accelerometer.xml | 33 ++++++++++++----- 12 files changed, 186 insertions(+), 28 deletions(-) diff --git a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java index 8351817..3611ec7 100644 --- a/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -29,7 +29,8 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv private Sensor accelerometerSensor; private TextView accelerometerStatusMessage; private TextView accelerometerDataTV; - private TextView accelerometerWarningTV; + private TextView tvAccelerometerdeviceListRecyclerView; + private TextView tvAccelerometeralarmHistoryListRecyclerView; private Button backToMainActivityButton; private AccelerometerViewModel mAccelerometerViewModel; private Permission permission = new Permission(); @@ -41,7 +42,8 @@ public class AccelerometerActivity extends AppCompatActivity implements SensorEv accelerometerStatusMessage = (TextView) findViewById(R.id.tvAccelerometerStatusmessage); accelerometerDataTV = (TextView) findViewById(R.id.tvAccelerometerData); - accelerometerWarningTV = (TextView) findViewById(R.id.tvAccelerometerWarning); + tvAccelerometerdeviceListRecyclerView = (TextView) findViewById(R.id.tvAccelerometerdeviceListRecyclerView); + tvAccelerometeralarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvAccelerometeralarmHistoryListRecyclerView); backToMainActivityButton = (Button) findViewById(R.id.accelerometerBackToMainActivity); RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java index e9f4d12..987d3b3 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -23,6 +23,8 @@ import java.util.List; public class AudiodetectionActivity extends AppCompatActivity { private TextView microfonStatusMessage; + private TextView tvAAudiodetectionAlarmHistoryListRecyclerView; + private TextView tvAudiodetectionDeviceListRecyclerView; private Button backToMainActivityButton; private Permission permission = new Permission(); private MicrofonViewModel mMicrofonViewModel; @@ -33,6 +35,8 @@ public class AudiodetectionActivity extends AppCompatActivity { setContentView(R.layout.activity_audiodetection); microfonStatusMessage = (TextView) findViewById(R.id.tvAudiodetectionStatusmessage); + tvAAudiodetectionAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvAudiodetectionAlarmHistoryListRecyclerView); + tvAudiodetectionDeviceListRecyclerView = (TextView) findViewById(R.id.tvAudiodetectionDeviceListRecyclerView); backToMainActivityButton = (Button) findViewById(R.id.audiodetectorBackToMainActivity); RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); diff --git a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java index a06f64d..c22fcb9 100644 --- a/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -28,6 +28,8 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im private SensorManager accelerometerManager; private Sensor accelerometerSensor; private TextView audiodetectionAndAccelerometerStatusMessage; + private TextView tvAudiodetectionAndAccelerometerDeviceListRecyclerView; + private TextView tvAudiodetectionAndAccelerometerAlarmHistoryListRecyclerView; private AudiodetectionAndAccelerometerViewModel mAudiodetectionAndAccelerometerViewModel; private Button backToMainActivity; @@ -39,6 +41,8 @@ public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity im setContentView(R.layout.activity_audiodetection_and_accelerometer); audiodetectionAndAccelerometerStatusMessage = (TextView) findViewById(R.id.tvAudiodetectionAndAccelerometerStatusmessage); + tvAudiodetectionAndAccelerometerDeviceListRecyclerView = (TextView) findViewById(R.id.tvAudiodetectionAndAccelerometerDeviceListRecyclerView); + tvAudiodetectionAndAccelerometerAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvAudiodetectionAndAccelerometerAlarmHistoryListRecyclerView); backToMainActivity = (Button) findViewById(R.id.audiodetectionAndAccelerometerBackToMainActivity); RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); diff --git a/app/src/main/java/com/example/greenwatch/MainActivity.java b/app/src/main/java/com/example/greenwatch/MainActivity.java index e2f9721..5051ca7 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -30,6 +30,9 @@ public class MainActivity extends AppCompatActivity { private Button accelerometerButton; private Button audiodetectionAndAccelerometerButton; private Button videodetectionAndAccelerometerButton; + private TextView tvMainActivityDeviceListRecyclerView; + private TextView tvMainActivityAlarmHistoryListRecyclerView; + private SurfaceView surfaceView; private MainActivityViewModel mMainActivityViewModel; private Permission permission = new Permission(); @@ -44,6 +47,9 @@ public class MainActivity extends AppCompatActivity { activity = MainActivity.this; context = MainActivity.this; + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewMainActivity); + tvMainActivityDeviceListRecyclerView = (TextView) findViewById(R.id.tvMainActivityDeviceListRecyclerView); + tvMainActivityAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvMainActivityAlarmHistoryListRecyclerView); audiodetectionButton = (Button) findViewById(R.id.audiodetectionButton); videodetectionButton = (Button) findViewById(R.id.videodetectionButton); accelerometerButton = (Button) findViewById(R.id.accelerometerButton); diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java index 84490ff..9d70414 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -26,6 +26,9 @@ import java.util.concurrent.ExecutionException; public class VideodetectionActivity extends AppCompatActivity { private Button backToMainActivity; + private SurfaceView surfaceView; + private TextView tvVideodetectionDeviceListRecyclerView; + private TextView tvVideodetectionAlarmHistoryListRecyclerView; private VideodetectionViewModel mVideoDetectionViewModel; private Permission permission = new Permission(); @@ -34,6 +37,9 @@ public class VideodetectionActivity extends AppCompatActivity { super.onCreate(savedInstanceState); setContentView(R.layout.activity_videodetection); + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewVideodetection); + tvVideodetectionDeviceListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionDeviceListRecyclerView); + tvVideodetectionAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionAlarmHistoryListRecyclerView); backToMainActivity = (Button) findViewById(R.id.videodetectorBackToMainActivity); RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); diff --git a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java index 353b496..8d72977 100644 --- a/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -34,7 +34,8 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im private Sensor accelerometerSensor; private TextView videodetectionAndAccelerometerStatusMessage; private TextView videodetectionAndAccelerometerDataTV; - private TextView videodetectionAndAccelerometerWarningTV; + private TextView tvVideodetectionAndAccelerometerDeviceListRecyclerView; + private TextView tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView; private Button backToMainActivity; private VideodetectionAndAccelerometerViewModel mVideodetectionAndAccelerometerViewModel; private Permission permission = new Permission(); @@ -46,7 +47,8 @@ public class VideodetectionAndAccelerometerActivity extends AppCompatActivity im videodetectionAndAccelerometerStatusMessage = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerStatusmessage); videodetectionAndAccelerometerDataTV = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerData); - videodetectionAndAccelerometerWarningTV = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerWarning); + tvVideodetectionAndAccelerometerDeviceListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionAndAccelerometerDeviceListRecyclerView); + tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView); backToMainActivity = (Button) findViewById(R.id.videodetectionAndAccelerometerBackToMainActivity); RecyclerView recyclerView = findViewById(R.id.deviceListRecyclerView); diff --git a/app/src/main/res/layout/activity_accelerometer.xml b/app/src/main/res/layout/activity_accelerometer.xml index b90e124..6c9aced 100644 --- a/app/src/main/res/layout/activity_accelerometer.xml +++ b/app/src/main/res/layout/activity_accelerometer.xml @@ -8,11 +8,19 @@ android:padding="10dp" tools:context=".AccelerometerActivity"> + + + + android:textAppearance="@style/TextAppearance.AppCompat.Large" + android:text="Accelerometer Activity"> - - -