private void RegisterSensorNameUnderSensorType(BaseSensorReading aSensorReading)
{
if (!SensorTypeToSensorNameListMap[aSensorReading.sensorType].Contains(aSensorReading.sensorName))
{
SensorTypeToSensorNameListMap[aSensorReading.sensorType].Add(aSensorReading.sensorName);
}
}
/// <summary>
/// Primary utility method/callback which adds a newly generated sensor reading
/// into the current sensor stream.
/// </summary>
/// <param name="newSensorReading">New sensor reading to be added.</param>
private void AddSensorDataToSensorStream(BaseSensorReading newSensorReading)
{
if (IsSensorStreamActive)
{
CurrentSensorStream.AddSensorData(newSensorReading);
}
}
/// <summary>
/// Parent utility method for generating a sensor reading and notifying
/// listeners of the generation of the sensor reading.
/// </summary>
protected virtual void GenerateBaseSensorReading()
{
BaseSensorReading newBaseSensorReading = new BaseSensorReading();
UpdateDetailsInSensorReading(newBaseSensorReading);
PublishSensorReading(newBaseSensorReading);
}
/// <summary>
/// Helper method which notifies listeners of newly generated sensor readings.
/// </summary>
/// <param name="sensorReading">Sensor reading which is sent to listeners via event.</param>
protected void PublishSensorReading(BaseSensorReading sensorReading)
{
if (GenerateSensorReadingEvent != null)
{
GenerateSensorReadingEvent(sensorReading);
}
}
private List <BaseSensorReading> SortSensorReadingsList(List <BaseSensorReading> sensorReadings)
{
BaseSensorReading[] sensorReadingsArray = sensorReadings.ToArray();
if (sensorReadingsArray.Length > 1)
{
int initPos = 1;
while (initPos < sensorReadingsArray.Length)
{
int listPos = initPos;
while ((listPos > 0) && (sensorReadingsArray[listPos - 1].
CompareToDateTime(sensorReadingsArray[listPos]) > 0))
{
BaseSensorReading sensorReadingA = sensorReadingsArray[listPos];
sensorReadingsArray[listPos] = sensorReadingsArray[listPos - 1];
sensorReadingsArray[listPos - 1] = sensorReadingA;
listPos--;
}
initPos++;
}
}
sensorReadings.Clear();
for (int i = 0; i < sensorReadingsArray.Length; i++)
{
sensorReadings.Add(sensorReadingsArray[i]);
}
return(sensorReadings);
}
private void RegisterSensorType(BaseSensorReading aSensorReading)
{
// Add sensor name to list under appropriate sensor type
if (!SensorTypeToSensorNameListMap.ContainsKey(aSensorReading.sensorType))
{
SensorTypeToSensorNameListMap.Add(aSensorReading.sensorType, new List <string>());
}
}
public bool DoesSensorReadingOccurInBookmark(BaseSensorReading aSensorReading)
{
if ((StartDateTime <= aSensorReading.dateTime) && (aSensorReading.dateTime <= EndDateTime))
{
return(true);
}
return(false);
}
public bool TriggerPublishSensorEvent(BaseSensorReading aSensorReading)
{
if (PublishSensorReadingEvent != null)
{
PublishSensorReadingEvent(aSensorReading);
return(true);
}
return(false);
}
private void AddSensorReadingToSensorNameMap(BaseSensorReading aSensorReading)
{
// Add sensor reading to list under appropriate sensor name
if (!SensorNameToSensorReadingsMap.ContainsKey(aSensorReading.sensorName))
{
SensorNameToSensorReadingsMap.Add(aSensorReading.sensorName, new List <BaseSensorReading>());
}
SensorNameToSensorReadingsMap[aSensorReading.sensorName].Add(aSensorReading);
}
private void RegisterBookmarkName(List <string> bookmarkNames, Dictionary <string, List <int> > bookmarkNameToSessionIDMap,
BaseSensorReading aSensorReading)
{
// Add new sensor bookmark names to relevant data structures
if (!bookmarkNames.Contains(aSensorReading.sensorBookmarkName))
{
bookmarkNames.Add(aSensorReading.sensorBookmarkName);
BookmarkNameToSessionIDToSensorReadingsListMap.
Add(aSensorReading.sensorBookmarkName, new Dictionary <int, List <BaseSensorReading> >());
bookmarkNameToSessionIDMap.Add(aSensorReading.sensorBookmarkName, new List <int>());
}
}
/// <summary>
/// Utility method which generates the SQL string for inserting a sensor reading
/// into a specified table in the database.
/// </summary>
/// <param name="aSensorReading">Sensor reading to be inserted.</param>
/// <param name="bookmarkName">Bookmark name associated with the sensor reading.</param>
/// <param name="sessionID">Session ID associated with the sensor reading.</param>
/// <param name="tableName">Name of table which will be storing the sensor reading.</param>
/// <returns>SQL string for inserting the specified sensor reading into a specified table in the database.</returns>
public static string InsertSensorReadingSQLString(BaseSensorReading aSensorReading,
string bookmarkName, int sessionID, string tableName)
{
return("INSERT OR REPLACE INTO " + tableName + " ("
+ COL_SENSOR_TYPE + "," + COL_SENSOR_AREA + "," + COL_SENSOR_NAME + ","
+ COL_SENSOR_DATE_YEAR + "," + COL_SENSOR_DATE_MONTH + "," + COL_SENSOR_DATE_DAY + ","
+ COL_SENSOR_TIME_HOURS + "," + COL_SENSOR_TIME_MINUTES + "," + COL_SENSOR_TIME_SECONDS + ","
+ COL_SENSOR_VALUE + "," + COL_SENSOR_BOOKMARK_NAME + "," + COL_SESSION_ID
+ ") VALUES (" + "'"
+ aSensorReading.sensorType + "','" + aSensorReading.areaName + "','" + aSensorReading.sensorName + "',"
+ aSensorReading.dateTime.Year + "," + aSensorReading.dateTime.Month + "," + aSensorReading.dateTime.Day + ","
+ aSensorReading.dateTime.Hour + "," + aSensorReading.dateTime.Minute + "," + aSensorReading.dateTime.Second + ","
+ aSensorReading.GetSensorValue() + ",'" + bookmarkName + "'," + sessionID + ")");
}
public void InsertingSensorReading()
{
DBInstance dbInstance = new DBInstance("sensor_readings");
dbInstance.InitialiseSQLiteConnection();
string newTableName = "testTable";
dbInstance.ExecuteNonQuery(SensorReadingTableDetails.CreateTableSQLString(newTableName));
int numberOfRowsBeforeAddition = dbInstance.GetNumberOfRowsInTable(newTableName);
Debug.Log("Number of rows in table before addition: " + numberOfRowsBeforeAddition);
BaseSensorReading newSensorReading = new BaseSensorReading
{
sensorName = " ",
sensorType = Sensor.Type.Interaction,
areaName = " "
};
newSensorReading.SetDateTime(1, 1, 1, 1, 1, 1);
string insertSensorReadingString = SensorReadingTableDetails.InsertSensorReadingSQLString(newSensorReading, "testBookmark", 0, newTableName);
Debug.Log(insertSensorReadingString);
dbInstance.ExecuteNonQuery(insertSensorReadingString);
int numberOfRowsAfterAddition = dbInstance.GetNumberOfRowsInTable(newTableName);
Debug.Log("Number of rows in table after addition: " + numberOfRowsAfterAddition);
dbInstance.ExecuteNonQuery(SensorReadingTableDetails.DropTableSQLString(newTableName));
dbInstance.CloseSQLiteConnection();
if (numberOfRowsBeforeAddition == numberOfRowsAfterAddition - 1)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
/// <summary>
/// Helper method which creates a base sensor reading object using the specified sensor
/// reading data. Used to construct sensor reading objects from database data.
/// </summary>
/// <param name="sensorArea">Area of where sensor reading was generated.</param>
/// <param name="sensorName">Unique identifier of sensor which generated the sensor reading.</param>
/// <param name="year">Year (Date) of when sensor reading was generated.</param>
/// <param name="month">Month (Date) of when sensor reading was generated.</param>
/// <param name="day">Day (Date) of when sensor reading was generated.</param>
/// <param name="hours">Hours (Time) of when sensor reading was generated.</param>
/// <param name="minutes">Minutes (Time) of when sensor reading was generated.</param>
/// <param name="seconds">Seconds (Time) of when sensor reading was generated.</param>
/// <param name="sensorValue">Value associated with the sensor reading.</param>
/// <param name="sensorType">Sensor type which generated the sensor reading.</param>
/// <returns></returns>
private BaseSensorReading ConstructSensorReading(string sensorArea, string sensorName,
int year, int month, int day, int hours, int minutes, int seconds, float sensorValue,
Sensor.Type sensorType)
{
BaseSensorReading newSensorReading;
switch (sensorType)
{
// Float sensor reading format for light, temperature.
case Sensor.Type.Light:
case Sensor.Type.Temperature:
newSensorReading = new FloatSensorReading
{
sensorValue = sensorValue,
};
break;
// Boolean sensor reading format for presence, toggle
case Sensor.Type.Presence:
case Sensor.Type.Toggle:
newSensorReading = new BoolSensorReading
{
sensorValue = Convert.ToBoolean(sensorValue)
};
break;
// Base sensor reading format for interaction
default:
newSensorReading = new BaseSensorReading();
break;
}
// Set the base attributes for the sensor reading
newSensorReading.areaName = sensorArea;
newSensorReading.sensorName = sensorName;
newSensorReading.sensorType = sensorType;
newSensorReading.SetDateTime(year, month, day, hours, minutes, seconds);
return(newSensorReading);
}
/// <summary>
/// Helper method for updating the name, type, date, time, and area details
/// for sensor readings.
/// </summary>
/// <param name="newSensorReading">Sensor reading for which details are to be updated.</param>
protected void UpdateDetailsInSensorReading(BaseSensorReading newSensorReading)
{
if (newSensorReading != null)
{
newSensorReading.sensorName = SensorName;
newSensorReading.sensorType = SensorType;
newSensorReading.dateTime = System.DateTime.MaxValue;
if (TimeController.Instance)
{
newSensorReading.dateTime = TimeController.Instance.GetCurrentTime(newSensorReading.dateTime);
}
else
{
Debug.LogError("Time controller instance does not exist in the scene.");
}
if (DateController.Instance)
{
newSensorReading.dateTime = DateController.Instance.GetCurrentDate(newSensorReading.dateTime);
}
else
{
Debug.LogError("Date controller instance does not exist in the scene.");
}
/*
* Assumes that the sensor is:
* 1.) Attached to a home object
* 2.) The home object is categorised under a parent game object indicating the environment area
*
* Future implementations should utilise editor tools to create these objects at runtime, allowing
* code to do the heavy lifting with categorisation and referencing of various attributes.
*/
newSensorReading.areaName = transform.parent.parent.name;
}
}
/// <summary>
/// Helper method which acquires all sensor readings from a specified table in the connected
/// database.
/// </summary>
/// <param name="tableName">Name of table to evaluate in the connected database.</param>
/// <returns>List of sensor readings from the specified table in the connected database.</returns>
public List <BaseSensorReading> GetSensorReadingsFromTable(string tableName)
{
List <BaseSensorReading> sensorReadings = new List <BaseSensorReading>();
dbConnection.Open();
dbCommand.CommandText = "SELECT * FROM " + tableName;
dbReader = dbCommand.ExecuteReader();
// Iterate through all data records
while (dbReader.Read())
{
// Extract appropriate data from records
string sensorType = dbReader.GetString(0);
string sensorArea = dbReader.GetString(1);
string sensorName = dbReader.GetString(2);
int year = dbReader.GetInt16(3);
int month = dbReader.GetInt16(4);
int day = dbReader.GetInt16(5);
int hours = dbReader.GetInt16(6);
int minutes = dbReader.GetInt16(7);
int seconds = dbReader.GetInt16(8);
float sensorValue = dbReader.GetFloat(9);
string sensorBookmarkName = dbReader.GetString(10);
int sessionID = dbReader.GetInt16(11);
// Create sensor reading using extracted data and add it to list
BaseSensorReading newSensorReading = ConstructSensorReading(sensorArea, sensorName, year, month,
day, hours, minutes, seconds, sensorValue, Sensor.StringToSensorType(sensorType));
newSensorReading.sensorBookmarkName = sensorBookmarkName;
newSensorReading.sessionID = sessionID;
sensorReadings.Add(newSensorReading);
}
dbConnection.Close();
return(sensorReadings);
}
public virtual int CompareToDateTime(BaseSensorReading anotherSensorReading)
{
return(dateTime.CompareTo(anotherSensorReading.dateTime));
}
/// <summary>
/// Utility, helper method for inserting a sensor reading into a table in the connected database.
/// </summary>
/// <param name="sensorReading">Sensor reading to be inserted.</param>
/// <param name="bookmarkName">Name of bookmark associated with the sensor reading.</param>
/// <param name="sessionID">Session ID associated with the sensor reading.</param>
/// <param name="tableName">Name of table who will be storing the sensor reading.</param>
public static void InsertSensorReadingInDatabaseTable(BaseSensorReading sensorReading, string bookmarkName, int sessionID, string tableName)
{
dbInstance.ExecuteNonQuery(SensorReadingTableDetails.InsertSensorReadingSQLString(sensorReading, bookmarkName, sessionID, tableName));
}
public void AddSensorData(BaseSensorReading newSensorReading)
{
sensorReadings.Add(newSensorReading);
}
private void AddSensorReadingToSessionIDMap(BaseSensorReading aSensorReading)
{
BookmarkNameToSessionIDToSensorReadingsListMap[aSensorReading.sensorBookmarkName][aSensorReading.sessionID].Add(aSensorReading);
}
private void RegisterSessionID(Dictionary <string, List <int> > bookmarkNameToSessionIDMap, BaseSensorReading aSensorReading)
{
// Add session ID to relevant data structures
if (!bookmarkNameToSessionIDMap[aSensorReading.sensorBookmarkName].Contains(aSensorReading.sessionID))
{
bookmarkNameToSessionIDMap[aSensorReading.sensorBookmarkName].
Add(aSensorReading.sessionID);
BookmarkNameToSessionIDToSensorReadingsListMap[aSensorReading.sensorBookmarkName].
Add(aSensorReading.sessionID, new List <BaseSensorReading>());
}
}
