From 442ffff150a57cb5a763f17802dfb6d88d2d3478 Mon Sep 17 00:00:00 2001 From: alanacheff Date: Sun, 6 Oct 2024 20:50:04 +0000 Subject: [PATCH] Upload files to "src/c" --- src/c/messaging.c | 223 +++++++++++++++++++++++++++++++++++++++++++ src/c/messaging.h | 7 ++ src/c/options.c | 78 +++++++++++++++ src/c/options.h | 5 + src/c/weather.c | 235 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 548 insertions(+) create mode 100644 src/c/messaging.c create mode 100644 src/c/messaging.h create mode 100644 src/c/options.c create mode 100644 src/c/options.h create mode 100644 src/c/weather.c diff --git a/src/c/messaging.c b/src/c/messaging.c new file mode 100644 index 0000000..12df07d --- /dev/null +++ b/src/c/messaging.c @@ -0,0 +1,223 @@ +#include +#include "messaging.h" +#include "constants.h" +#include "weather.h" +#include "date.h" +#include "digital_time.h" +#include "battery.h" +#include "analog_wd.h" + +extern Options s_options; +extern Layer *s_canvas_layer; + +void send(int key, int value, int key2, int value2, int key3, char value3[64]){ + #if DEBUG + APP_LOG(APP_LOG_LEVEL_DEBUG, "send: s_options.pebble_js_ready: %d", s_options.pebble_js_ready); + #endif + if (s_options.pebble_js_ready) { + + DictionaryIterator *iterator; + app_message_outbox_begin(&iterator); + dict_write_int(iterator, key, &value, sizeof(int), true); + dict_write_int(iterator, key2, &value2, sizeof(int), true); + dict_write_cstring(iterator, key3, value3); + + app_message_outbox_send(); + } +} + +void inbox_received_callback(DictionaryIterator *iterator, void *context) { + + // Read first item + Tuple *t = dict_read_first(iterator); + + // For all items + while(t != NULL) { + // Which key was received? + switch(t->key) { + + case KEY_TEMPERATURE: + s_options.tempF = (int)t->value->int32; + break; + + case KEY_TEMPERATURE_LO: + s_options.tempFLo = (int)t->value->int32; + break; + + case KEY_TEMPERATURE_HI: + s_options.tempFHi = (int)t->value->int32; + break; + + case KEY_TEMPERATURE_IN_C: + s_options.tempC = (int)t->value->int32; + break; + + case KEY_TEMPERATURE_IN_C_LO: + s_options.tempCLo = (int)t->value->int32; + break; + + case KEY_TEMPERATURE_IN_C_HI: + s_options.tempCHi = (int)t->value->int32; + break; + + case KEY_CONDITIONS: + snprintf(s_options.conditions, sizeof(s_options.conditions), "%s", t->value->cstring); + + //check if successful weather retrieval + if (strlen(s_options.conditions) > 0) { + // Get a tm structure + time_t temp = time(NULL); + struct tm *tick_time = localtime(&temp); + //strftime(s_options.last_weather_update, sizeof("00:00"), "%H:%M", tick_time); + strftime(s_options.last_weather_update24hr, sizeof("00:00"), "%H:%M", tick_time); + strftime(s_options.last_weather_update12hr, sizeof("00:00 pm"), "%l:%M %P", tick_time); + s_options.last_update = temp; + } + break; + + case KEY_CONDITION_CODE: + s_options.condition_code = (int)t->value->int32; + break; + + case KEY_SHAKE_FOR_LOHI: + s_options.shake_for_lohi = (int)t->value->int32; + break; + + case KEY_USE_CELSIUS: + s_options.use_celsius = (int)t->value->int32; + break; + + case KEY_WEATHER_USE_GPS: + //force weather update after each config page Save + memset(s_options.conditions, 0,sizeof(s_options.conditions)); + s_options.condition_code = DEFAULT_CONDITION_CODE; + + s_options.weather_use_GPS = (int)t->value->int32; + break; + + case KEY_WEATHER_LOCATION: + snprintf(s_options.weather_location, sizeof(s_options.weather_location), "%s", t->value->cstring); + break; + + case KEY_WEATHER_FREQUENCY: + s_options.weather_frequency = (int)t->value->int32; + break; + + case KEY_BACKGROUND_COLOR: + s_options.background_color = (int)t->value->int32; + window_set_background_color(s_main_window, GColorFromHEX(s_options.background_color)); + break; + + case KEY_TEXT_COLOR: + s_options.text_color = (int)t->value->int32; + + text_layer_set_text_color(weather_layer1, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(weather_layer_center, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(weather_layer2, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(digital_time_layer, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(date_layer1, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(date_layer2, GColorFromHEX(s_options.text_color)); + text_layer_set_text_color(battery_layer, GColorFromHEX(s_options.text_color)); + break; + + case KEY_HOUR_HAND_COLOR: + s_options.hour_hand_color = (int)t->value->int32; + break; + + case KEY_MINUTE_HAND_COLOR: + s_options.minute_hand_color = (int)t->value->int32; + break; + + case KEY_SECONDS_HAND_COLOR: + s_options.seconds_hand_color = (int)t->value->int32; + break; + + case KEY_HOUR_MARKERS_COLOR: + s_options.hour_markers_color = (int)t->value->int32; + break; + + case KEY_MINOR_MARKERS_COLOR: + s_options.minor_markers_color = (int)t->value->int32; + break; + + case KEY_READABILITY: + s_options.readability = (int)t->value->int32; + break; + + case KEY_DISPLAY_DIGITAL_TIME: + s_options.display_digital_time = (int)t->value->int32; + break; + + case KEY_DISPLAY_DATE: + s_options.display_date = (int)t->value->int32; + break; + + case KEY_VIBBRATE_BT_STATUS: + s_options.vibrate_bt_status = (int)t->value->int32; + break; + + case KEY_USE_THIN_HANDS: + s_options.use_thin_hands = (int)t->value->int32; + break; + + case KEY_DISPLAY_BATTERY: + s_options.display_battery = (int)t->value->int32; + break; + + case KEY_DISPLAY_HOUR_DIGITS: + s_options.display_hour_digits = (int)t->value->int32; + break; + + case KEY_DISPLAY_SECONDS_HAND: + s_options.display_seconds_hand = (int)t->value->int32; + break; + + case KEY_JS_READY: + s_options.pebble_js_ready = (int)t->value->int32; + #if DEBUG + APP_LOG(APP_LOG_LEVEL_DEBUG, "inbox_received_callback: s_options.pebble_js_ready: %d", s_options.pebble_js_ready); + #endif + break; + } + // Look for next item + t = dict_read_next(iterator); + } + + //check update weather, date, digital time, and battery layers + update_date_layer(); + update_digital_time_layer(); + update_weather_layer(); + update_battery_layer(); +} + +char *translate_error(AppMessageResult result) { + switch (result) { + case APP_MSG_OK: return "APP_MSG_OK"; + case APP_MSG_SEND_TIMEOUT: return "APP_MSG_SEND_TIMEOUT"; + case APP_MSG_SEND_REJECTED: return "APP_MSG_SEND_REJECTED"; + case APP_MSG_NOT_CONNECTED: return "APP_MSG_NOT_CONNECTED"; + case APP_MSG_APP_NOT_RUNNING: return "APP_MSG_APP_NOT_RUNNING"; + case APP_MSG_INVALID_ARGS: return "APP_MSG_INVALID_ARGS"; + case APP_MSG_BUSY: return "APP_MSG_BUSY"; + case APP_MSG_BUFFER_OVERFLOW: return "APP_MSG_BUFFER_OVERFLOW"; + case APP_MSG_ALREADY_RELEASED: return "APP_MSG_ALREADY_RELEASED"; + case APP_MSG_CALLBACK_ALREADY_REGISTERED: return "APP_MSG_CALLBACK_ALREADY_REGISTERED"; + case APP_MSG_CALLBACK_NOT_REGISTERED: return "APP_MSG_CALLBACK_NOT_REGISTERED"; + case APP_MSG_OUT_OF_MEMORY: return "APP_MSG_OUT_OF_MEMORY"; + case APP_MSG_CLOSED: return "APP_MSG_CLOSED"; + case APP_MSG_INTERNAL_ERROR: return "APP_MSG_INTERNAL_ERROR"; + default: return "UNKNOWN ERROR"; + } +} + +void message_dropped(AppMessageResult reason, void *context) { + APP_LOG(APP_LOG_LEVEL_ERROR, "Dropped message! Reason given: %s", translate_error(reason)); +} + +void message_out_success(DictionaryIterator *iter, void *context) { + APP_LOG(APP_LOG_LEVEL_DEBUG, "Message sent."); +} + +void message_out_failed(DictionaryIterator *iter, AppMessageResult reason, void *context) { + APP_LOG(APP_LOG_LEVEL_DEBUG, "Failed to send message. Reason = %s", translate_error(reason)); +} \ No newline at end of file diff --git a/src/c/messaging.h b/src/c/messaging.h new file mode 100644 index 0000000..3b4166a --- /dev/null +++ b/src/c/messaging.h @@ -0,0 +1,7 @@ +#pragma once + + void send(int key, int value, int key2, int value2, int key3, char value3[64]); + void inbox_received_callback(DictionaryIterator *iterator, void *context); + void message_dropped(AppMessageResult reason, void *context); + void message_out_success(DictionaryIterator *iter, void *context); + void message_out_failed(DictionaryIterator *iter, AppMessageResult reason, void *context); \ No newline at end of file diff --git a/src/c/options.c b/src/c/options.c new file mode 100644 index 0000000..236e10b --- /dev/null +++ b/src/c/options.c @@ -0,0 +1,78 @@ +#include +#include "options.h" +#include "constants.h" +#include "analog_wd.h" + +extern Options s_options; + +void init_options() { + + if (persist_exists(KEY_OPTIONS)) { + persist_read_data(KEY_OPTIONS, &s_options, sizeof(s_options)); + } + else { + s_options.shake_for_lohi = DEFAULT_SHAKE_FOR_LOHI; + s_options.display_weather = DEFAULT_DISPLAY_WEATHER; + s_options.use_celsius = DEFAULT_USE_CELSIUS; + s_options.weather_use_GPS = DEFAULT_WEATHER_USE_GPS; + memset(s_options.weather_location, 0,sizeof(s_options.weather_location)); + s_options.weather_frequency = DEFAULT_WEATHER_FREQUENCY; + s_options.min_since_last_forecast = DEFAULT_MIN_SINCE_WEATHER_UPDATE; + s_options.background_color = DEFAULT_BACKGROUND_COLOR; + s_options.text_color = DEFAULT_TEXT_COLOR; + s_options.hour_hand_color = DEFAULT_HOUR_HAND_COLOR; + s_options.minute_hand_color = DEFAULT_MINUTE_HAND_COLOR; + s_options.seconds_hand_color = DEFAULT_SECONDS_HAND_COLOR; + s_options.hour_markers_color = DEFAULT_HOUR_MARKERS_COLOR; + s_options.minor_markers_color = DEFAULT_MINOR_MARKERS_COLOR; + s_options.readability = DEFAULT_READABILITY; + s_options.condition_code = DEFAULT_CONDITION_CODE; + s_options.display_digital_time = DEFAULT_DISPLAY_DIGITAL_TIME; + s_options.display_date = DEFAULT_DISPLAY_DATE; + s_options.vibrate_bt_status = DEFAULT_VIBRATE_BT_STATUS; + s_options.use_thin_hands = DEFAULT_USE_THIN_HANDS; + s_options.display_battery = DEFAULT_DISPLAY_BATTERY; + s_options.display_hour_digits = DEFAULT_DISPLAY_HOUR_DIGITS; + s_options.display_seconds_hand = DEFAULT_DISPLAY_SECONDS_HAND; + memset(s_options.conditions, 0,sizeof(s_options.conditions)); + snprintf(s_options.last_weather_update12hr, sizeof(s_options.last_weather_update12hr), "--:--"); + snprintf(s_options.last_weather_update24hr, sizeof(s_options.last_weather_update24hr), "--:--"); + //persist_write_data(KEY_OPTIONS, &s_options, sizeof(s_options)); + } + #if DEBUG + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.shake_for_lohi: %d", s_options.shake_for_lohi); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempF: %d", s_options.tempF); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempFLo: %d", s_options.tempFLo); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempFHi: %d", s_options.tempFHi); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempC: %d", s_options.tempC); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempCLo: %d", s_options.tempCLo); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.tempCHi: %d", s_options.tempCHi); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_weather: %d", s_options.display_weather); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.weather_use_GPS: %d", s_options.weather_use_GPS); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.weather_location: %s", s_options.weather_location); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.use_celsius: %d", s_options.use_celsius); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.weather_frequency: %d", s_options.weather_frequency); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.min_since_last_forecast: %d", s_options.min_since_last_forecast); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_date: %d", s_options.display_date); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.background_color: %d", s_options.background_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.text_color: %d", s_options.text_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.hour_hand_color: %d", s_options.hour_hand_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.minute_hand_color: %d", s_options.minute_hand_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.seconds_hand_color: %d", s_options.seconds_hand_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.hour_markers_color: %d", s_options.hour_markers_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.minor_markers_color: %d", s_options.minor_markers_color); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.readability: %d", s_options.readability); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.condition_code: %d", s_options.condition_code); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.bluetooth_state: %d", s_options.bluetooth_state); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_digital_time: %d", s_options.display_digital_time); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.vibrate_bt_status: %d", s_options.vibrate_bt_status); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.use_thin_hands: %d", s_options.use_thin_hands); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_battery: %d", s_options.display_battery); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_hour_digits: %d", s_options.display_hour_digits); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.display_seconds_hand: %d", s_options.display_seconds_hand); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.conditions: %s", s_options.conditions); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.last_weather_update12hr: %s", s_options.last_weather_update12hr); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: s_options.last_weather_update24hr: %s", s_options.last_weather_update24hr); + APP_LOG(APP_LOG_LEVEL_DEBUG, "init_options: options sizeof(s_options) %zu", sizeof(s_options)); + #endif +} diff --git a/src/c/options.h b/src/c/options.h new file mode 100644 index 0000000..f1d00d9 --- /dev/null +++ b/src/c/options.h @@ -0,0 +1,5 @@ +#pragma once + +#define KEY_OPTIONS 99 + + void init_options(); \ No newline at end of file diff --git a/src/c/weather.c b/src/c/weather.c new file mode 100644 index 0000000..4306c08 --- /dev/null +++ b/src/c/weather.c @@ -0,0 +1,235 @@ +#include +#include "weather.h" +#include "constants.h" +#include "digital_time.h" +#include "analog_wd.h" + +extern TextLayer *weather_layer1, *weather_layer2, *weather_layer_center; +extern AppTimer *lohi_display_timer; + +extern Options s_options; + +//check if need to convert weather condition codes (too long) +void convert_conditions(int conditionCode) { + + switch(conditionCode) { + case 0: // tornado + case 1: // tropical storm + case 2: // hurricane + case 4: // thunderstorms + case 8: //freezing drizzle + case 9: //drizzle + case 10: //freezing rain + case 11: //showers + case 12: //showers + case 13: //snow flurries + case 15: //blowing snow + case 16: //snow + case 17: //hail + case 18: //sleet + case 19: //dust + case 20: //foggy + case 21: //haze + case 22: //smoky + case 23: //blustery + case 24: //windy + case 25: //cold + case 26: //cloudy + case 32: //sunny + case 36: //hot + case 40: //scattered showers + case 41: //heavy snow + case 43: //heavy snow + case 44: //partly cloudy + case 45: //thundershowers + case 46: //snow showers + //no need to convert, do nothing + break; + case 3: // severe thunderstorms + case 37: //isolated thunderstorms + case 38: //scattered thunderstorms + case 39: //scattered thunderstorms + snprintf(s_options.conditions, sizeof(s_options.conditions), "Thunderstorms"); + break; + case 5: //mixed rain and snow + snprintf(s_options.conditions, sizeof(s_options.conditions), "Rain and Snow"); + break; + case 6: //mixed rain and sleet + snprintf(s_options.conditions, sizeof(s_options.conditions), "Rain and Sleet"); + break; + case 7: //mixed snow and sleet + snprintf(s_options.conditions, sizeof(s_options.conditions), "Snow and Sleet"); + break; + case 14: //light snow showers + snprintf(s_options.conditions, sizeof(s_options.conditions), "Snow Showers"); + break; + case 27: //mostly cloudy (night) + case 28: //mostly cloudy (day) + snprintf(s_options.conditions, sizeof(s_options.conditions), "Mostly Cloudy"); + break; + case 29: //partly cloudy (night) + case 30: //partly cloudy (day) + snprintf(s_options.conditions, sizeof(s_options.conditions), "Partly Cloudy"); + break; + case 31: //clear (night) + snprintf(s_options.conditions, sizeof(s_options.conditions), "Clear"); + break; + case 33: //fair (night) + case 34: //fair (day) + snprintf(s_options.conditions, sizeof(s_options.conditions), "Fair"); + break; + case 35: //mixed rain and hail + snprintf(s_options.conditions, sizeof(s_options.conditions), "Rain and Hail"); + break; + case 42: //scattered snow showers + snprintf(s_options.conditions, sizeof(s_options.conditions), "Snow Showers"); + break; + case 47: //isolated thundershowers + snprintf(s_options.conditions, sizeof(s_options.conditions), "Thundershowers"); + break; + case 3200: //Unknown + snprintf(s_options.conditions, sizeof(s_options.conditions), "....."); + break; + default: //invalid condition code, clear conditions + memset(s_options.conditions, 0,sizeof(s_options.conditions)); + break; + } +} + +//adds/configures weather display lines +void add_weather_layers(Layer *window_layer, int16_t width, int16_t height) { + + GFont weather_font; + int weather_Y_readability_offset = 0; + int weather_Y_hour_digits_offset = 0; + int chalk_weather1_Y_offset = 0; + int chalk_weather_center_Y_offset = 0; + int chalk_weather2_Y_offset = 0; + + chalk_weather1_Y_offset = DEFAULT_CHALK_WEATHER1_Y_OFFSET; + chalk_weather_center_Y_offset = DEFAULT_CHALK_WEATHER_CENTER_Y_OFFSET; + chalk_weather2_Y_offset = DEFAULT_CHALK_WEATHER2_Y_OFFSET; + + if (s_options.readability) { + weather_Y_readability_offset = DEFAULT_WEATHER_Y_OFFSET_READABILITY; + weather_font = fonts_get_system_font(FONT_KEY_GOTHIC_24); + } + else { + weather_font = fonts_get_system_font(FONT_KEY_GOTHIC_18); + } + + if (s_options.display_hour_digits) { + weather_Y_hour_digits_offset = DEFAULT_WEATHER_Y_OFFSET_HOUR_DIGITS; + } + + //weather layers + weather_layer1 = text_layer_create(GRect(0, 5 - weather_Y_readability_offset + chalk_weather1_Y_offset + weather_Y_hour_digits_offset, width, 28)); + text_layer_set_text_alignment(weather_layer1, GTextAlignmentCenter); + init_static_row(weather_layer1, weather_font); + layer_add_child(window_layer, text_layer_get_layer(weather_layer1)); + + weather_layer2 = text_layer_create(GRect(0, 5 - weather_Y_readability_offset + chalk_weather2_Y_offset + weather_Y_hour_digits_offset, width, 28)); + text_layer_set_text_alignment(weather_layer2, GTextAlignmentCenter); + init_static_row(weather_layer2, weather_font); + layer_add_child(window_layer, text_layer_get_layer(weather_layer2)); + + weather_layer_center = text_layer_create(GRect(0, 5 - weather_Y_readability_offset + chalk_weather_center_Y_offset + weather_Y_hour_digits_offset, width, 28)); + text_layer_set_text_alignment(weather_layer_center, GTextAlignmentCenter); + init_static_row(weather_layer_center, weather_font); + layer_add_child(window_layer, text_layer_get_layer(weather_layer_center)); +} + +//checks updates weather display lines +void update_weather_layer() { + static char weather1_layer_buffer[32]; + static char weather2_layer_buffer[32]; + static char weather_center_layer_buffer[32]; + + //check if need to convert options (if too long) + convert_conditions(s_options.condition_code); + + if (s_options.use_celsius){ + memset(weather1_layer_buffer, 0,sizeof(weather1_layer_buffer)); + snprintf(weather_center_layer_buffer, sizeof(weather_center_layer_buffer), "%dC %s", s_options.tempC, s_options.conditions); + memset(weather2_layer_buffer, 0,sizeof(weather2_layer_buffer)); + if (strlen(s_options.conditions) > MAX_CHALK_SINGLE_LINE_CONDITIONS_LEN) { + snprintf(weather1_layer_buffer, sizeof(weather1_layer_buffer), "%dC", s_options.tempC); + memset(weather_center_layer_buffer, 0,sizeof(weather_center_layer_buffer)); + snprintf(weather2_layer_buffer, sizeof(weather2_layer_buffer), "%s", s_options.conditions); + } + } + else { + memset(weather1_layer_buffer, 0,sizeof(weather1_layer_buffer)); + snprintf(weather_center_layer_buffer, sizeof(weather_center_layer_buffer), "%dF %s", s_options.tempF, s_options.conditions); + memset(weather2_layer_buffer, 0,sizeof(weather2_layer_buffer)); + if (strlen(s_options.conditions) > MAX_CHALK_SINGLE_LINE_CONDITIONS_LEN) { + snprintf(weather1_layer_buffer, sizeof(weather1_layer_buffer), "%dF", s_options.tempF); + memset(weather_center_layer_buffer, 0,sizeof(weather_center_layer_buffer)); + snprintf(weather2_layer_buffer, sizeof(weather2_layer_buffer), "%s", s_options.conditions); + } + } + + //write weather text row + if (strlen(s_options.conditions) != 0) { + text_layer_set_text(weather_layer1, weather1_layer_buffer); + text_layer_set_text(weather_layer_center, weather_center_layer_buffer); + text_layer_set_text(weather_layer2, weather2_layer_buffer); + #if DEBUG + APP_LOG(APP_LOG_LEVEL_DEBUG, "update_weather_layer: Successful weather row information written at %s. ", s_options.last_weather_update12hr); + #endif + + } + else { //empty temp & conditions + text_layer_set_text(weather_layer1, ""); + text_layer_set_text(weather_layer_center, DEFAULT_ERROR_WEATHER_UPDATE); + text_layer_set_text(weather_layer2, ""); + #if DEBUG + APP_LOG(APP_LOG_LEVEL_DEBUG, "update_weather_layer: Error displaying weather %s. ", s_options.last_weather_update12hr); + #endif + } +} + +void handle_timer(void *data) { + update_weather_layer(); + update_digital_time_layer(); +} + +//temporarily sets and displays Lo/Hi temp and last updates info on weather/date lines +void display_lohi_weather_info() { + static char weather1_layer_buffer[32]; + static char weather2_layer_buffer[32]; + static char weather_center_layer_buffer[32]; + + if (s_options.use_celsius){ + snprintf(weather1_layer_buffer, sizeof(weather1_layer_buffer), "Lo %dC", s_options.tempCLo); + snprintf(weather2_layer_buffer, sizeof(weather2_layer_buffer), "Hi %dC", s_options.tempCHi); + memset(weather_center_layer_buffer, 0,sizeof(weather_center_layer_buffer)); + } + else { + snprintf(weather1_layer_buffer, sizeof(weather1_layer_buffer), "Lo %dF", s_options.tempFLo); + snprintf(weather2_layer_buffer, sizeof(weather2_layer_buffer), "Hi %dF", s_options.tempFHi); + memset(weather_center_layer_buffer, 0,sizeof(weather_center_layer_buffer)); + } + + //write weather text row + if (strlen(s_options.conditions) != 0) { + if (clock_is_24h_style()) { + text_layer_set_text(digital_time_layer, s_options.last_weather_update24hr); + } + else { + text_layer_set_text(digital_time_layer, s_options.last_weather_update12hr); + } + text_layer_set_text(weather_layer1, weather1_layer_buffer); + text_layer_set_text(weather_layer_center, weather_center_layer_buffer); + text_layer_set_text(weather_layer2, weather2_layer_buffer); + } + else { //empty temp & conditions + text_layer_set_text(digital_time_layer, s_options.last_weather_update12hr); + text_layer_set_text(digital_time_layer, s_options.last_weather_update24hr); + text_layer_set_text(weather_layer1, ""); + text_layer_set_text(weather_layer_center, DEFAULT_ERROR_WEATHER_UPDATE); + text_layer_set_text(weather_layer2, ""); + } + + lohi_display_timer = app_timer_register(DEFAULT_DISPLAY_LOHI_TIMER, handle_timer, NULL); +} \ No newline at end of file