Page MenuHomec4science
Files F83487437

AddMonitorFragment.java
No OneTemporary
Actions

File Metadata

Created
Tue, Sep 17, 10:10

AddMonitorFragment.java
View Options

package ch.epfl.esl.elevatedmonitor;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.support.annotation.NonNull;
import android.support.design.widget.Snackbar;
import android.support.v4.app.DialogFragment;
import android.util.Log;
import android.util.TypedValue;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.SpinnerAdapter;
import android.widget.TextView;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import ch.epfl.esl.elevatedmonitor.SuperClasses.Device;
import ch.epfl.esl.elevatedmonitor.SuperClasses.SensorDevice;
public class AddMonitorFragment extends DialogFragment {
private static final int MARGIN = 16;
private static final int TEXT_SIZE = 14;
private static final String TAG = "ADD MONITOR";
public static AddMonitorFragment newInstance() {
return new AddMonitorFragment();
}
ArrayList<Device> listDeviceConnected = new ArrayList<>();
ArrayList<SensorDevice> listSensorsDevice = new ArrayList<>();
Device selectedDevice = null;
SensorDevice selectedSensor = null;
//--- Service Manager
private ServiceManagerConnection serviceManagerConnection = null;
// private ConnectedStateReceiver connectedStateReceiver = null;
private Boolean serviceManagerBound = false;
//--------------------------------------------------------------------------------------------//
// Override methods //
//--------------------------------------------------------------------------------------------//
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
public View onCreateView(@NonNull final LayoutInflater inflater, final ViewGroup container, Bundle savedInstanceState) {
View v = inflater.inflate(R.layout.dialog_add_monitor, container, false);
final DeviceAdapter deviceAdapter = new DeviceAdapter();
final SensorAdapter sensorAdapter = new SensorAdapter();
final Spinner spinnerDevice = v.findViewById(R.id.spinnerDeviceSession);
final Spinner spinnerSensor = v.findViewById(R.id.spinnerSensorMonitoring);
/*----------------------------------------------------------------------------------------//
//--- Initialize first spinner
//----------------------------------------------------------------------------------------*/
listDeviceConnected.addAll(ServiceManager.getConnectedDevices());
// Apply the adapter to the spinner
spinnerDevice.setAdapter(deviceAdapter);
class SpinnerDeviceOnItemSelectedListener implements AdapterView.OnItemSelectedListener {
public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
Spinner spinnerSensor = parent.getRootView().findViewById(R.id.spinnerSensorMonitoring);
//Check if option is not the first one
if (pos == 0) {
//Snackbar.make(parent.getRootView(), R.string.select_device, Snackbar.LENGTH_SHORT).show();
listSensorsDevice.clear();
sensorAdapter.notifyDataSetChanged();
spinnerSensor.setEnabled(false);
} else {
selectedDevice = (Device) spinnerDevice.getSelectedItem();
listSensorsDevice.clear();
Device device = ((Device) parent.getAdapter().getItem(pos));
listSensorsDevice.addAll(device.getSensors());
sensorAdapter.notifyDataSetChanged();
spinnerSensor.setEnabled(true);
// Snackbar.make(parent.getRootView(), R.string.select_sensor, Snackbar.LENGTH_SHORT).show();
}
}
public void onNothingSelected(AdapterView parent) {
}
}
AdapterView.OnItemSelectedListener spinnerDeviceListener = new SpinnerDeviceOnItemSelectedListener();
spinnerDevice.setOnItemSelectedListener(spinnerDeviceListener);
/*----------------------------------------------------------------------------------------//
//--- Initialize second spinner.
//----------------------------------------------------------------------------------------*/
// Apply the adapter to the spinner
spinnerSensor.setAdapter(sensorAdapter);
class SpinnerSensorOnItemSelectedListener implements AdapterView.OnItemSelectedListener {
public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
//Check if option is not the first one
if (listSensorsDevice.size() > 0) {
if (pos == 0) {
Snackbar.make(parent.getRootView(), R.string.select_sensor, Snackbar.LENGTH_SHORT).show();
} else {
selectedSensor = (SensorDevice) spinnerSensor.getSelectedItem();
}
}
}
public void onNothingSelected(AdapterView parent) {
}
}
AdapterView.OnItemSelectedListener spinnerSensorListener = new SpinnerSensorOnItemSelectedListener();
spinnerSensor.setOnItemSelectedListener(spinnerSensorListener);
spinnerSensor.setEnabled(false);
/*----------------------------------------------------------------------------------------//
// Watch for cancel button click.
//----------------------------------------------------------------------------------------*/
Button buttonCancel = v.findViewById(R.id.buttonCancelMonitoring);
buttonCancel.setOnClickListener(v12 -> {
// When button is clicked, call up to owning activity.
dismiss();
});
/*----------------------------------------------------------------------------------------//
// Watch for add button click.
//----------------------------------------------------------------------------------------*/
Button buttonAdd = v.findViewById(R.id.buttonAddMonitoring);
// When button is clicked, call up to owning activity.
buttonAdd.setOnClickListener(v1 -> {
if (spinnerDevice.getSelectedItemPosition() != 0 && spinnerSensor.getSelectedItemPosition() != 0) {
//--- First get selected device from Service Manager.
Device selectedDevice = ((Device) spinnerDevice.getSelectedItem());
//--- Then check inside connected devices.
boolean flagConnected = false;
for (Device device : ServiceManager.getConnectedDevices()) {
if (device.getId().equals(selectedDevice.getId()) && device.isConnected()) {
addMonitor(device, selectedSensor);
flagConnected = true;
break;
}
}
//--- If not initiate a connection.
if (!flagConnected) {
Log.d(TAG, "Device not connected, start a connection");
ServiceManager.startActionConnect(v1.getContext(), selectedDevice.getId(), selectedDevice.getManagerName());
Snackbar.make(v1.getRootView(), R.string.monitor_add_device, Snackbar.LENGTH_LONG).show();
}
} else if (spinnerDevice.getSelectedItemPosition() == 0) {
Snackbar.make(v1, R.string.select_device, Snackbar.LENGTH_SHORT).show();
} else {
Snackbar.make(v1, R.string.select_sensor, Snackbar.LENGTH_SHORT).show();
}
});
return v;
}
@Override
public void onStart() {
super.onStart();
/*-------------------------- Register the BroadCast Receiver -----------------------------*/
//--- The filter's action is BROADCAST_STATUS
// IntentFilter statusIntentFilter = new IntentFilter(Constants.BROADCAST_STATUS);
//--- Instantiates a new ScannedStateReceiver
// connectedStateReceiver = new ConnectedStateReceiver();
//--- Registers the ScannedStateReceiver and its intent filters
// LocalBroadcastManager.getInstance(this.getContext()).registerReceiver(connectedStateReceiver, statusIntentFilter);
//--- Start a new connection
if (serviceManagerConnection == null) {
serviceManagerConnection = new ServiceManagerConnection();
}
//------------------------------ Bind to LocalService ------------------------------------//
Intent serviceManagerIntent = new Intent(this.getActivity(), ServiceManager.class);
if (!serviceManagerBound) {
this.getActivity().bindService(serviceManagerIntent, serviceManagerConnection, Context.BIND_AUTO_CREATE);
}
}
@Override
public void onStop() {
if (serviceManagerBound) {
this.getActivity().unbindService(serviceManagerConnection);
}
super.onStop();
}
/**
* Return list of devices which were already connected to the app or that are currently connected.
* Reading into files.
*/
private ArrayList<Device> getListDeviceSaved() {
//Variable declaration
ArrayList<Device> deviceList = new ArrayList<>();
//Get File
File path = this.getContext().getFilesDir();
File file = new File(path, Constants.FILE_DEVICES);
//Read file
if (file.exists()) {
try {
//---Read device list
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
deviceList = (ArrayList<Device>) ois.readObject();
ois.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return deviceList;
}
private void addMonitor(Device device, SensorDevice sensor) {
Log.d(TAG, "A monitor will be added.");
MonitoringActivity.addMonitor(new Monitor(device, device.getSensor(sensor.getId()), this.getContext()));
MonitoringActivity.notifyAdapterDataSetChanged();
DialogFragment df = this;
df.dismiss();
}
class SensorAdapter extends BaseAdapter implements SpinnerAdapter {
@Override
public int getCount() {
return (listSensorsDevice.size() + 1);
}
@Override
public Object getItem(int position) {
if (position == 0) {
return null;
} else {
return listSensorsDevice.get(--position);
}
}
@Override
public long getItemId(int position) {
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
LinearLayout ll = new LinearLayout(parent.getContext());
ll.setOrientation(LinearLayout.VERTICAL);
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
int px = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, MARGIN, parent.getResources().getDisplayMetrics());
params.setMargins(px, px, px, px);
TextView text = new TextView(parent.getContext());
text.setTextSize(TEXT_SIZE);
if (position == 0) {
text.setText(getResources().getString(R.string.select_sensor));
} else {
text.setText(listSensorsDevice.get(--position).getName());
}
ll.addView(text, params);
return ll;
}
}
class DeviceAdapter extends BaseAdapter implements SpinnerAdapter {
@Override
public int getCount() {
return (listDeviceConnected.size() + 1);
}
@Override
public Object getItem(int position) {
if (position == 0) {
return null;
} else {
return listDeviceConnected.get(--position);
}
}
@Override
public long getItemId(int position) {
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
LinearLayout ll = new LinearLayout(parent.getContext());
ll.setOrientation(LinearLayout.VERTICAL);
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
int px = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, MARGIN, parent.getResources().getDisplayMetrics());
params.setMargins(px, px, px, px);
TextView text = new TextView(parent.getContext());
text.setTextSize(TEXT_SIZE);
if (position == 0) {
text.setText(getResources().getString(R.string.select_device));
} else {
text.setText(listDeviceConnected.get(--position).getName());
}
ll.addView(text, params);
return ll;
}
}
//--------------------------------------------------------------------------------------------//
/**
* Broadcast receiver for receiving status updates from the Devices Services to update list
*/
/*
private class ConnectedStateReceiver extends BroadcastReceiver {
// Called when the BroadcastReceiver gets an Intent it's registered to receive
@Override
public void onReceive(Context context, Intent intent) {
final String status = intent.getAction();
final String statusType = intent.getStringExtra(Constants.EXTENDED_DATA_STATUS);
if (Constants.BROADCAST_STATUS.equals(status)) {
if (ServiceManager.STATUS_CONNECTED.equals(statusType)) {
Log.d(TAG, "New connection");
for (Device device : ServiceManager.getConnectedDevices()) {
if (device != null && device.isConnected() && device.getId().equals(selectedDevice.getId())) {
addMonitor(device, selectedSensor);
}
}
}
}
}
}
*/
private class ServiceManagerConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName className, IBinder service) {
// We've bound to LocalService, cast the IBinder and get LocalService instance
ServiceManager.ServiceManagerBinder binder = (ServiceManager.ServiceManagerBinder) service;
ServiceManager.serviceManager = binder.getService();
serviceManagerBound = true;
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
serviceManagerBound = false;
}
}
}

Event Timeline

c4science · Help