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 e6408bb..7c4d9c4 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -2,6 +2,18 @@ + + + + + + + + + + + + + + + + + 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..c9747dd --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AccelerometerActivity.java @@ -0,0 +1,181 @@ +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.SurfaceView; +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 java.util.List; + +public class AccelerometerActivity extends AppCompatActivity implements SensorEventListener { + + private SensorManager accelerometerManager; + private Sensor accelerometerSensor; + private SurfaceView surfaceView; + private TextView accelerometerStatusMessage; + private TextView accelerometerDataTV; + private TextView tvAccelerometerdeviceListRecyclerView; + private TextView tvAccelerometeralarmHistoryListRecyclerView; + private Button backToMainActivityButton; + private AccelerometerViewModel mAccelerometerViewModel; + private Permission permission = new Permission(); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_accelerometer); + + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewAccelerometer); + accelerometerStatusMessage = (TextView) findViewById(R.id.tvAccelerometerStatusmessage); + accelerometerDataTV = (TextView) findViewById(R.id.tvAccelerometerData); + tvAccelerometerdeviceListRecyclerView = (TextView) findViewById(R.id.tvAccelerometerdeviceListRecyclerView); + tvAccelerometeralarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvAccelerometeralarmHistoryListRecyclerView); + 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) { + finish(); + } + }); + + mAccelerometerViewModel = new ViewModelProvider(this).get(AccelerometerViewModel.class); + mAccelerometerViewModel.init(surfaceView.getHolder()); + mAccelerometerViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mAccelerometerViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mAccelerometerViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + if(permission.alarmRechtePruefen(AccelerometerActivity.this, AccelerometerActivity.this)){ + Toast.makeText(AccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mAccelerometerViewModel.startAlarmRecording(); + //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(); + mAccelerometerViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } + else { + Toast.makeText(AccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mAccelerometerViewModel.stopAlarmRecording(AccelerometerActivity.this); + } + } + } + else { + mAccelerometerViewModel.stopAlarmRecording(AccelerometerActivity.this); + Toast.makeText(AccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + mAccelerometerViewModel.getAccelerometerAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mAccelerometerViewModel.getAccelerometerSensorMeanValue()); + } + else { + mAccelerometerViewModel.updateDevice(mAccelerometerViewModel.getLocalDeviceUUID(), mAccelerometerViewModel.getSystemTimeStamp(), false, "Accelerometer", 0.0f); + } + + } + }); + + 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/AudiodetectionActivity.java b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java new file mode 100644 index 0000000..d3a9437 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionActivity.java @@ -0,0 +1,135 @@ +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.os.Bundle; +import android.view.SurfaceView; +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.MicrofonViewModel; + +import java.util.List; + +public class AudiodetectionActivity extends AppCompatActivity { + private TextView microfonStatusMessage; + private TextView tvAAudiodetectionAlarmHistoryListRecyclerView; + private TextView tvAudiodetectionDeviceListRecyclerView; + private Button backToMainActivityButton; + private SurfaceView surfaceView; + private Permission permission = new Permission(); + private MicrofonViewModel mMicrofonViewModel; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_audiodetection); + + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewAudio); + 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); + 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(surfaceView.getHolder()); + 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) { + if(permission.alarmRechtePruefen(AudiodetectionActivity.this, AudiodetectionActivity.this)){ + Toast.makeText(AudiodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mMicrofonViewModel.startAlarmRecording(); + //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(); + mMicrofonViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(AudiodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mMicrofonViewModel.stopAlarmRecording(AudiodetectionActivity.this); + } + } + } + else { + Toast.makeText(AudiodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mMicrofonViewModel.stopAlarmRecording(AudiodetectionActivity.this); + } + } + }); + + mMicrofonViewModel.getMicrofonAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), true, "Audio", mMicrofonViewModel.getAmplitudeInDB()); + } + else { + mMicrofonViewModel.updateDevice(mMicrofonViewModel.getLocalDeviceUUID(), mMicrofonViewModel.getSystemTimeStamp(), false, "Audio", 0.0f); + } + + } + }); + } + + @Override + protected void onResume() { + super.onResume(); + mMicrofonViewModel.startMicrofonSensor(); + } + + @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 new file mode 100644 index 0000000..3972109 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/AudiodetectionAndAccelerometerActivity.java @@ -0,0 +1,192 @@ +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.SurfaceView; +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.AudiodetectionAndAccelerometerViewModel; + +import java.util.List; + +public class AudiodetectionAndAccelerometerActivity extends AppCompatActivity implements SensorEventListener { + private SensorManager accelerometerManager; + private Sensor accelerometerSensor; + private SurfaceView surfaceView; + private TextView audiodetectionAndAccelerometerStatusMessage; + private TextView tvAudiodetectionAndAccelerometerDeviceListRecyclerView; + private TextView tvAudiodetectionAndAccelerometerAlarmHistoryListRecyclerView; + private AudiodetectionAndAccelerometerViewModel mAudiodetectionAndAccelerometerViewModel; + private Button backToMainActivity; + + private Permission permission = new Permission(); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_audiodetection_and_accelerometer); + + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewAudiodetectionAndAccelerometer); + 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); + 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(surfaceView.getHolder()); + 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) { + if(permission.alarmRechtePruefen(AudiodetectionAndAccelerometerActivity.this, AudiodetectionAndAccelerometerActivity.this)){ + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mAudiodetectionAndAccelerometerViewModel.startAlarmRecording(); + //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(); + mAudiodetectionAndAccelerometerViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mAudiodetectionAndAccelerometerViewModel.stopAlarmRecording(AudiodetectionAndAccelerometerActivity.this); + } + } + } + else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mAudiodetectionAndAccelerometerViewModel.stopAlarmRecording(AudiodetectionAndAccelerometerActivity.this); + } + } + }); + + mAudiodetectionAndAccelerometerViewModel.getAudiodetectionAndAccelerometerAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedTrue", Toast.LENGTH_LONG).show(); + if (mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mAudiodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); + } + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && !mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Audio", mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + } + else if (mAudiodetectionAndAccelerometerViewModel.getMicrofonAlarmDetected() && mAudiodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "AudioAndAccelerometer", mAudiodetectionAndAccelerometerViewModel.getAmplitudeInDB()); + } + } + else { + Toast.makeText(AudiodetectionAndAccelerometerActivity.this, "onChangedFalse", Toast.LENGTH_LONG).show(); + mAudiodetectionAndAccelerometerViewModel.updateDevice(mAudiodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mAudiodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0.0f); + } + + } + }); + + 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(); + if (isFinishing()){ + mAudiodetectionAndAccelerometerViewModel.recalibrationMicrofonSensor(); + } + 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 98aa213..bbee085 100644 --- a/app/src/main/java/com/example/greenwatch/MainActivity.java +++ b/app/src/main/java/com/example/greenwatch/MainActivity.java @@ -1,14 +1,208 @@ 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.app.Activity; +import android.content.Context; +import android.content.Intent; import android.os.Bundle; +import android.view.SurfaceView; +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; + +import java.util.List; public class MainActivity extends AppCompatActivity { + private Button audiodetectionButton; + private Button videodetectionButton; + 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(); + + 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; + + 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); + audiodetectionAndAccelerometerButton = (Button) findViewById(R.id.audiodetectionAndAccelerometerButton); + videodetectionAndAccelerometerButton = (Button) findViewById(R.id.videodetectionAndAccelerometerButton); + + RecyclerView deviceListRecyclerView = findViewById(R.id.deviceListRecyclerView); + deviceListRecyclerView.setLayoutManager(new LinearLayoutManager(this)); + deviceListRecyclerView.setHasFixedSize(true); + + final DeviceListAdapter deviceListAdapter = new 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); + + permission.startRechtePruefen(this, this); + + mMainActivityViewModel = new ViewModelProvider(this).get(MainActivityViewModel.class); + mMainActivityViewModel.init(surfaceView.getHolder()); + + mMainActivityViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mMainActivityViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mMainActivityViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + if(permission.alarmRechtePruefen(context, activity)){ + Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mMainActivityViewModel.startAlarmRecording(); + //todo AlarmHandling einfügen + } else { + permission.alarmRechteAnfordern(activity); + if(permission.alarmRechtePruefen(context, activity)){ + Toast.makeText(MainActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mMainActivityViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(MainActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mMainActivityViewModel.stopAlarmRecording(MainActivity.this); + } + } + } + else { + Toast.makeText(MainActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + audiodetectionButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + + if (permission.microRechtePruefen(context, activity)) { + openAudiodetectionActivity(); + } + else { + permission.microRechteAnfordern(activity); + } + } + }); + videodetectionButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (permission.kameraRechtePruefen(context, activity)) { + openVideodetectionActivity(); + } + else { + permission.kameraRechteAnfordern(activity); + } + } + }); + accelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + openAccelerometerActivity(); + mMainActivityViewModel.setSensorType(mMainActivityViewModel.getLocalDeviceUUID(), "Accelerometer"); + } + }); + audiodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (permission.microRechtePruefen(context, activity)) { + openAudiodetectionAndAccelerometerActivity(); + } + else { + permission.microRechteAnfordern(activity); + } + } + }); + videodetectionAndAccelerometerButton.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + if (permission.kameraRechtePruefen(context, activity)) { + openVideodetectionAndAccelerometerActivity(); + } + else { + permission.kameraRechteAnfordern(activity); + } + } + }); + } + + @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() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "Video", 0.0f); + Intent intent = new Intent(this, VideodetectionActivity.class); + startActivity(intent); + } + 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() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "AudioAndAccelerometer", 0.0f); + Intent intent = new Intent(this, AudiodetectionAndAccelerometerActivity.class); + startActivity(intent); + } + public void openVideodetectionAndAccelerometerActivity() { + mMainActivityViewModel.updateDevice(mMainActivityViewModel.getLocalDeviceUUID(), mMainActivityViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0.0f); + Intent intent = new Intent(this, VideodetectionAndAccelerometerActivity.class); + startActivity(intent); + } + + @Override + protected void onPause() { + super.onPause(); } } \ No newline at end of file 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 new file mode 100644 index 0000000..7b2fa65 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/VideodetectionActivity.java @@ -0,0 +1,131 @@ +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.SurfaceView; +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.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 SurfaceView surfaceView; + private TextView tvVideodetectionDeviceListRecyclerView; + private TextView tvVideodetectionAlarmHistoryListRecyclerView; + private VideodetectionViewModel mVideoDetectionViewModel; + private Permission permission = new Permission(); + + @Override + protected void onCreate(Bundle savedInstanceState) { + 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); + 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(surfaceView.getHolder()); + mVideoDetectionViewModel.getConnectedDeviceList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + deviceListAdapter.setDevices(devices); + } + }); + + mVideoDetectionViewModel.getAlarmHistoryList().observe(this, new Observer>() { + @Override + public void onChanged(List devices) { + alarmHistoryListAdapter.setAlarmHistoryList(devices); + } + }); + + mVideoDetectionViewModel.getStartAlarmRecording().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + if(permission.alarmRechtePruefen(VideodetectionActivity.this, VideodetectionActivity.this)){ + Toast.makeText(VideodetectionActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mVideoDetectionViewModel.startAlarmRecording(); + //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(); + mVideoDetectionViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(VideodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mVideoDetectionViewModel.stopAlarmRecording(VideodetectionActivity.this); + } + } + } + else { + Toast.makeText(VideodetectionActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + } + } + }); + + mVideoDetectionViewModel.getVideoAlarmDetectedValue().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), true, "Video", 1.0f); + } + else { + mVideoDetectionViewModel.updateDevice(mVideoDetectionViewModel.getLocalDeviceUUID(), mVideoDetectionViewModel.getSystemTimeStamp(), false, "Video", 0.0f); + } + + } + }); + + 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/VideodetectionAndAccelerometerActivity.java b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java new file mode 100644 index 0000000..4b31597 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/VideodetectionAndAccelerometerActivity.java @@ -0,0 +1,199 @@ +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.SurfaceView; +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.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 SurfaceView surfaceView; + private TextView videodetectionAndAccelerometerStatusMessage; + private TextView videodetectionAndAccelerometerDataTV; + private TextView tvVideodetectionAndAccelerometerDeviceListRecyclerView; + private TextView tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView; + private Button backToMainActivity; + private VideodetectionAndAccelerometerViewModel mVideodetectionAndAccelerometerViewModel; + private Permission permission = new Permission(); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_videodetection_and_accelerometer); + + surfaceView = (SurfaceView) findViewById(R.id.surfaceViewVideodetectionAndAccelerometer); + videodetectionAndAccelerometerStatusMessage = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerStatusmessage); + videodetectionAndAccelerometerDataTV = (TextView) findViewById(R.id.tvvideodetectionAndAccelerometerData); + tvVideodetectionAndAccelerometerDeviceListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionAndAccelerometerDeviceListRecyclerView); + tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView = (TextView) findViewById(R.id.tvVideodetectionAndAccelerometerAlarmHistoryListRecyclerView); + 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(surfaceView.getHolder()); + 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) { + if(permission.alarmRechtePruefen(VideodetectionAndAccelerometerActivity.this, VideodetectionAndAccelerometerActivity.this)){ + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Start Alarm Recording", Toast.LENGTH_LONG).show(); + mVideodetectionAndAccelerometerViewModel.startAlarmRecording(); + //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(); + mVideodetectionAndAccelerometerViewModel.startAlarmRecording(); + //todo Alarmhandling einfügen + } else { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mVideodetectionAndAccelerometerViewModel.stopAlarmRecording(VideodetectionAndAccelerometerActivity.this); + } + } + } + else { + Toast.makeText(VideodetectionAndAccelerometerActivity.this, "Stop Alarm Recording", Toast.LENGTH_LONG).show(); + mVideodetectionAndAccelerometerViewModel.stopAlarmRecording(VideodetectionAndAccelerometerActivity.this); + } + } + }); + + mVideodetectionAndAccelerometerViewModel.getVideodetectionAndAccelerometerAlarmDetected().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + if (aBoolean) { + if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Accelerometer", mVideodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); + } + else if (mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected() && !mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "Video", 1.0f); + } + else if (mVideodetectionAndAccelerometerViewModel.getAccelerometerAlarmDetected() && mVideodetectionAndAccelerometerViewModel.getVideoAlarmDetected()) { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), true, "VideoAndAccelerometer", mVideodetectionAndAccelerometerViewModel.getAccelerometerSensorMeanValue()); + } + } + else { + mVideodetectionAndAccelerometerViewModel.updateDevice(mVideodetectionAndAccelerometerViewModel.getLocalDeviceUUID(), mVideodetectionAndAccelerometerViewModel.getSystemTimeStamp(), false, "VideoAndAccelerometer", 0.0f); + } + } + }); + + 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/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/adapters/DeviceListAdapter.java b/app/src/main/java/com/example/greenwatch/adapters/DeviceListAdapter.java new file mode 100644 index 0000000..3b28b20 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/adapters/DeviceListAdapter.java @@ -0,0 +1,92 @@ +package com.example.greenwatch.adapters; + +import android.graphics.Color; +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.Collections; +import java.util.Comparator; +import java.util.List; + +public class DeviceListAdapter extends RecyclerView.Adapter { + private List devices = new ArrayList<>(); + + + @NonNull + @Override + public DeviceListHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { + View itemView = LayoutInflater.from(parent.getContext()) + .inflate(R.layout.device_item, parent, false); + return new DeviceListHolder(itemView); + } + + @Override + public void onBindViewHolder(@NonNull DeviceListHolder holder, int position) { + Device currentDevice = devices.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())); + holder.setDeviceSensorStatus(currentDevice); + } + + @Override + public int getItemCount() { + return devices.size(); + } + + public void setDevices(List devices) { + this.devices = devices; + Collections.sort(this.devices, new Comparator() { + + @Override + public int compare(Device device1, Device device2) { + if (device1.getSensorStatus() && !device2.getSensorStatus()) { + return -1; + } else if (!device1.getSensorStatus() && device2.getSensorStatus()) { + return 1; + } else { + return 0; + } + } + }); + notifyDataSetChanged(); + } + + class DeviceListHolder extends RecyclerView.ViewHolder { + private TextView textViewSensorType; + private TextView textViewSensorStatus; + private TextView textViewDeviceID; + private TextView textViewTimeStamp; + private TextView textViewSensorMessage; + + public DeviceListHolder(View itemView) { + super(itemView); + textViewSensorType = (TextView) itemView.findViewById(R.id.tvDeviceSensorType); + textViewSensorStatus = (TextView) itemView.findViewById(R.id.tvDeviceSensorStatus); + textViewDeviceID = (TextView) itemView.findViewById(R.id.tvDeviceID); + textViewTimeStamp = (TextView) itemView.findViewById(R.id.tvDeviceTimeStamp); + textViewSensorMessage = (TextView) itemView.findViewById(R.id.tvDeviceSensorMassage); + } + + public void setDeviceSensorStatus(Device device) { + if (device.getSensorStatus()) { + textViewSensorStatus.setText(itemView.getContext().getString(R.string.sensor_status_placeholder, "AN")); + itemView.setBackgroundColor(Color.RED); + } + else { + textViewSensorStatus.setText(itemView.getContext().getString(R.string.sensor_status_placeholder, "AUS")); + itemView.setBackgroundColor(Color.WHITE); + } + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/alarmrecorder/AlarmRecorder.java b/app/src/main/java/com/example/greenwatch/alarmrecorder/AlarmRecorder.java new file mode 100644 index 0000000..b1c47b2 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/alarmrecorder/AlarmRecorder.java @@ -0,0 +1,256 @@ +package com.example.greenwatch.alarmrecorder; + +import android.app.Activity; +import android.content.Context; +import android.media.MediaCodec; +import android.media.MediaExtractor; +import android.media.MediaFormat; +import android.media.MediaMuxer; +import android.media.MediaRecorder; +import android.os.Environment; +import android.view.SurfaceHolder; +import android.widget.Toast; + +import com.example.greenwatch.MainActivity; +import com.example.greenwatch.alarmrecorder.runnables.AudioRecorder; +import com.example.greenwatch.alarmrecorder.runnables.VideoRecorder; +import com.example.greenwatch.sensors.AccelerometerSensor; +import com.example.greenwatch.sensors.CameraSensor; + +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; + +public class AlarmRecorder { + private static AlarmRecorder alarmRecorderInstance; + private boolean isRecording; + private String videoPath; + private String audioPath; + private MediaFormat videoFormat; + private MediaFormat audioFormat; + private MediaExtractor videoExtractor; + private MediaExtractor audioExtractor; + private AudioRecorder audioRecorderRunnable; + private VideoRecorder videoRecorderRunnable; + private SurfaceHolder previewHolder; + private MediaRecorder videoRecorder; + //private MediaRecorder audioRecorder; + private Thread videoThread; // Video-Thread als Instanzvariable + private Thread audioThread; // Audio-Thread als Instanzvariable + + private AlarmRecorder() { + //audioRecorder = new MediaRecorder(); + //videoRecorder = new MediaRecorder(); + videoExtractor = new MediaExtractor(); + audioExtractor = new MediaExtractor(); + audioRecorderRunnable = new AudioRecorder(); + videoRecorderRunnable = new VideoRecorder(); + } + + public static synchronized AlarmRecorder getInstance() { + if (alarmRecorderInstance == null){ + alarmRecorderInstance = new AlarmRecorder(); + } + return alarmRecorderInstance; + } + + public void setPreviewHolder(SurfaceHolder previewHolder) { + this.previewHolder = previewHolder; + } + + public void startRecording() { + createStoragePaths(); //Speicherort und -namen für Audio- und Video-Datei + + setAudioPath(audioPath); + setVideoPath(videoPath); + setVideoRecorderPreviewHolder(previewHolder); + + //audioThread = new Thread(audioRecorderRunnable); + videoThread = new Thread(videoRecorderRunnable); + + //Threads starten + videoThread.start(); + //audioThread.start(); + } + + public void stopRecording(Context context) { + try { + //stopAudioRecording(); + stopVideoRecording(); + + Toast.makeText(context, "Video- und Audioaufzeichnung beendet", Toast.LENGTH_SHORT).show(); + + waitTillThreadsStopped(); + File videoFile = new File(videoPath); //Speichere das aufgenommene Video + File audioFile = new File(audioPath); //Speichere die aufgenommene Audio + + if (videoFile.exists() && audioFile.exists()) { + //Wenn Video- und Audioaufzeichnung gestoppt und abgespeichert sind, beginne mit dem Mergeprozess der beiden + // mergeVideoWithAudio(); + Toast.makeText(context, "Video und Audio erfolgreich zusammengeführt", Toast.LENGTH_SHORT).show(); + } else { + Toast.makeText(context, "Dateien wurden nicht gefunden!", Toast.LENGTH_SHORT).show(); + } + } catch (RuntimeException stopException) { + stopException.printStackTrace(); + } + } + + private void createStoragePaths(){ + //Pfade zum Zwischenspeichern der aufgenommenen Audio und Video-Datei + String externalStorageDirectory = Environment.getExternalStorageDirectory().getAbsolutePath(); + String dcimDirectory = externalStorageDirectory + "/DCIM"; + videoPath = dcimDirectory + "/video.mp4"; + audioPath = dcimDirectory + "/audio.mp3"; + } + + private void setVideoPath(String videoPath) { + videoRecorderRunnable.setVideoPath(videoPath); + } + + private void setVideoRecorderPreviewHolder(SurfaceHolder previewHolder) { + videoRecorderRunnable.setPreviewHolder(previewHolder); + } + private void stopVideoRecording(){ + videoRecorderRunnable.stopVideoRecording(); + } + + private void setAudioPath(String audioPath) { + audioRecorderRunnable.setAudioPath(audioPath); + } + + private void stopAudioRecording(){ + audioRecorderRunnable.stopAudioRecording(); + } + + private void waitTillThreadsStopped(){ + try { + videoThread.join(); + audioThread.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + private void mergeVideoWithAudio() { + try { + setVideoExtractorDataSource(); //extrahieren der Video Datei, die zuvor zwischengespeichert wurde + setAudioExtractorDataSource(); //extrahieren der Audio Datei, die zuvor zwischengespeichert wurde + + //Speicherort der später zusammengeführten Datei + String outputFilePath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES).getAbsolutePath() + "/merged_video.mp4"; + //MediaMuxer zum Zusammenführen einer Audio- und einer Videodatei + MediaMuxer muxer = new MediaMuxer(outputFilePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4); + int videoTrack = muxer.addTrack(videoFormat); + int audioTrack = muxer.addTrack(audioFormat); + muxer.start(); + + ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024); + MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo(); + + videoExtraction(buffer, videoTrack, bufferInfo, muxer); + audioExtraction(buffer, audioTrack, bufferInfo, muxer); + + muxer.stop(); + muxer.release(); + + // Löschen der separaten Video- und Audio-Dateien + deleteVideoFile(); + deleteAudioFile(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + private void setVideoExtractorDataSource() { + try { + videoExtractor.setDataSource(videoPath); + int videoTrackIndex = getTrackIndex(videoExtractor, "video/"); + if (videoTrackIndex < 0) { + // Video-Track nicht gefunden + return; + } + videoExtractor.selectTrack(videoTrackIndex); + videoFormat = videoExtractor.getTrackFormat(videoTrackIndex); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + private void setAudioExtractorDataSource() { + try { + audioExtractor.setDataSource(audioPath); + int audioTrackIndex = getTrackIndex(audioExtractor, "audio/"); + if (audioTrackIndex < 0) { + // Audio-Track nicht gefunden + return; + } + audioExtractor.selectTrack(audioTrackIndex); + audioFormat = audioExtractor.getTrackFormat(audioTrackIndex); + + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + private int getTrackIndex(MediaExtractor extractor, String mimeType) { + int trackCount = extractor.getTrackCount(); + for (int i = 0; i < trackCount; i++) { + MediaFormat format = extractor.getTrackFormat(i); + String trackMimeType = format.getString(MediaFormat.KEY_MIME); + if (trackMimeType.startsWith(mimeType)) { + return i; + } + } + return -1; + } + + private void videoExtraction(ByteBuffer buffer, int videoTrack, MediaCodec.BufferInfo bufferInfo, MediaMuxer muxer) { + videoExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC); + while (true) { + int sampleSize = videoExtractor.readSampleData(buffer, 0); + if (sampleSize < 0) { + break; + } + long presentationTimeUs = videoExtractor.getSampleTime(); + bufferInfo.offset = 0; + bufferInfo.size = sampleSize; + bufferInfo.flags = MediaCodec.BUFFER_FLAG_KEY_FRAME; + bufferInfo.presentationTimeUs = presentationTimeUs; + muxer.writeSampleData(videoTrack, buffer, bufferInfo); + videoExtractor.advance(); + } + } + + private void audioExtraction(ByteBuffer buffer, int audioTrack, MediaCodec.BufferInfo bufferInfo, MediaMuxer muxer) { + audioExtractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC); + while (true) { + int sampleSize = audioExtractor.readSampleData(buffer, 0); + if (sampleSize < 0) { + break; + } + long presentationTimeUs = audioExtractor.getSampleTime(); + bufferInfo.offset = 0; + bufferInfo.size = sampleSize; + bufferInfo.flags = 0; // or MediaCodec.BUFFER_FLAG_KEY_FRAME + bufferInfo.presentationTimeUs = presentationTimeUs; + muxer.writeSampleData(audioTrack, buffer, bufferInfo); + audioExtractor.advance(); + } + } + + + private void deleteVideoFile(){ + File videoFile = new File(videoPath); + if (videoFile.exists()) { + videoFile.delete(); + } + } + + private void deleteAudioFile(){ + File audioFile = new File(audioPath); + if (audioFile.exists()) { + audioFile.delete(); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/AudioRecorder.java b/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/AudioRecorder.java new file mode 100644 index 0000000..09afcdb --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/AudioRecorder.java @@ -0,0 +1,47 @@ +package com.example.greenwatch.alarmrecorder.runnables; + +import android.media.MediaRecorder; +import android.view.SurfaceHolder; +import android.widget.Toast; + +import com.example.greenwatch.MainActivity; + +import java.io.IOException; + +public class AudioRecorder implements Runnable { + + private MediaRecorder audioRecorder; + private String audioPath; + public AudioRecorder() { + audioRecorder = new MediaRecorder(); + } + + public void setAudioPath(String audioPath) { + this.audioPath = audioPath; + } + + public void stopAudioRecording(){ + if (audioRecorder != null) { + audioRecorder.stop(); + audioRecorder.reset(); + audioRecorder.release(); + audioRecorder = null; + } + } + + @Override + public void run() { + audioRecorder = new MediaRecorder(); + audioRecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT); + audioRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); + audioRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); + audioRecorder.setOutputFile(audioPath); + + try { + audioRecorder.prepare(); + audioRecorder.start(); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/VideoRecorder.java b/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/VideoRecorder.java new file mode 100644 index 0000000..d014231 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/alarmrecorder/runnables/VideoRecorder.java @@ -0,0 +1,54 @@ +package com.example.greenwatch.alarmrecorder.runnables; + +import android.media.MediaRecorder; +import android.view.SurfaceHolder; + +import com.example.greenwatch.viewmodels.ViewModelInterface; + +import java.io.IOException; + +public class VideoRecorder implements Runnable{ + private MediaRecorder videoRecorder; + private String videoPath; + private SurfaceHolder previewHolder; + + public VideoRecorder() { + videoRecorder = new MediaRecorder(); + } + + public void setPreviewHolder(SurfaceHolder previewHolder) { + this.previewHolder = previewHolder; + } + + public void setVideoPath(String audioPath) { + this.videoPath = audioPath; + } + + public void stopVideoRecording(){ + if (videoRecorder != null) { + videoRecorder.stop(); + videoRecorder.reset(); + videoRecorder.release(); + videoRecorder = null; + } + } + + @Override + public void run() { + videoRecorder = new MediaRecorder(); + videoRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); + videoRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); + videoRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT); + videoRecorder.setOutputFile(videoPath); + videoRecorder.setOrientationHint(90); + videoRecorder.setPreviewDisplay(previewHolder.getSurface()); + + try { + videoRecorder.prepare(); + videoRecorder.start(); + + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java b/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java new file mode 100644 index 0000000..17c38cf --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/communication/WiFiCommunication.java @@ -0,0 +1,134 @@ +package com.example.greenwatch.communication; + +import com.example.greenwatch.repositories.DeviceRepository; + +import java.io.IOException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.Inet4Address; +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.net.SocketException; +import java.net.UnknownHostException; +import java.util.Enumeration; + +public class WiFiCommunication { + + private final InetAddress address; + private final DatagramSocket socket; + private final int port; + private volatile String rxString; + private String sendMessage; + //private String sendMsg = "default"; + private boolean isNewMessage; + volatile private boolean running; + private static WiFiCommunication wifiCommunicationInstance; + private DeviceRepository mDeviceRepository; + + private WiFiCommunication() { + port = 1234; + try { + socket = new DatagramSocket(port); + socket.setBroadcast(true); + address = InetAddress.getByName("255.255.255.255"); + running = true; + isNewMessage = false; + new ReceiveThread().start(); + new SendThread().start(); + } catch (SocketException | UnknownHostException e) { + throw new RuntimeException(e); + } + } + + public static synchronized WiFiCommunication getInstance() { + if (wifiCommunicationInstance == null){ + wifiCommunicationInstance = new WiFiCommunication(); + } + return wifiCommunicationInstance; + } + + public void setDeviceRepository(DeviceRepository deviceRepository) { + if (mDeviceRepository == null) { + this.mDeviceRepository = deviceRepository; + } + } + + public void setNewMessage(String newMessage, boolean isNewMessage){ + this.sendMessage = newMessage; + this.isNewMessage = isNewMessage; + } + + public static String getLocalIpAddress() { + try { + for (Enumeration en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) { + NetworkInterface networkInterface = (NetworkInterface) ((Enumeration) en).nextElement(); + for (Enumeration addresses = networkInterface.getInetAddresses(); addresses.hasMoreElements();) { + InetAddress inetAddress = addresses.nextElement(); + if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) { + return inetAddress.getHostAddress(); + } + } + } + } catch (SocketException ex) { + ex.printStackTrace(); + } + return null; + } + + public void stopCommunication() { + running = false; + socket.close(); + } + + private class SendThread extends Thread { + private int tmpCnt = 0; + @Override + public void run() { + try { + do { + + if(isNewMessage) + { + isNewMessage = false; + String txString = sendMessage; + byte[] txBuffer = txString.getBytes(); + + DatagramPacket txPacket = new DatagramPacket(txBuffer, txBuffer.length, address, port); + + for(int i = 0; i < 20; i++) { + socket.send(txPacket); + } + } + } while (running); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + private class ReceiveThread extends Thread { + private String rxString = ""; + private String previousRxString = ""; + @Override + public void run() { + try { + do { + byte[] rxBuffer = new byte[1024]; + DatagramPacket packet = new DatagramPacket(rxBuffer, rxBuffer.length); + socket.receive(packet); + rxString = new String(packet.getData(), 0, packet.getLength()); + + if(!previousRxString.equals(rxString)){ + mDeviceRepository.getNewReceivedMessage(rxString); + + } + previousRxString = rxString; + + } while (running); + } + catch (IOException e) { + e.printStackTrace(); + } + } + } +} 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..3a5ef1a --- /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 float sensorMassage; + + public Device(String timeStamp, String deviceID, boolean sensorStatus, String sensorType, float 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(float sensorMassage) { + this.sensorMassage = sensorMassage; + } + + 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 new file mode 100644 index 0000000..d772147 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/repositories/DeviceRepository.java @@ -0,0 +1,350 @@ +package com.example.greenwatch.repositories; + + +import android.os.Looper; + +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 boolean startAlarmRecordingValue; + private MutableLiveData startAlarmRecording = new MutableLiveData<>(); + 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(); + startAlarmRecordingValue = false; + } + + public static synchronized DeviceRepository getInstance() { + if (deviceRepositoryInstance == null){ + deviceRepositoryInstance = new DeviceRepository(); + } + return deviceRepositoryInstance; + } + + public void setWiFiCommunication(WiFiCommunication wiFiCommunication) { + if (mWiFiCommunication == null) { + this.mWiFiCommunication = wiFiCommunication; + } + + } + + public MutableLiveData> getConnectedDeviceList() { + setMutableLiveDataDeviceList(); + return deviceList; + } + + public MutableLiveData> getAlarmHistoryDeviceList() { + setMutableLiveDataAlarmHistoryList(); + return alarmHistoryList; + } + + public MutableLiveData getStartAlarmRecording() { + setMutableLiveDataStartAlarmRecording(); + return startAlarmRecording; + } + + 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); + } + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } + addToConnectedDeviceList(newDevice.getDeviceID(), newDevice); + setMutableLiveDataDeviceList(); + } + + public void getNewReceivedMessage(String newMessage) { + String[] messageString = messageStringSplitter(newMessage); + if(messageString[0].equals("1") && messageString.length == 7) { + String timeStamp = messageString[1]; + String deviceID = messageString[3]; + boolean sensorStatus = convertRecievedSensorStatus(messageString[4]); + String sensorType = messageString[5]; + float sensorMassage = Float.valueOf(messageString[6]); + + 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) { + StringBuilder message = new StringBuilder(); + Device device = connectedDevicesList.get(deviceID); + if(device != null) { + message.append("1") + .append(delimiter) + .append(device.getTimeStamp()) + .append(delimiter) + .append("Gruppe3") + .append(delimiter) + .append(device.getDeviceID()) + .append(delimiter) + .append(convertSendSensorStatus(device.getSensorStatus())) + .append(delimiter) + .append(device.getSensorType()) + .append(delimiter) + .append(device.getSensorMassage()); + } + else { + message.append("1") + .append(delimiter) + .append("") + .append(delimiter) + .append("Gruppe3") + .append(delimiter) + .append("") + .append(delimiter) + .append("") + .append(delimiter) + .append("") + .append(delimiter) + .append(""); + } + return message.toString(); + } + + public String getLocalDeviceUUID() { + return localDeviceUUID; + } + + 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) { + device.setTimeStamp(timeStamp); + device.setSensorType(sensorType); + device.setSensorMassage(sensorMassage); + if (!device.getSensorStatus() && sensorStatus) { + setAlarmHistoryDeviceList(device); + } + device.setSensorStatus(sensorStatus); + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataDeviceList(); + } + } + + 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); + setMutableLiveDataDeviceList(); + } + } + + 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); + setMutableLiveDataDeviceList(); + } + } + + 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) { + if (!device.getSensorStatus() && sensorStatus) { + setAlarmHistoryDeviceList(device); + } + device.setSensorStatus(sensorStatus); + boolean newStartAlarmRecordingValue = checkDeviceStatus(); + if (startAlarmRecordingValue != newStartAlarmRecordingValue) { + startAlarmRecordingValue = newStartAlarmRecordingValue; + setMutableLiveDataStartAlarmRecording(); + } + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataDeviceList(); + + } + } + + 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); + setMutableLiveDataDeviceList(); + } + } + + 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, float sensorMessage) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + device.setSensorMassage(sensorMessage); + addToConnectedDeviceList(checkedDeviceID, device); + setMutableLiveDataDeviceList(); + } + } + + public float getSensorMassage(String deviceID) { + String checkedDeviceID = checkDeviceID(deviceID); + Device device = connectedDevicesList.get(checkedDeviceID); + if(device != null) { + return device.getSensorMassage(); + } + return 0; + } + + 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()); + if (Looper.myLooper() == Looper.getMainLooper()){ + deviceList.setValue(list); + } + else { + deviceList.postValue(list); + } + } + + private void setMutableLiveDataAlarmHistoryList() { + 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))) { + mWiFiCommunication.setNewMessage(messageStringBuilder(device.getDeviceID()),true); + } + } + + private String checkDeviceID(String deviceID) { + if(!deviceIDMapper.isEmpty() && deviceID.equals(localDeviceUUID)) { + return deviceIDMapper.get(deviceID); + } + return deviceID; + } + + private void setDeviceIDMapper(String deviceID) { + deviceIDMapper.put(localDeviceUUID, deviceID); + } + + private void setLocalDeviceUUID(){ + this.localDeviceUUID = UUID.randomUUID().toString(); + } + + private String[] messageStringSplitter(String message) { + return message.split(delimiter); + } + + private boolean convertRecievedSensorStatus(String status) { + return status.equals(sensorStatusKey); + } + + private String convertSendSensorStatus(boolean status) { + if (status){ + return "An"; + } + else { + return "Aus"; + } + } + + 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(); + } + + 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/sensors/AccelerometerSensor.java b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java new file mode 100644 index 0000000..52ad5eb --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/AccelerometerSensor.java @@ -0,0 +1,89 @@ +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); + } + } + + public float getAccelerometerSensorMeanValue() { + return meanValue; + } +} 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..c238df8 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java @@ -0,0 +1,188 @@ +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; +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 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; + } + + public static synchronized CameraSensor getInstance() { + if (cameraSensorInstance == null){ + cameraSensorInstance = new CameraSensor(); + } + return cameraSensorInstance; + } + + public MutableLiveData getVideoAlarmDetectedValue() { + setMutableLiveDataVideoAlarmDetected(); + return mVideoAlarmDetected; + } + + private void setMutableLiveDataVideoAlarmDetected() { + 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; + isMotionDetected = 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(); + + if (isMotionDetected) { + + videoAlarmDetected = true; + + if(alarmResetRunnable != null) { + alarmResetHandler.removeCallbacks(alarmResetRunnable); + } + + alarmResetRunnable = this::resetAlarmStatus; + alarmResetHandler.postDelayed(alarmResetRunnable, ALARM_RESET_DELAY); + } + + checkAlarmCondition(); + + } + + imageProxy.close(); + }); + + CameraSelector cameraSelector = new CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build(); + + cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, imageAnalysis); + } + + private boolean compareFrames(Image currentImage) { + 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; + } + + int blockSize = kleinstesQuadrat(previousHeight, previousWidth) / 8; + + int numBlocksX = currentWidth / blockSize; + int numBlocksY = currentHeight / blockSize; + + 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; + + 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(); + } + else if (!videoAlarmDetected && mVideoAlarmDetected.getValue()){ + setMutableLiveDataVideoAlarmDetected(); + } + } +} 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..40b78c9 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/sensors/MicrofonSensor.java @@ -0,0 +1,201 @@ +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 = 10; + + 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 = 10; + amplitudeInDB = 0; + } + + 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 new file mode 100644 index 0000000..87fba2e --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AccelerometerViewModel.java @@ -0,0 +1,175 @@ +package com.example.greenwatch.viewmodels; + +import android.Manifest; +import android.app.Activity; +import android.content.Context; +import android.content.pm.PackageManager; +import android.view.SurfaceHolder; + +import androidx.core.app.ActivityCompat; +import androidx.core.content.ContextCompat; +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.alarmrecorder.AlarmRecorder; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +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; + private MutableLiveData mStartAlarmRecording; + private AccelerometerSensor mAccelerometerSensor; + private AlarmRecorder mAlarmRecorder; + private DeviceRepository mDeviceRepository; + + @Override + public void init(SurfaceHolder previewHolder) { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.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(); + } + setAlarmRecordingPreviewHolder(previewHolder); + } + + public void addValueToGesamtBE(float newValue) { + mAccelerometerSensor.addValueToGesamtBE(newValue); + } + + public void meanValueCalculation() { + mAccelerometerSensor.meanValueCalculation(); + } + + public void calibrateAccelerometerSensor() { + mAccelerometerSensor.calibrateAccelerometerSensor(); + } + + public void checkAlarmCondition() { + mAccelerometerSensor.checkAlarmCondition(); + } + + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + + public LiveData getAccelerometerAlarmDetected() { + return mAccelerometerAlarmDetected; + } + + @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, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..14166a3 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/AudiodetectionAndAccelerometerViewModel.java @@ -0,0 +1,258 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; +import android.view.SurfaceHolder; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.alarmrecorder.AlarmRecorder; +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 AlarmRecorder mAlarmRecorder; + private DeviceRepository mDeviceRepository; + private boolean microfonAlarmDetected; + private boolean accelerometerAlarmDetected; + private boolean microfondetectionAndAccelerometerAlarmDetected; + + public void init() { + + } + + public void addValueToGesamtBE(float newValue) { + mAccelerometerSensor.addValueToGesamtBE(newValue); + } + + public void meanValueCalculation() { + mAccelerometerSensor.meanValueCalculation(); + } + + public void calibrateAccelerometerSensor() { + mAccelerometerSensor.calibrateAccelerometerSensor(); + } + + public void checkAlarmCondition() { + mAccelerometerSensor.checkAlarmCondition(); + } + + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + + 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 = true; + setMutableLiveDataMicrofondetectionAndAccelerometerAlarmDetected(); + + } + else if (!microfonAlarmDetected && !accelerometerAlarmDetected) { + 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 void init(SurfaceHolder previewHolder) { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mMicrofonSensor == null) { + mMicrofonSensor = MicrofonSensor.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.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(); + setAlarmRecordingPreviewHolder(previewHolder); + } + + @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, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..cd05bb5 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MainActivityViewModel.java @@ -0,0 +1,155 @@ +package com.example.greenwatch.viewmodels; + +import android.Manifest; +import android.app.Activity; +import android.content.Context; +import android.content.pm.PackageManager; +import android.view.SurfaceHolder; + +import androidx.core.app.ActivityCompat; +import androidx.core.content.ContextCompat; +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.alarmrecorder.AlarmRecorder; +import com.example.greenwatch.communication.WiFiCommunication; +import com.example.greenwatch.models.Device; +import com.example.greenwatch.repositories.DeviceRepository; +import com.example.greenwatch.sensors.AccelerometerSensor; + +import java.util.List; + +public class MainActivityViewModel extends ViewModel implements ViewModelInterface { + + private MutableLiveData> mDeviceList; + private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; + private DeviceRepository mDeviceRepository; + private WiFiCommunication mWiFiCommunication; + private AlarmRecorder mAlarmRecorder; + + @Override + public void init(SurfaceHolder previewHolder) { + + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mWiFiCommunication == null) { + mWiFiCommunication = WiFiCommunication.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } + mWiFiCommunication.setDeviceRepository(mDeviceRepository); + mDeviceRepository.setWiFiCommunication(mWiFiCommunication); + mDeviceRepository.createNewDevice(mDeviceRepository.getSystemTimeStamp(), mDeviceRepository.getLocalDeviceUUID(), false, "No Sensor selected", 0.0f); + mDeviceRepository.setDeviceID(mDeviceRepository.getLocalDeviceUUID(), WiFiCommunication.getLocalIpAddress()); + setAlarmRecordingPreviewHolder(previewHolder); + mWiFiCommunication = null; + } + + @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, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..b16248e --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/MicrofonViewModel.java @@ -0,0 +1,167 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; +import android.view.SurfaceHolder; + +import androidx.lifecycle.LiveData; +import androidx.lifecycle.MutableLiveData; +import androidx.lifecycle.ViewModel; + +import com.example.greenwatch.alarmrecorder.AlarmRecorder; +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 MicrofonViewModel extends ViewModel implements ViewModelInterface { + private MutableLiveData> mDeviceList; + private MutableLiveData mMicrofonAlarmDetected; + private MutableLiveData> mAlarmHistoryList; + private MutableLiveData mStartAlarmRecording; + private MicrofonSensor mMicrofonSensor; + private DeviceRepository mDeviceRepository; + private AlarmRecorder mAlarmRecorder; + + 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 void init(SurfaceHolder previewHolder) { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mMicrofonSensor == null) { + mMicrofonSensor = MicrofonSensor.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.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(); + } + setAlarmRecordingPreviewHolder(previewHolder); + } + + @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, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..8bc0bbd --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionAndAccelerometerViewModel.java @@ -0,0 +1,244 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; +import android.view.SurfaceHolder; + +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.alarmrecorder.AlarmRecorder; +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 AlarmRecorder mAlarmRecorder; + private boolean videoAlarmDetected; + private boolean accelerometerAlarmDetected; + private boolean videodetectionAndAccelerometerAlarmDetected; + + public void addValueToGesamtBE(float newValue) { + mAccelerometerSensor.addValueToGesamtBE(newValue); + } + + public void meanValueCalculation() { + mAccelerometerSensor.meanValueCalculation(); + } + + public void calibrateAccelerometerSensor() { + mAccelerometerSensor.calibrateAccelerometerSensor(); + } + + public void checkAlarmCondition() { + mAccelerometerSensor.checkAlarmCondition(); + } + + public float getAccelerometerSensorMeanValue() { + return mAccelerometerSensor.getAccelerometerSensorMeanValue(); + } + + 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); + } + + 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) { + setAccelerometerAlarmDetected(mAccelerometerAlarmDetected.getValue()); + setVideoAlarmDetected(mVideoAlarmDetected.getValue()); + if (videoAlarmDetected || accelerometerAlarmDetected && !videodetectionAndAccelerometerAlarmDetected) { + videodetectionAndAccelerometerAlarmDetected = true; + setMutableLiveDataVideodetectionAndAccelerometerAlarmDetected(); + + } + else if (!videoAlarmDetected && !accelerometerAlarmDetected && 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 void init(SurfaceHolder previewHolder) { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mAccelerometerSensor == null) { + mAccelerometerSensor = AccelerometerSensor.getInstance(); + } + if (mCameraSensor == null) { + mCameraSensor = CameraSensor.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.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; + videoAlarmDetected = false; + accelerometerAlarmDetected = false; + registerAlarmObserver(); + setAlarmRecordingPreviewHolder(previewHolder); + } + + @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, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..c86af52 --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/VideodetectionViewModel.java @@ -0,0 +1,162 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; +import android.view.SurfaceHolder; + +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.alarmrecorder.AlarmRecorder; +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 MutableLiveData mStartAlarmRecording; + private DeviceRepository mDeviceRepository; + private AlarmRecorder mAlarmRecorder; + private CameraSensor mCameraSensor; + + + public LiveData getVideoMovementDetectedValue() { + return mVideoAlarmDetected; + } + + @Override + public void init(SurfaceHolder previewHolder) { + if (mDeviceRepository == null) { + mDeviceRepository = DeviceRepository.getInstance(); + } + if (mCameraSensor == null) { + mCameraSensor = CameraSensor.getInstance(); + } + if (mAlarmRecorder == null) { + mAlarmRecorder = AlarmRecorder.getInstance(); + } + if (mDeviceList == null) { + mDeviceList = mDeviceRepository.getConnectedDeviceList(); + } + if (mAlarmHistoryList == null) { + mAlarmHistoryList = mDeviceRepository.getAlarmHistoryDeviceList(); + } + if (mStartAlarmRecording == null) { + mStartAlarmRecording = mDeviceRepository.getStartAlarmRecording(); + } + if (mVideoAlarmDetected == null) { + mVideoAlarmDetected = mCameraSensor.getVideoAlarmDetectedValue(); + } + setAlarmRecordingPreviewHolder(previewHolder); + } + + 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 LiveData getStartAlarmRecording() { + return mStartAlarmRecording; + } + + @Override + public void updateDevice(String deviceID, String timeStamp, boolean sensorStatus, String sensorType, float 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, float sensorMessage) { + mDeviceRepository.setSensorMassage(deviceID, sensorMessage); + } + + @Override + public float getSensorMassage(String deviceID) { + return mDeviceRepository.getSensorMassage(deviceID); + } + + @Override + public String getLocalDeviceUUID() { + return mDeviceRepository.getLocalDeviceUUID(); + } + + @Override + public String getSystemTimeStamp() { + return mDeviceRepository.getSystemTimeStamp(); + } + + @Override + public void startAlarmRecording() { + mAlarmRecorder.startRecording(); + } + + @Override + public void stopAlarmRecording(Context context) { + mAlarmRecorder.stopRecording(context); + } + + @Override + public void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder) { + mAlarmRecorder.setPreviewHolder(previewHolder); + } +} 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..002a0ab --- /dev/null +++ b/app/src/main/java/com/example/greenwatch/viewmodels/ViewModelInterface.java @@ -0,0 +1,33 @@ +package com.example.greenwatch.viewmodels; + +import android.content.Context; +import android.view.SurfaceHolder; + +import androidx.lifecycle.LiveData; + +import com.example.greenwatch.models.Device; + +import java.util.List; + +public interface ViewModelInterface { + void init(SurfaceHolder previewHolder); + LiveData> getConnectedDeviceList(); + LiveData> getAlarmHistoryList(); + LiveData getStartAlarmRecording(); + 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); + 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, float sensorMessage); + float getSensorMassage(String deviceID); + String getLocalDeviceUUID(); + String getSystemTimeStamp(); + void startAlarmRecording(); + void stopAlarmRecording(Context context); + void setAlarmRecordingPreviewHolder(SurfaceHolder previewHolder); +} 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..6c9aced --- /dev/null +++ b/app/src/main/res/layout/activity_accelerometer.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ 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..25b4e30 --- /dev/null +++ b/app/src/main/res/layout/activity_audiodetection.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ 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..df2b7d7 --- /dev/null +++ b/app/src/main/res/layout/activity_audiodetection_and_accelerometer.xml @@ -0,0 +1,72 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ 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..950b8a2 100644 --- a/app/src/main/res/layout/activity_main.xml +++ b/app/src/main/res/layout/activity_main.xml @@ -1,18 +1,130 @@ - + android:textAppearance="@style/TextAppearance.AppCompat.Large" + android:text="Registered Devices"> + - \ No newline at end of file + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ 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..a4ab242 --- /dev/null +++ b/app/src/main/res/layout/activity_videodetection.xml @@ -0,0 +1,72 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ 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..552e806 --- /dev/null +++ b/app/src/main/res/layout/activity_videodetection_and_accelerometer.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file 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 diff --git a/app/src/main/res/layout/device_item.xml b/app/src/main/res/layout/device_item.xml new file mode 100644 index 0000000..449fbd1 --- /dev/null +++ b/app/src/main/res/layout/device_item.xml @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 9aa5c73..4bbef69 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,3 +1,8 @@ GreenWatch + Sensortyp: %s + Sensorstatus: %s + Sensor-ID: %s + Timestamp: %s + Sensormessage: %f \ No newline at end of file