Initial import

6 files changed, 717 insertions, 0 deletions

diff --git a/app/src/main/java/com/javispedro/rempe/Device.java b/app/src/main/java/com/javispedro/rempe/Device.java
new file mode 100644
index 0000000..4622eed
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/Device.java
@@ -0,0 +1,231 @@
+package com.javispedro.rempe;
+
+import android.content.Context;
+import android.util.Log;
+
+import com.dsi.ant.plugins.antplus.pcc.AntPlusEnvironmentPcc;
+import com.dsi.ant.plugins.antplus.pcc.defines.DeviceState;
+import com.dsi.ant.plugins.antplus.pcc.defines.EventFlag;
+import com.dsi.ant.plugins.antplus.pcc.defines.RequestAccessResult;
+import com.dsi.ant.plugins.antplus.pccbase.AntPluginPcc;
+import com.dsi.ant.plugins.antplus.pccbase.AntPlusCommonPcc;
+import com.dsi.ant.plugins.antplus.pccbase.PccReleaseHandle;
+
+import java.math.BigDecimal;
+import java.util.EnumSet;
+
+public class Device {
+    private final static String TAG = "Device";
+
+    private final int mDeviceNumber;
+
+    private PccReleaseHandle<AntPlusEnvironmentPcc> mEnvPccHandle;
+    private AntPlusEnvironmentPcc mEnvPcc;
+
+    private String mDeviceName;
+
+    private final Reading mLastReading = new Reading();
+    private int mLastRssi;
+    private RequestAccessResult mConnectResult;
+    private DeviceState mCurState;
+
+    public interface DeviceObserver {
+        void onDeviceInfoChanged();
+        void onDeviceStateChanged();
+        void onDeviceNewReading();
+        void onDeviceRssiChanged();
+    }
+    private DeviceObserver mObserver;
+
+    public Device(int deviceNumber) {
+        mDeviceNumber = deviceNumber;
+        mDeviceName = "dev-" + deviceNumber;
+        mConnectResult = RequestAccessResult.SUCCESS;
+        mCurState = DeviceState.DEAD;
+    }
+
+    public void connect(Context context) {
+        Log.d(TAG, "connect (" + mDeviceNumber + ")");
+        if (mEnvPccHandle != null) {
+            Log.w(TAG, "Already connected");
+        }
+        mConnectResult = RequestAccessResult.SUCCESS; // Clear old connect result
+        mCurState = DeviceState.SEARCHING;
+        if (mObserver != null) {
+            mObserver.onDeviceStateChanged();
+        }
+        mEnvPccHandle = AntPlusEnvironmentPcc.requestAccess(context, mDeviceNumber, 0, mResultReceiver, mDeviceStateChangeReceiver);
+    }
+
+    public void close() {
+        Log.d(TAG, "close (" + mDeviceNumber + ")");
+        if (mEnvPccHandle != null) {
+            mEnvPccHandle.close();
+            mEnvPccHandle = null;
+        }
+        if (mEnvPcc != null) {
+            mEnvPcc = null;
+        }
+        mConnectResult = RequestAccessResult.SUCCESS;
+        mCurState = DeviceState.DEAD;
+        if (mObserver != null) {
+            mObserver.onDeviceStateChanged();
+        }
+    }
+
+    public void setObserver(DeviceObserver observer) {
+        mObserver = observer;
+    }
+
+    public boolean isOpen() {
+        return mEnvPccHandle != null;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + "(" + mDeviceNumber + ")";
+    }
+
+    private void setEnvPcc(AntPlusEnvironmentPcc envPcc) {
+        if (mEnvPcc != null) {
+            mEnvPcc.releaseAccess();
+            mEnvPcc = null;
+        }
+        mEnvPcc = envPcc;
+        final String deviceName = mEnvPcc.getDeviceName();
+        final int deviceNumber = mEnvPcc.getAntDeviceNumber();
+        Log.d(TAG, "handleConnection deviceName=" + deviceName + " deviceNumber=" + deviceNumber);
+        if (deviceNumber != mDeviceNumber) {
+            Log.e(TAG, "device number mismatch");
+        }
+        mDeviceName = deviceName;
+        mEnvPcc.subscribeTemperatureDataEvent(mTemperatureDataReceiver);
+        mEnvPcc.subscribeRssiEvent(mRssiReceiver);
+        if (mObserver != null) {
+            mObserver.onDeviceInfoChanged();
+        }
+    }
+
+    public String getDeviceName() {
+        return mDeviceName;
+    }
+
+    public Reading getLastReading() {
+        return mLastReading;
+    }
+
+    public int getLastRssi() {
+        return mLastRssi;
+    }
+
+    public DeviceState getCurrentDeviceState() {
+        return mCurState;
+    }
+
+    public RequestAccessResult getConnectResult() {
+        return mConnectResult;
+    }
+
+    private AntPluginPcc.IPluginAccessResultReceiver<AntPlusEnvironmentPcc> mResultReceiver = new AntPluginPcc.IPluginAccessResultReceiver<AntPlusEnvironmentPcc>() {
+        @Override
+        public void onResultReceived(AntPlusEnvironmentPcc result, RequestAccessResult resultCode, DeviceState initialDeviceState) {
+            Log.d(TAG, "onResultReceived resultCode=" + resultCode + " initialDeviceState=" + initialDeviceState);
+            mConnectResult = resultCode;
+            mCurState = initialDeviceState;
+            if (resultCode.equals(RequestAccessResult.SUCCESS)) {
+                setEnvPcc(result);
+            }
+            if (mObserver != null) {
+                mObserver.onDeviceStateChanged();
+            }
+
+            if (resultCode.equals(RequestAccessResult.SEARCH_TIMEOUT)) {
+                Log.d(TAG, "timeout");
+            }
+        }
+    };
+
+    private AntPluginPcc.IDeviceStateChangeReceiver mDeviceStateChangeReceiver = new AntPluginPcc.IDeviceStateChangeReceiver() {
+        @Override
+        public void onDeviceStateChange(DeviceState newDeviceState) {
+            Log.d(TAG, "onDeviceStateChange newDeviceState=" + newDeviceState);
+            mCurState = newDeviceState;
+            if (mObserver != null) {
+                mObserver.onDeviceStateChanged();
+            }
+        }
+    };
+
+    private final AntPlusEnvironmentPcc.ITemperatureDataReceiver mTemperatureDataReceiver = new AntPlusEnvironmentPcc.ITemperatureDataReceiver() {
+        @Override
+        public void onNewTemperatureData(long estTimestamp, EnumSet<EventFlag> eventFlags, BigDecimal currentTemperature, long eventCount, BigDecimal lowLast24Hours, BigDecimal highLast24Hours) {
+            Log.d(TAG, "onNewTemperatureData");
+            mLastReading.timestamp = estTimestamp;
+            mLastReading.temperature = currentTemperature;
+            mLastReading.highLast24Hours = highLast24Hours;
+            mLastReading.lowLast24Hours = lowLast24Hours;
+            if (mObserver != null) {
+                mObserver.onDeviceNewReading();
+            }
+        }
+    };
+
+    private final AntPlusCommonPcc.IRssiReceiver mRssiReceiver = new AntPlusCommonPcc.IRssiReceiver() {
+        @Override
+        public void onRssiData(long estTimestamp, EnumSet<EventFlag> eventFlags, int rssi) {
+            Log.d(TAG, "onRssiData rssi=" + rssi);
+            mLastRssi = rssi;
+            if (mObserver != null) {
+                mObserver.onDeviceRssiChanged();
+            }
+        }
+    };
+
+    public static String deviceStateToString(Context context, DeviceState state) {
+        switch (state) {
+            case DEAD:
+                return context.getString(R.string.state_dead);
+            case CLOSED:
+                return context.getString(R.string.state_closed);
+            case SEARCHING:
+                return context.getString(R.string.state_searching);
+            case TRACKING:
+                return context.getString(R.string.state_tracking);
+            case PROCESSING_REQUEST:
+                return context.getString(R.string.state_processing);
+            case UNRECOGNIZED:
+                return context.getString(R.string.state_unrecognized);
+            default:
+                return context.getString(R.string.state_unknown);
+        }
+    }
+
+    public static String connectionRequestAccessResultToString(Context context, RequestAccessResult result) {
+        switch (result) {
+            case SUCCESS:
+                return context.getString(R.string.connection_result_success);
+            case USER_CANCELLED:
+                return context.getString(R.string.connection_result_user_cancelled);
+            case CHANNEL_NOT_AVAILABLE:
+                return context.getString(R.string.connection_result_channel_not_available);
+            case OTHER_FAILURE:
+                return context.getString(R.string.connection_result_other_failure);
+            case DEPENDENCY_NOT_INSTALLED:
+                return context.getString(R.string.connection_result_dependency_not_installed);
+            case DEVICE_ALREADY_IN_USE:
+                return context.getString(R.string.connection_result_device_already_in_use);
+            case SEARCH_TIMEOUT:
+                return context.getString(R.string.connection_result_search_timeout);
+            case ALREADY_SUBSCRIBED:
+                return context.getString(R.string.connection_result_already_subscribed);
+            case BAD_PARAMS:
+                return context.getString(R.string.connection_result_bad_params);
+            case ADAPTER_NOT_DETECTED:
+                return context.getString(R.string.connection_result_adapter_not_detected);
+            case UNRECOGNIZED:
+                return context.getString(R.string.connection_result_unrecognized);
+            default:
+                return context.getString(R.string.connection_result_unknown);
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/javispedro/rempe/DeviceListRecyclerViewListAdapter.java b/app/src/main/java/com/javispedro/rempe/DeviceListRecyclerViewListAdapter.java
new file mode 100644
index 0000000..2288f20
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/DeviceListRecyclerViewListAdapter.java
@@ -0,0 +1,44 @@
+package com.javispedro.rempe;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.List;
+
+/**
+ * {@link RecyclerView.Adapter} that can display a {@link Device}.
+ */
+public class DeviceListRecyclerViewListAdapter extends RecyclerView.Adapter<DeviceViewHolder> {
+
+    private List<Device> mList;
+
+    @Override
+    @NonNull
+    public DeviceViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        View view = LayoutInflater.from(parent.getContext())
+                .inflate(R.layout.fragment_device, parent, false);
+        return new DeviceViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(final DeviceViewHolder holder, int position) {
+        holder.setDevice(mList.get(position));
+    }
+
+    @Override
+    public int getItemCount() {
+        if (mList != null) {
+            return mList.size();
+        } else {
+            return 0;
+        }
+    }
+
+    public void setDeviceList(List<Device> list) {
+        mList = list;
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/javispedro/rempe/DeviceViewHolder.java b/app/src/main/java/com/javispedro/rempe/DeviceViewHolder.java
new file mode 100644
index 0000000..9731471
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/DeviceViewHolder.java
@@ -0,0 +1,123 @@
+package com.javispedro.rempe;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.dsi.ant.plugins.antplus.pcc.defines.RequestAccessResult;
+
+import java.math.BigDecimal;
+
+public class DeviceViewHolder extends RecyclerView.ViewHolder implements Device.DeviceObserver {
+    private static final String TAG = "DeviceViewHolder";
+
+    private final View mView;
+    private final Context mContext;
+
+    private final TextView mTemperatureView;
+    private final TextView mMinTemperatureView;
+    private final TextView mMaxTemperatureView;
+    private final TextView mNameView;
+    private final TextView mStatusView;
+    private final ProgressBar mSignalBar;
+    private final TextView mSignalLabel;
+
+    private Device mDevice;
+
+    public DeviceViewHolder(View view) {
+        super(view);
+        mView = view;
+        mContext = view.getContext();
+        mNameView = view.findViewById(R.id.nameView);
+        mStatusView = view.findViewById(R.id.statusView);
+        mTemperatureView = view.findViewById(R.id.temperatureView);
+        mMinTemperatureView = view.findViewById(R.id.minTemperatureView);
+        mMaxTemperatureView = view.findViewById(R.id.maxTemperatureView);
+        mSignalBar = view.findViewById(R.id.signalBar);
+        mSignalLabel = view.findViewById(R.id.signalLabel);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " '" + mNameView.getText() + "'";
+    }
+
+    public void setDevice(Device device) {
+        resetDisplay();
+        if (mDevice != null) {
+            mDevice.setObserver(null);
+        }
+        mDevice = device;
+        if (mDevice != null) {
+            mNameView.setText(mDevice.getDeviceName());
+            mDevice.setObserver(this);
+        }
+    }
+
+    private void runOnUiThread(Runnable r) {
+        mView.post(r);
+    }
+
+    private void resetDisplay() {
+        mTemperatureView.setText(mContext.getString(R.string.temperature_nothing));
+        mMinTemperatureView.setText(mContext.getString(R.string.temperature_nothing));
+        mMaxTemperatureView.setText(mContext.getString(R.string.temperature_nothing));
+        mNameView.setText("");
+        mStatusView.setText("");
+        mSignalBar.setProgress(0);
+        mSignalLabel.setVisibility(View.INVISIBLE);
+    }
+
+    private String formatTemperature(BigDecimal temp) {
+        final String value = temp.setScale(1, BigDecimal.ROUND_HALF_EVEN).toPlainString();
+        return mContext.getString(R.string.temperature_celsius, value);
+    }
+
+    @Override
+    public void onDeviceInfoChanged() {
+        runOnUiThread(() -> {
+            mNameView.setText(mDevice.getDeviceName());
+        });
+    }
+
+    @Override
+    public void onDeviceStateChanged() {
+        runOnUiThread(() -> {
+            if (mDevice.getConnectResult() != RequestAccessResult.SUCCESS) {
+                mStatusView.setText(Device.connectionRequestAccessResultToString(mContext, mDevice.getConnectResult()));
+            } else {
+                mStatusView.setText(Device.deviceStateToString(mContext, mDevice.getCurrentDeviceState()));
+            }
+        });
+    }
+
+    @Override
+    public void onDeviceNewReading() {
+        runOnUiThread(() -> {
+            final Reading reading = mDevice.getLastReading();
+            mTemperatureView.setText(formatTemperature(reading.temperature));
+            mMinTemperatureView.setText(formatTemperature(reading.lowLast24Hours));
+            mMaxTemperatureView.setText(formatTemperature(reading.highLast24Hours));
+        });
+    }
+
+    private int rssiToMeterValue(float rssi) {
+        final float minThreshold = -100;
+        final float maxThreshold = 0;
+
+        final float step = (maxThreshold - minThreshold) / 100;
+
+        return Math.round((rssi - minThreshold) / step);
+    }
+
+    @Override
+    public void onDeviceRssiChanged() {
+        runOnUiThread(() -> {
+            mSignalBar.setProgress(rssiToMeterValue(mDevice.getLastRssi()));
+            mSignalLabel.setVisibility(View.VISIBLE);
+        });
+    }
+}
diff --git a/app/src/main/java/com/javispedro/rempe/MainActivity.java b/app/src/main/java/com/javispedro/rempe/MainActivity.java
new file mode 100644
index 0000000..e458468
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/MainActivity.java
@@ -0,0 +1,264 @@
+package com.javispedro.rempe;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
+import androidx.preference.PreferenceManager;
+import androidx.recyclerview.widget.DiffUtil;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.ListUpdateCallback;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.dsi.ant.plugins.antplus.pcc.AntPlusEnvironmentPcc;
+import com.dsi.ant.plugins.antplus.pcc.defines.DeviceState;
+import com.dsi.ant.plugins.antplus.pcc.defines.RequestAccessResult;
+import com.dsi.ant.plugins.antplus.pccbase.AntPluginPcc;
+import com.dsi.ant.plugins.antplus.pccbase.PccReleaseHandle;
+import com.google.android.material.floatingactionbutton.FloatingActionButton;
+import com.google.android.material.snackbar.Snackbar;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainActivity extends AppCompatActivity {
+    private final static String TAG = "MainActivity";
+
+    private SharedPreferences mPrefs = null;
+    private SharedPreferences.OnSharedPreferenceChangeListener mPrefsListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
+        @Override
+        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+            switch (key) {
+                case Preferences.PREFS_DEVICES:
+                    refreshDevices();
+                    break;
+            }
+        }
+    };
+
+    private final ArrayList<Integer> mDeviceNumbers = new ArrayList<Integer>();
+    private final ArrayList<Device> mDevices = new ArrayList<Device>();
+
+    private DeviceListRecyclerViewListAdapter mDeviceListAdapter;
+
+    private PccReleaseHandle<AntPlusEnvironmentPcc> mPccSearchHandle;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
+
+        setContentView(R.layout.activity_main);
+        Toolbar toolbar = findViewById(R.id.toolbar);
+        setSupportActionBar(toolbar);
+
+        FloatingActionButton fab = findViewById(R.id.fabAddDevice);
+        fab.setOnClickListener(view -> onConnectButtonClicked());
+
+        RecyclerView list = findViewById(R.id.list);
+        list.setLayoutManager(new LinearLayoutManager(list.getContext()));
+        mDeviceListAdapter = new DeviceListRecyclerViewListAdapter();
+        list.setAdapter(mDeviceListAdapter);
+
+        refreshDevices();
+    }
+
+    @Override
+    protected void onDestroy() {
+        disconnectAll();
+        mPrefs = null;
+        mDeviceListAdapter = null;
+        super.onDestroy();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mPrefs.registerOnSharedPreferenceChangeListener(mPrefsListener);
+        connectToDevices();
+    }
+
+    @Override
+    public void onPause() {
+        disconnectAll();
+        mPrefs.unregisterOnSharedPreferenceChangeListener(mPrefsListener);
+        super.onPause();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        // Inflate the menu; this adds items to the action bar if it is present.
+        getMenuInflater().inflate(R.menu.menu_main, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle action bar item clicks here. The action bar will
+        // automatically handle clicks on the Home/Up button, so long
+        // as you specify a parent activity in AndroidManifest.xml.
+        int id = item.getItemId();
+
+        switch (id) {
+            case R.id.action_remove_all:
+                removeAllDevices();
+                return true;
+            case R.id.action_settings:
+                return true;
+        }
+
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void onConnectButtonClicked() {
+        searchForNewDevice();
+    }
+
+    public void searchForNewDevice() {
+        Log.d(TAG, "searchForNewDevice");
+        if (mPccSearchHandle != null) {
+            mPccSearchHandle.close();
+            mPccSearchHandle = null;
+        }
+        mPccSearchHandle = AntPlusEnvironmentPcc.requestAccess(this, this, mResultReceiver, mDeviceStateChangeReceiver);
+    }
+
+    private AntPluginPcc.IPluginAccessResultReceiver<AntPlusEnvironmentPcc> mResultReceiver = new AntPluginPcc.IPluginAccessResultReceiver<AntPlusEnvironmentPcc>() {
+        @Override
+        public void onResultReceived(AntPlusEnvironmentPcc result, RequestAccessResult resultCode, DeviceState initialDeviceState) {
+            Log.d(TAG, "onResultReceived resultCode=" + resultCode);
+            if (resultCode == RequestAccessResult.SUCCESS) {
+                int deviceNumber = result.getAntDeviceNumber();
+                result.releaseAccess();
+                runOnUiThread(() -> addDevice(result.getAntDeviceNumber()));
+            } else if (resultCode != RequestAccessResult.USER_CANCELLED) {
+                runOnUiThread(() -> {
+                    final String resultText = Device.connectionRequestAccessResultToString(MainActivity.this, resultCode);
+                    Snackbar.make(findViewById(R.id.fabAddDevice),
+                            getString(R.string.add_device_failed, resultText), Snackbar.LENGTH_INDEFINITE).show();
+                });
+            }
+            mPccSearchHandle.close();
+            mPccSearchHandle = null;
+        }
+    };
+
+    private AntPluginPcc.IDeviceStateChangeReceiver mDeviceStateChangeReceiver = new AntPluginPcc.IDeviceStateChangeReceiver() {
+        @Override
+        public void onDeviceStateChange(DeviceState newDeviceState) {
+            Log.d(TAG, "onDeviceStateChange newDeviceState=" + newDeviceState);
+        }
+    };
+
+    public void addDevice(int deviceNumber) {
+        Log.d(TAG, "addDevice " + deviceNumber);
+        List<Integer> list = Preferences.getDeviceNumbers(mPrefs);
+        if (list.contains(deviceNumber)) {
+            Snackbar.make(findViewById(R.id.fabAddDevice),
+                    getString(R.string.add_device_already), Snackbar.LENGTH_INDEFINITE).show();
+            return;
+        }
+        list.add(deviceNumber);
+        Preferences.saveDeviceNumbers(mPrefs, list);
+    }
+
+    public void removeAllDevices() {
+        List<Integer> list = new ArrayList<Integer>();
+        Preferences.saveDeviceNumbers(mPrefs, list);
+    }
+
+    public void refreshDevices() {
+        Log.d(TAG, "refreshDevices");
+
+        setDeviceNumberList(Preferences.getDeviceNumbers(mPrefs));
+    }
+
+    public void connectToDevices() {
+        Log.d(TAG, "connectToDevices");
+        for (Device dev : mDevices) {
+            if (!dev.isOpen()) {
+                dev.connect(this);
+            }
+        }
+    }
+
+    public void disconnectAll() {
+        Log.d(TAG, "disconnectAll");
+        for (Device dev : mDevices) {
+            dev.close();
+        }
+    }
+
+    void setDeviceNumberList(List<Integer> newDeviceNumbers) {
+            DiffUtil.DiffResult diff = DiffUtil.calculateDiff(new DiffUtil.Callback() {
+            @Override
+            public int getOldListSize() {
+                return mDeviceNumbers.size();
+            }
+
+            @Override
+            public int getNewListSize() {
+                return newDeviceNumbers.size();
+            }
+
+            @Override
+            public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
+                return mDeviceNumbers.get(oldItemPosition).equals(newDeviceNumbers.get(newItemPosition));
+            }
+
+            @Override
+            public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
+                return areItemsTheSame(oldItemPosition, newItemPosition);
+            }
+        });
+
+        diff.dispatchUpdatesTo(new ListUpdateCallback() {
+            @Override
+            public void onInserted(int position, int count) {
+                for (int i = 0; i < count; ++i) {
+                    final int deviceNumber = newDeviceNumbers.get(position + i);
+                    Device device = new Device(deviceNumber);
+                    mDeviceNumbers.add(position + i, deviceNumber);
+                    mDevices.add(position + i, device);
+                }
+            }
+
+            @Override
+            public void onRemoved(int position, int count) {
+                for (int i = 0; i < count; ++i) {
+                    mDevices.get(position + i).close();
+                }
+                mDevices.subList(position, position + count).clear();
+                mDeviceNumbers.subList(position, position + count).clear();
+            }
+
+            @Override
+            public void onMoved(int fromPosition, int toPosition) {
+                mDevices.set(toPosition, mDevices.get(fromPosition));
+                mDevices.set(fromPosition, null);
+                mDeviceNumbers.set(toPosition, mDeviceNumbers.get(fromPosition));
+                mDeviceNumbers.set(fromPosition, 0);
+            }
+
+            @Override
+            public void onChanged(int position, int count, @Nullable Object payload) {
+                // Nothing to be done
+            }
+        });
+
+        if (mDeviceListAdapter != null) {
+            mDeviceListAdapter.setDeviceList(mDevices);
+            diff.dispatchUpdatesTo(mDeviceListAdapter);
+        }
+    }
+
+    public List<Integer> getDeviceNumberList() {
+        return mDeviceNumbers;
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/javispedro/rempe/Preferences.java b/app/src/main/java/com/javispedro/rempe/Preferences.java
new file mode 100644
index 0000000..41c943c
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/Preferences.java
@@ -0,0 +1,43 @@
+package com.javispedro.rempe;
+
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import static android.content.ContentValues.TAG;
+
+class Preferences {
+    public final static String PREFS_DEVICES = "devices";
+
+    public static List<Integer> getDeviceNumbers(SharedPreferences prefs) {
+        ArrayList<Integer> result = new ArrayList<Integer>();
+
+        try {
+            StringTokenizer st = new StringTokenizer(prefs.getString(PREFS_DEVICES, ""), ",");
+            while (st.hasMoreTokens()) {
+                result.add(Integer.parseInt(st.nextToken()));
+            }
+        } catch (java.lang.Exception ex) {
+            // Ensure that at least we can recover from a corrupted preferences situation...
+            Log.e(TAG, ex.toString());
+        }
+
+        return result;
+    }
+
+    public static void saveDeviceNumbers(SharedPreferences prefs, List<Integer> list) {
+        StringBuilder sb = new StringBuilder();
+        for (Integer i : list) {
+            sb.append(i.toString());
+            sb.append(",");
+        }
+        final String pref = sb.toString();
+        Log.d(TAG, "saveDeviceNumbers: " + pref);
+        SharedPreferences.Editor editor = prefs.edit();
+        editor.putString(PREFS_DEVICES, pref);
+        editor.apply();
+    }
+}
diff --git a/app/src/main/java/com/javispedro/rempe/Reading.java b/app/src/main/java/com/javispedro/rempe/Reading.java
new file mode 100644
index 0000000..a49e29a
--- /dev/null
+++ b/app/src/main/java/com/javispedro/rempe/Reading.java
@@ -0,0 +1,12 @@
+package com.javispedro.rempe;
+
+import java.math.BigDecimal;
+
+public class Reading {
+    public long timestamp;
+
+    public BigDecimal temperature;
+
+    public BigDecimal lowLast24Hours;
+    public BigDecimal highLast24Hours;
+}