de.tudarmstadt.dvs.myhealthassistant.myhealthhub.sensormodules.AbstractSensorModule.java Source code

Introduction

Here is the source code for de.tudarmstadt.dvs.myhealthassistant.myhealthhub.sensormodules.AbstractSensorModule.java

Source

/* 
 * Copyright (C) 2014 TU Darmstadt, Hessen, Germany.
 * Department of Computer Science Databases and Distributed Systems
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
* 
*/
package de.tudarmstadt.dvs.myhealthassistant.myhealthhub.sensormodules;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.content.Context;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
import de.tudarmstadt.dvs.myhealthassistant.myhealthhub.events.AbstractChannel;
import de.tudarmstadt.dvs.myhealthassistant.myhealthhub.events.Event;
import de.tudarmstadt.dvs.myhealthassistant.myhealthhub.events.sensorreadings.SensorReadingEvent;
import de.tudarmstadt.dvs.myhealthassistant.myhealthhub.events.sensorreadings.cardiovascular.HeartRateEvent;
import de.tudarmstadt.dvs.myhealthassistant.myhealthhub.services.transformationmanager.database.LocalTransformationDBMS;

/**
 * @author Christian Seeger
 *
 */
public abstract class AbstractSensorModule {

    protected String moduleID;
    protected Context context;

    public AbstractSensorModule(final String moduleID, Context context) {
        this.moduleID = moduleID;
        this.context = context;
    }

    /**
     * Starts the sensor module. For passive modules, a corresponding
     * port is opened. For active modules, the module tries to connect
     * to the sensors.
     */
    public abstract void start();

    /**
     * Stops the sensor module. It cancels open connections and 
     * closes open ports.
     */
    public abstract void stop();

    /**
     * Initializes the sensor module by sending an advertisement message.
     */
    public abstract void initializeSensorModule();

    /**
     * Stops the sensor module and sends an un-advertisement message.
     */
    public abstract void destroySensorModule();

    /**
     * Returns the event type which is produced by this sensor module. 
     * @return event type 
     */
    public abstract String getProducingEventType();

    /**
     * Returns true if the module actively establishes a connection to its sensor.
     * @return true if active module
     */
    public abstract boolean isActiveModule();

    /**
     * Returns true if module is currently connected to sensor, otherwise false.
     * @return true if connected.
     */
    public abstract boolean isConnected();

    /**
     * Returns the module's ID.
     * @return ID
     */
    public String getModuleID() {
        return moduleID;
    }

    /**
     * Sends an event to a specific channel using the LocalBroadcastManager
     * @param Event to send
     * @param Channel on which the event is sent
     */
    protected void sendToChannel(Event evt, String channel) {
        Intent i = new Intent();
        i.putExtra(Event.PARCELABLE_EXTRA_EVENT_TYPE, evt.getEventType());
        i.putExtra(Event.PARCELABLE_EXTRA_EVENT, evt);
        i.setAction(channel);
        LocalBroadcastManager.getInstance(context).sendBroadcast(i);
    }

    /**
     * Sends an event to the managment channel.
     * @param management event
     */
    protected void sendManagementEvent(Event evt) {
        sendToChannel(evt, AbstractChannel.MANAGEMENT);
    }

    /**
     * Sends an event to the reading channel.
     * @param sensor reading
     */
    protected void sendSensorReading(Event evt) {
        sendToChannel(evt, AbstractChannel.RECEIVER);
        if (evt.getEventType().equals(SensorReadingEvent.HEART_RATE)) {
            Log.e("AbstractSensor", "this's heartrate event");
            storeHeartRateEvent((HeartRateEvent) evt);
        }
    }

    private void storeHeartRateEvent(HeartRateEvent evt) {
        LocalTransformationDBMS db = new LocalTransformationDBMS(this.context);
        db.open();
        String timeStp = evt.getTimeOfMeasurement();
        double yValue = evt.getValue();
        double xValue = convertTimeToDouble(timeStp, "yyyy-MM-dd kk:mm:ss", "kk.mm");
        String time = getDayFromDate(timeStp, "yyyy-MM-dd kk:mm:ss", "dd-MM-yyyy");
        db.addTraffic(time, 999, xValue, yValue);
        db.addDateOfTraffic(time, 0);
        db.close();
    }

    private String getDayFromDate(String timeOfMeasurement, String dateFormat, String applyPattern) {
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);

        try {
            Date today = sdf.parse(timeOfMeasurement);
            sdf.applyPattern(applyPattern);

            return sdf.format(today);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

    private static double convertTimeToDouble(String fullTime, String dateFormat, String applyPattern) {
        SimpleDateFormat fullDate = new SimpleDateFormat(dateFormat);
        SimpleDateFormat timeDate = new SimpleDateFormat(applyPattern);

        try {
            Date now = fullDate.parse(fullTime);
            String strDate = timeDate.format(now);
            double parseDate = Double.parseDouble(strDate);
            if (parseDate >= 24.00d)
                return parseDate - 24;
            return parseDate;

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return Double.parseDouble("00.00");
    }
}