Merge lp:~martin-borho/ubuntu-weather-app/backend-upgrade into lp:ubuntu-weather-app/obsolete.trunk

[Martin Borho]

Improvements to API-Worker to reduce HTTP calls against weather api.

- Weather data will not get refreshed unless stored data is older than 30min or an refresh is forced.
- Metric and imperial values are getting precalculated in API-Worker now. Refresh of weather data isn't neccessary anymore after changing scale in settings.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:40
http://91.189.93.125:8080/job/ubuntu-weather-app-ci/20/
Executed test runs:
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-weather-app-quantal-amd64-ci/17
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-weather-app-raring-amd64-ci/20

Click here to trigger a rebuild:
http://91.189.93.125:8080/job/ubuntu-weather-app-ci/20/rebuild

review: Approve (continuous-integration)

[Raúl Yeguas (neokore)]

review: Approve

=== modified file 'components/LocationTab.qml'
--- components/LocationTab.qml	2013-06-12 17:44:34 +0000
+++ components/LocationTab.qml	2013-06-14 13:37:21 +0000
@@ -19,7 +19,8 @@
 
     Component.onCompleted: {
         var locData = mainView.locationsList[locationIndex],
-            currentData = locData.current.results;
+            currentData = locData.current.results,
+            units = (mainView.settings.units === 'imperial') ? 'imperial' : 'metric';
 
         // set location data as property
         locationData = locData;
@@ -32,9 +33,9 @@
         // set current Condition
         currentCondition.condition = currentData.condition.id;
         currentCondition.icon = currentData.condition.icon;
-        currentCondition.currentTemp =  currentData.temp;
-        currentCondition.minTemp = currentData.temp_min;
-        currentCondition.maxTemp = currentData.temp_max;
+        currentCondition.currentTemp =  currentData[units].temp;
+        currentCondition.minTemp = currentData[units].temp_min;
+        currentCondition.maxTemp = currentData[units].temp_max;
 
         // set daily forecasts
         var dailyForecasts = locationData.daily.results,
@@ -43,8 +44,8 @@
             dayForecastModel.append({
                 dateRel: "",//Tomorrow",
                 date: formatTimestamp(dailyForecasts[x].timestamp, 'dddd, dd MMMM yyyy'),
-                temp: dailyForecasts[x].max,
-                tempMin: dailyForecasts[x].min,
+                temp: dailyForecasts[x][units].max,
+                tempMin: dailyForecasts[x][units].min,
                 cond: dailyForecasts[x].condition.id,
                 condIcon: dailyForecasts[x].condition.icon
             });
@@ -61,7 +62,7 @@
                 text: i18n.tr("Refresh")
 
                 onTriggered: {
-                    mainView.refreshData();
+                    mainView.refreshData(false, true);
                 }
             }
             Action {

=== modified file 'components/SettingsDialog.qml'
--- components/SettingsDialog.qml	2013-06-12 17:13:32 +0000
+++ components/SettingsDialog.qml	2013-06-14 13:37:21 +0000
@@ -52,7 +52,7 @@
                     for(var settingName in storedSettings) {
                         settings[settingName] = storedSettings[settingName];
                     }
-                    refreshData();
+                    refreshData(true);
                 });
             }
         }

=== modified file 'components/Storage.qml'
--- components/Storage.qml	2013-06-09 15:42:41 +0000
+++ components/Storage.qml	2013-06-14 13:37:21 +0000
@@ -83,6 +83,7 @@
                 for(var i = 0; i < rs.rows.length; i++) {
                     var row = rs.rows.item(i),
                         locData = JSON.parse(row.data);
+                    locData["updated"] = parseInt(row.date, 10);
                     locData["db"] = {id: row.id, updated: new Date(parseInt(row.date, 10))};
                     locations.push(locData);
                 }

=== modified file 'components/WeatherApi.js'
--- components/WeatherApi.js	2013-06-12 16:41:07 +0000
+++ components/WeatherApi.js	2013-06-14 13:37:21 +0000
@@ -1,11 +1,25 @@
 .pragma library
+/**
+*  Version of the response data format.
+*  Increase this number to force a refresh.
+*/
+var RESPONSE_DATA_VERSION = 1;
+
+/**
+* Helper functions
+*/
+function calcFahrenheit(celsius) {
+        return celsius * 1.8 + 32;
+}
+function calcMph(kmh) {
+        return kmh*0.62137;
+}
 
 var OpenWeatherMapApi = (function() {
     /**
       provides neccessary methods for requesting and preparing data from OpenWeatherMap.org
     */
     var _baseUrl = "http://api.openweathermap.org/data/2.5/";
-
     //
     function _buildSearchResult(request, data) {
         var searchResult = {
@@ -31,12 +45,20 @@
         var result = {
             timestamp: data.dt,
             date: (data.date !== undefined) ? data.date : ((data.dt_txt !== undefined) ? data.dt_txt: null),
-            temp: data.main.temp,
-            temp_min: data.main.temp_min,
-            temp_max: data.main.temp_max,
+            metric: {
+                temp:data.main.temp,
+                temp_min: data.main.temp_min,
+                temp_max: data.main.temp_max
+            },
+            imperial: {
+                temp: calcFahrenheit(data.main.temp),
+                temp_min: calcFahrenheit(data.main.temp_min),
+                temp_max: calcFahrenheit(data.main.temp_max)
+            },
             humidity: data.main.humidity,
             pressure: data.main.pressure,
-            wind_speed: data.wind.speed,
+            wind_speed_kmh: data.wind.speed,
+            wind_speed_mph: calcMph(data.wind.speed),
             wind_deg: data.wind.deg,
             condition: data.weather[0]
         };
@@ -76,12 +98,22 @@
             // TODO date_txt
             forecastResult.results.push({
                 timestamp: f.dt,
-                day: f.temp.day,
-                min: f.temp.min,
-                max: f.temp.max,
-                night: f.temp.night,
-                eve: f.temp.eve,
-                morn: f.temp.morn,
+                metric: {
+                    day: f.temp.day,
+                    min: f.temp.min,
+                    max: f.temp.max,
+                    night: f.temp.night,
+                    eve: f.temp.eve,
+                    morn: f.temp.morn
+                },
+                imperial: {
+                    day: calcFahrenheit(f.temp.day),
+                    min: calcFahrenheit(f.temp.min),
+                    max: calcFahrenheit(f.temp.max),
+                    night: calcFahrenheit(f.temp.night),
+                    eve: calcFahrenheit(f.temp.eve),
+                    morn: calcFahrenheit(f.temp.morn)
+                },
                 pressure: f.pressure,
                 humidity: f.humidity,
                 condition: f.weather[0],
@@ -228,7 +260,8 @@
             },
             response = {
                 location: params.location,
-                db: (params.db) ? params.db : null
+                db: (params.db) ? params.db : null,
+                format: RESPONSE_DATA_VERSION
             },
             addDataToResponse = (function(data) {
                 response[data.request.type] = data;
@@ -256,16 +289,15 @@
     "openweathermap": OpenWeatherMapApi
 });
 
-
-/*
-  following WorkerScript handles the data requests against the weather API.
-  "message" requires a "params" property with the required params to perform
-  the API call and an "action" property, which will be added also to the response.
+/**
+*  following WorkerScript handles the data requests against the weather API.
+*  "message" requires a "params" property with the required params to perform
+*  the API call and an "action" property, which will be added also to the response.
 */
 if(typeof WorkerScript != "undefined") {
     WorkerScript.onMessage = function(message) {
         // handles the response data
-        var finished = function(result) {
+        var finished = function(result) {            
             WorkerScript.sendMessage({
                 action: message.action,
                 result: result
@@ -288,25 +320,33 @@
         } else if(message.action === "updateData") {
             var locLength = message.params.locations.length,
                 locUpdated = 0,
-                result = [];
+                result = [],
+                now = new Date().getTime();
             if(locLength > 0) {
                 message.params.locations.forEach(function(loc) {
-                    var updatedHnd = function (newData) {
-                            locUpdated += 1;
+                    var updatedHnd = function (newData, cached) {
+                            locUpdated += 1;                            
+                            newData["save"] = (cached === true) ? false : true;
                             result.push(newData);
                             if(locUpdated === locLength) {
                                 result.sort(sortDataResults);
                                 finished(result);
                             }
                         },
-                        units = (message.params.units === "metric" || message.params.units === "imperial")
-                                                                            ? message.params.units : "metric",
                         params = {
                             location:loc.location,
                             db: loc.db,
-                            units: units
-                        };
-                    WeatherApi.getLocationData(params, updatedHnd, onError);
+                            units: 'metric'
+                        },
+                        secsFromLastFetch = (now-loc.updated)/1000;
+                    //
+                    if( message.params.force===true || loc.format !== RESPONSE_DATA_VERSION || secsFromLastFetch > 1800){
+                        // data older than 30min, location is new or data format is deprecated
+                        WeatherApi.getLocationData(params, updatedHnd, onError);
+                    } else {
+                        console.log("["+loc.location.name+"] returning cached data, time from last fetch: "+secsFromLastFetch)
+                        updatedHnd(loc, true);
+                    }
                 })
             } else {
                 finished(result);

=== modified file 'ubuntu-weather-app.qml'
--- ubuntu-weather-app.qml	2013-06-12 17:44:34 +0000
+++ ubuntu-weather-app.qml	2013-06-14 13:37:21 +0000
@@ -25,7 +25,9 @@
             if(!messageObject.error) {
                 if(messageObject.action === "updateData") {
                     messageObject.result.forEach(function(loc) {
-                        storage.updateLocation(loc.db.id, loc);
+                        if(loc["save"] === true) {
+                            storage.updateLocation(loc.db.id, loc);
+                        }
                     });
                     buildTabs(messageObject.result);
                 }
@@ -67,15 +69,21 @@
             tabsObject.selectedTabIndex = locLength -1;
     }
 
-    function refreshData() {
-        if(bigLoading === null)
+    function refreshData(from_storage, force_refresh) {
+        if(bigLoading === null) {
              loading.running = true;
-        storage.getLocations(function(locations) {
-            locationDataWorker.sendMessage({
-                action: "updateData",
-                params: {locations:locations, units:settings["units"]}
-            })
-        });
+        }
+        //
+        if(from_storage === true && force_refresh !== true) {
+            storage.getLocations(buildTabs);
+        } else {
+            storage.getLocations(function(locations) {
+                locationDataWorker.sendMessage({
+                    action: "updateData",
+                    params: {locations:locations, force: force_refresh}
+                })
+            });
+        }
     }
 
     function showLocationManager() {