feature(history): store data each hour

App/Screens/Loading/Loading.js

@@ -17,14 +17,17 @@
 import React, { Component } from 'react';
 import { inject, observer } from 'mobx-react';
 import * as Permissions from 'expo-permissions';
+import * as TaskManager from 'expo-task-manager';
 import * as Location from 'expo-location';
 import retry from 'async-retry';
 import { StyleSheet, Text } from 'react-native';
-
 import { Background } from './Background';
-import { i18n } from '../../localization';
 import * as dataSources from '../../utils/dataSources';
 import * as theme from '../../utils/theme';
+import { i18n } from '../../localization';
+import { AqiHistoryDb } from '../../managers';
+
+const TASK_STORE_AQI_HISTORY = 'store-aqi-history';
 
 @inject('stores')
 @observer
@@ -35,8 +38,9 @@ export class Loading extends Component {
 
   longWaitingTimeout = null; // The variable returned by setTimeout for longWaiting
 
-  componentDidMount () {
-    this.fetchData();
+  async componentDidMount () {
+    await this.fetchData();
+    await this._startRecordingAqiHistory();
   }
 
   componentWillUnmount () {
@@ -45,6 +49,36 @@ export class Loading extends Component {
     }
   }
 
+  _startRecordingAqiHistory = async () => {
+    await Location.startLocationUpdatesAsync(TASK_STORE_AQI_HISTORY, {
+      accuracy: Location.Accuracy.BestForNavigation,
+      timeInterval: AqiHistoryDb.SAVE_DATA_INTERVAL,
+      distanceInterval: 0
+    });
+  };
+
+  _apiCall = async (currentPosition) => {
+    // We currently have 2 sources, aqicn, and windWaqi
+    // We put them in an array
+    const sources = [dataSources.aqicn, dataSources.windWaqi];
+
+    return retry(
+      async (_, attempt) => {
+        // Attempt starts at 1
+        console.log(
+          `<Loading> - fetchData - Attempt #${attempt}: ${
+            sources[(attempt - 1) % 2].name
+          }`
+        );
+        const result = await sources[(attempt - 1) % 2](currentPosition);
+        console.log('<Loading> - fetchData - Got result', result);
+
+        return result;
+      },
+      { retries: 3 } // 2 attempts per source
+    );
+  };
+
   async fetchData () {
     const { stores } = this.props;
     const { location } = stores;
@@ -84,34 +118,14 @@ export class Loading extends Component {
         location.setGps(coords);
       }
 
-      // We currently have 2 sources, aqicn, and windWaqi
-      // We put them in an array
-      const sources = [dataSources.aqicn, dataSources.windWaqi];
-
       // Set a 2s timer that will set `longWaiting` to true. Used to show an
       // additional "cough" message on the loading screen
       this.longWaitingTimeout = setTimeout(
         () => this.setState({ longWaiting: true }),
         2000
       );
 
-      const api = await retry(
-        async (_, attempt) => {
-          // Attempt starts at 1
-          console.log(
-            `<Loading> - fetchData - Attempt #${attempt}: ${
-              sources[(attempt - 1) % 2].name
-            }`
-          );
-          const result = await sources[(attempt - 1) % 2](currentPosition);
-          console.log('<Loading> - fetchData - Got result', result);
-
-          return result;
-        },
-        { retries: 3 } // 2 attemps per source
-      );
-
-      stores.setApi(api);
+      stores.setApi(await this._apiCall(currentPosition));
     } catch (error) {
       console.log('<Loading> - fetchData - Error', error);
       stores.setError(error.message);
@@ -159,6 +173,41 @@ export class Loading extends Component {
   };
 }
 
+TaskManager.defineTask(TASK_STORE_AQI_HISTORY, async ({ data, error }) => {
+  if (error) {
+    console.log('<Loading> - TaskManager - defineTask - Error', error.message);
+    return;
+  }
+  if (data) {
+    const { locations } = data;
+    const { coords } = locations[0];
+
+    // We currently have 2 sources, aqicn, and windWaqi
+    // We put them in an array
+    const sources = [dataSources.aqicn, dataSources.windWaqi];
+
+    const api = await retry(
+      async (_, attempt) => {
+        // Attempt starts at 1
+        console.log(
+          `<Loading> - fetchData - Attempt #${attempt}: ${
+            sources[(attempt - 1) % 2].name
+          }`
+        );
+        const result = await sources[(attempt - 1) % 2](coords);
+        console.log('<Loading> - fetchData - Got result', result);
+
+        return result;
+      },
+      { retries: 3 } // 2 attempts per source
+    );
+
+    if (await AqiHistoryDb.isSaveNeeded()) {
+      await AqiHistoryDb.saveData(api.city.name, api.rawPm25, coords);
+    }
+  }
+});
+
 const styles = StyleSheet.create({
   dots: {
     color: theme.primaryColor

App/managers/AqiHistory.js

@@ -0,0 +1,43 @@
+class AqiHistory {
+  _id;
+  _location;
+  _lat;
+  _lng;
+  _rawPm25;
+  _creationTime;
+
+  constructor ({ id, location, lat, lng, rawPm25, creationTime }) {
+    this._id = id;
+    this._location = location;
+    this._lat = lat;
+    this._lng = lng;
+    this._rawPm25 = rawPm25;
+    this._creationTime = creationTime;
+  }
+
+  get id () {
+    return this._id;
+  }
+
+  get location () {
+    return this._location;
+  }
+
+  get lat () {
+    return this._lat;
+  }
+
+  get lng () {
+    return this._lng;
+  }
+
+  get rawPm25 () {
+    return this._rawPm25;
+  }
+
+  get creationTime () {
+    return this._creationTime;
+  }
+}
+
+export default AqiHistory;

App/managers/AqiHistoryDb.js

@@ -0,0 +1,88 @@
+import { SQLite } from 'expo-sqlite';
+import AqiHistory from './AqiHistory';
+
+export const SAVE_DATA_INTERVAL = 3600000; // 1 hour
+const DB_AQI_HISTORY = 'aqi-history';
+
+export const initDb = () => {
+  return SQLite.openDatabase(DB_AQI_HISTORY, '1.0', 'Aqi History', 5 * 1024 * 1024);
+};
+
+export const init = async () => {
+  const db = await initDb();
+
+  await db.transaction((tx) => {
+    tx.executeSql(
+      'create table if not exists history(id integer primary key autoincrement, location varchar(255) not null, lat numeric not null, lng numeric not null, rawPm25 decimal not null, creationTime timestamp not null)',
+      [],
+      () => {},
+      (transaction, error) => console.log('DB init error', error)
+    );
+  });
+
+  return db;
+};
+
+export const isSaveNeeded = async () => {
+  const db = await init();
+
+  const promise = new Promise((resolve, reject) => {
+    db.readTransaction((tx) => {
+      tx.executeSql(
+        'select * from history order by id desc limit 1',
+        [],
+        (transaction, resultSet) => {
+          if (resultSet.rows.length === 0) {
+            resolve(true);
+          } else if ((resultSet.rows.item(0).creationTime + SAVE_DATA_INTERVAL) < Date.now()) {
+            resolve(true);
+          } else {
+            resolve(false);
+          }
+        },
+        (transaction, error) => reject(error)
+      );
+    });
+  });
+
+  return promise;
+};
+
+export const saveData = async (location, rawPm25, { latitude, longitude }) => {
+  const db = await init();
+
+  db.transaction((tx) => {
+    tx.executeSql(
+      'insert into history (location, lat, lng, rawPm25, creationTime) values (?, ?, ?, ?, ?)',
+      [location, latitude, longitude, rawPm25, Date.now()],
+      () => {},
+      (transaction, error) => console.log('DB insert error', error)
+    );
+  });
+};
+
+export const getData = async (limit) => {
+  const db = await init();
+
+  const promise = new Promise((resolve, reject) => {
+    db.readTransaction((tx) => {
+      tx.executeSql(
+        'select * from history order by creationTime desc limit ' + limit,
+        [],
+        (transaction, resultSet) => {
+          let data = [];
+
+          for (let i = 0; i < resultSet.rows.length; i++) {
+            const result = new AqiHistory(resultSet.rows.item(i));
+            data.push(result);
+          }
+
+          resolve(data);
+        },
+        (transaction, error) => reject(error)
+      );
+    });
+  });
+
+  return promise;
+};

App/managers/index.js

@@ -0,0 +1,5 @@
+import * as AqiHistoryDb from './AqiHistoryDb';
+
+export {
+  AqiHistoryDb
+};