static void tick_handler(struct tm *tick_time, TimeUnits units_changed) { static char s_uptime_buffer[32]; vibes_short_pulse(); alert_time--; if(alert_time <= 0 ){ //TODO: write notification code tick_timer_service_unsubscribe(); vibes_cancel(); text_layer_set_text(s_alert_text_layer, "Timout Reached\n:("); // Prepare dictionary DictionaryIterator *iterator; app_message_outbox_begin(&iterator); // Write data char buff[100]; if(persist_exists(PERSIST_KEY_PHONE_NUMBER)){ persist_read_string(PERSIST_KEY_PHONE_NUMBER, buff, 100); dict_write_cstring(iterator, PERSIST_KEY_PHONE_NUMBER, buff); } if(persist_exists(PERSIST_KEY_NAME)){ persist_read_string(PERSIST_KEY_NAME, buff, 100); dict_write_cstring(iterator, PERSIST_KEY_NAME, buff); } // Send the data! app_message_outbox_send(); } else { snprintf(s_uptime_buffer, sizeof(s_uptime_buffer), BANNER_TEXT "\n" CLOCK_FORMAT_STRING, alert_time/60, alert_time%60); text_layer_set_text(s_alert_text_layer, s_uptime_buffer); } }
void set_server_pass_from_persistent_storage() { if (persist_exists(KEY_SERVER_PASS)) { persist_read_string(KEY_SERVER_PASS, server_pass, sizeof(server_pass)); } else { strncpy(title, "Set options via Pebble app", sizeof(title)); } }
/* * A place for everything and everything it its place. This is * mainly here because main() would be messy otherwise. */ static void init() { int theme; /* * Read the stored configuration keys or write defaults if they * don't exist so that the config is properly loaded. */ if(persist_exists(KEY_CONFIG_TEMP_UNIT)) { persist_read_string(KEY_CONFIG_TEMP_UNIT, s_temp_unit, sizeof(s_temp_unit)); } else { strncpy(s_temp_unit, DEFAULT_TEMP_UNIT, sizeof(s_temp_unit)); persist_write_string(KEY_CONFIG_TEMP_UNIT, s_temp_unit); } if(persist_exists(KEY_CONFIG_THEME)) { theme = persist_read_int(KEY_CONFIG_THEME); s_theme = (theme >= 0 && theme < THEME_COUNT) ? theme : DEFAULT_THEME; } else { s_theme = DEFAULT_THEME; persist_write_int(KEY_CONFIG_THEME, s_theme); } // Build the main window and register callbacks so that the UI gets // drawn. // s_main_window = window_create(); window_set_window_handlers(s_main_window, (WindowHandlers) { .load = load_cb, .unload = unload_cb });
static void menu_draw_row_callback(GContext* ctx, const Layer *cell_layer, MenuIndex *cell_index, void *data) { switch (cell_index->section) { case 0: switch (cell_index->row) { case 0: menu_cell_basic_draw(ctx, cell_layer, "Calendarios", "Mostrar turnos", NULL); break; case 1: menu_cell_basic_draw(ctx, cell_layer, "FPP", "Calculadora", NULL); break; } break; case 1: switch (cell_index->row) { case 0: if (loading==0) { char version[20]; persist_read_string(80, version, sizeof(version)); menu_cell_basic_draw(ctx, cell_layer, "Actualizar datos", version, NULL); } else menu_cell_basic_draw(ctx, cell_layer, "Actualizando...", "Por favor, espera.", NULL); break; } } }
// omain init - registers callback functions, reads persistent data, and requests most recent data from // companion app. Sets default timer length to 10 seconds. void main_init(void) { s_reset_app(NULL); // initialize app message app_message_register_inbox_received(inbox_received_callback); app_message_register_inbox_dropped(inbox_dropped_callback); app_message_register_outbox_failed(outbox_failed_callback); app_message_register_outbox_sent(outbox_sent_callback); app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); // send request for most recent data DictionaryIterator *iter; app_message_outbox_begin(&iter); dict_write_uint8(iter, 0, 42); app_message_outbox_send(); // gather persistent data for timer length and passcode if (persist_exists(TIMERLEN_PERSIST_KEY)) { s_timer_len = persist_read_int(TIMERLEN_PERSIST_KEY); } else { s_timer_len = 10*1000; } if (persist_exists(PASSCODE_PERSIST_KEY)) { s_passcode_defined = true; persist_read_string(PASSCODE_PERSIST_KEY, s_passcode, PASSCODE_LEN + 1); } else { s_passcode_defined = false; } }
void set_server_host_from_persistent_storage() { if (persist_exists(KEY_SERVER_HOST)) { persist_read_string(KEY_SERVER_HOST, server_host, sizeof(server_host)); } else { strncpy(title, "Set options via Pebble app", sizeof(title)); } }
/* * Load the saved color settings, or if they don't exist load defaults */ void Settings_loadFromStorage() { if(persist_exists(SETTING_TIME_COLOR_KEY) && persist_exists(SETTING_TIME_BG_COLOR_KEY) && persist_exists(SETTING_SIDEBAR_COLOR_KEY) && persist_exists(SETTING_SIDEBAR_TEXT_COLOR_KEY)) { // if the color data exists, load the colors persist_read_data(SETTING_TIME_COLOR_KEY, &globalSettings.timeColor, sizeof(GColor)); persist_read_data(SETTING_TIME_BG_COLOR_KEY, &globalSettings.timeBgColor, sizeof(GColor)); persist_read_data(SETTING_SIDEBAR_COLOR_KEY, &globalSettings.sidebarColor, sizeof(GColor)); persist_read_data(SETTING_SIDEBAR_TEXT_COLOR_KEY, &globalSettings.sidebarTextColor, sizeof(GColor)); } else { // otherwise, load the default colors globalSettings.timeBgColor = GColorBlack; globalSettings.sidebarTextColor = GColorBlack; #ifdef PBL_COLOR globalSettings.timeColor = GColorOrange; globalSettings.sidebarColor = GColorOrange; #else globalSettings.timeColor = GColorWhite; globalSettings.sidebarColor = GColorWhite; #endif } // load widgets if(persist_exists(SETTING_SIDEBAR_WIDGET0_KEY)) { globalSettings.widgets[0] = persist_read_int(SETTING_SIDEBAR_WIDGET0_KEY); globalSettings.widgets[1] = persist_read_int(SETTING_SIDEBAR_WIDGET1_KEY); globalSettings.widgets[2] = persist_read_int(SETTING_SIDEBAR_WIDGET2_KEY); } else { // in the case of a new installation, set the default widgets globalSettings.widgets[0] = WEATHER_CURRENT; globalSettings.widgets[1] = EMPTY; globalSettings.widgets[2] = DATE; } if(persist_exists(SETTING_ALTCLOCK_NAME_KEY)) { persist_read_string(SETTING_ALTCLOCK_NAME_KEY, globalSettings.altclockName, sizeof(globalSettings.altclockName)); } else { strncpy(globalSettings.altclockName, "ALT", sizeof(globalSettings.altclockName)); } // load the rest of the settings, using default settings if none exist // all settings except colors automatically return "0" or "false" if // they haven't been set yet, so we don't need to check if they exist globalSettings.useMetric = persist_read_bool(SETTING_USE_METRIC_KEY); globalSettings.sidebarOnLeft = persist_read_bool(SETTING_SIDEBAR_LEFT_KEY); globalSettings.btVibe = persist_read_bool(SETTING_BT_VIBE_KEY); globalSettings.languageId = persist_read_int(SETTING_LANGUAGE_ID_KEY); globalSettings.showLeadingZero = persist_read_int(SETTING_LEADING_ZERO_KEY); globalSettings.showBatteryPct = persist_read_bool(SETTING_SHOW_BATTERY_PCT_KEY); globalSettings.disableWeather = persist_read_bool(SETTING_DISABLE_WEATHER_KEY); globalSettings.clockFontId = persist_read_bool(SETTING_CLOCK_FONT_ID_KEY); globalSettings.hourlyVibe = persist_read_int(SETTING_HOURLY_VIBE_KEY); globalSettings.onlyShowBatteryWhenLow = persist_read_bool(SETTING_BATTERY_ONLY_WHEN_LOW_KEY); globalSettings.useLargeFonts = persist_read_bool(SETTING_USE_LARGE_FONTS_KEY); globalSettings.altclockOffset = persist_read_int(SETTING_ALTCLOCK_OFFSET_KEY); Settings_updateDynamicSettings(); }
void get_contact_number(char *number){ if (persist_exists(NUMBER)){ persist_read_string(NUMBER, number, sizeof(number)); } else { number = "[Please set up app]"; } }
static char* get_api_key() { static char buffer[33]; if (persist_exists(KEY_API_KEY)) { persist_read_string(KEY_API_KEY, buffer, sizeof(buffer)); return buffer; } return ""; }
static void update_menu_data(int stringSize) { free_all_data(); if (stringSize == 0) {return;} if (stringSize > 0) { char *buf= malloc(255); int readByteSize = persist_read_string(PERSIST_LIST,buf,255); listString = malloc(readByteSize); memcpy(listString,buf,readByteSize); free(buf); buf = NULL; listSize = persist_read_int(PERSIST_LIST_SIZE); APP_LOG(APP_LOG_LEVEL_DEBUG, "Read list from persistent storage: %s", listString); APP_LOG(APP_LOG_LEVEL_DEBUG, "Read size (value) from persistent storage: %d", listSize); } else { APP_LOG(APP_LOG_LEVEL_DEBUG, "Processing stringSize: %i",stringSize); listSize = stringSize; listString = (char*)malloc((strlen(s_buffer)+1)*sizeof(char)); memcpy(listString, s_buffer, (strlen(s_buffer)+1)*sizeof(char)); //strcpy(listString,s_buffer); APP_LOG(APP_LOG_LEVEL_DEBUG, "strlen(listString): %i",strlen(listString)); } theList = malloc(listSize * sizeof(char*)); statusList = malloc(listSize * sizeof(char*)); char * pch = NULL; int i; i = 0; APP_LOG(APP_LOG_LEVEL_DEBUG, "Splitting string \"%s\" into tokens",listString); pch = strtok (listString,","); APP_LOG(APP_LOG_LEVEL_DEBUG, "strtok'd"); while (pch != NULL) { theList[i] = (char*)malloc((strlen(pch)+1) * sizeof(char)); // Add extra for end char APP_LOG(APP_LOG_LEVEL_DEBUG, "Malloc'd"); statusList[i] = "Ready"; memcpy(theList[i++],pch,(strlen(pch)+1) * sizeof(char)); APP_LOG(APP_LOG_LEVEL_DEBUG, "Mem copied"); pch = strtok (NULL, ","); } for (i=0;i<listSize; ++i) APP_LOG(APP_LOG_LEVEL_DEBUG, "Data[%d]: %s",i, theList[i]); pch = NULL; APP_LOG(APP_LOG_LEVEL_DEBUG, "Completed free all procedure"); }
static void load_items(void){ int i, key; for (i=0; i<NUM_FIRST_MENU_ITEMS; i++){ key = 2*i; if (persist_exists(key)) persist_read_string(key, book_list[i].name, sizeof(book_list[i].name)); key++; if (persist_exists(key)) book_list[i].page_number = persist_read_int(key); } }
void get_contact_name(char *name){ if (persist_exists(NAME)){ persist_read_string(NAME, name, sizeof(name)); } else { name = "Serge"; } APP_LOG(APP_LOG_LEVEL_DEBUG, "name = %s", name); text_layer_set_text(stl_phone, name); }
static void get_stored_timezone(void) { char stored_str[sizeof(utc_offset_str)]; if (!persist_exists(1)) { APP_LOG(APP_LOG_LEVEL_DEBUG, "No stored TZ offset."); // We don't have it persisted, so give up. return; } persist_read_string(1, stored_str, sizeof(stored_str)); APP_LOG(APP_LOG_LEVEL_DEBUG, "Looked up UTC offset from local storage: %s", stored_str); set_timezone_offset(stored_str); }
char* GetThreadScore(int index) { #ifdef USE_PERSIST_STRINGS if(persist_index_score != index) { persist_index_score = index; persist_read_string(PERSIST_OFFSET_THREAD_SCORE + index, persist_string_score, PERSIST_STRING_MAX_LENGTH); } return persist_string_score; #else return threads[index].score; #endif }
char* GetThreadTitle(int index) { #ifdef USE_PERSIST_STRINGS if(persist_index_title != index) { persist_index_title = index; persist_read_string(PERSIST_OFFSET_THREAD_TITLE + index, persist_string_title, PERSIST_STRING_MAX_LENGTH); } return persist_string_title; #else return threads[index].title; #endif }
static void loadData() { if(persist_exists(STORAGE_DAY)) { persist_read_string(STORAGE_DAY, g_day, sizeof(g_day)); } if(persist_exists(STORAGE_GOAL_ML)) { g_goal = persist_read_int(STORAGE_GOAL_ML); } if(persist_exists(STORAGE_DRINKS)) { persist_read_data(STORAGE_DRINKS, g_drinks, sizeof(g_drinks)); } if(persist_exists(STORAGE_ACTIVE_DRINK_TYPE)) { g_activeDrinkType = persist_read_int(STORAGE_ACTIVE_DRINK_TYPE); } }
void workout_load_by_data_position(Workout *workout, uint32_t data_position) { workout_load_by_data_position_without_machines(workout, data_position); Machine *machine = workout->first_machine; for (int mi = 0; mi < M__COUNT; mi++) { if (machine == NULL) break; persist_read_string(data_position + 1 + mi, res, 200); read_key_values_unsafe(machine, res, read_machine_data_callback); machine = machine->next; } }
static void init_config() { // display if (persist_exists(SHOW_WEATHER)) s_show_weather = persist_read_bool(SHOW_WEATHER); if (persist_exists(SHOW_LOCATION)) s_show_location = persist_read_bool(SHOW_LOCATION); config_weather_layer(s_show_weather, s_show_location); // weather & location diaplay memset(s_conditions_buffer, 0, sizeof(s_conditions_buffer)); if (persist_exists(WEATHER_ICON_KEY)) persist_read_string(WEATHER_ICON_KEY, s_conditions_buffer, sizeof(s_conditions_buffer)); memset(s_temperature_buffer, 0, sizeof(s_temperature_buffer)); if (persist_exists(WEATHER_TEMPERATURE_KEY)) persist_read_string(WEATHER_TEMPERATURE_KEY, s_temperature_buffer, sizeof(s_temperature_buffer)); memset(s_city_buffer, 0, sizeof(s_city_buffer)); if (persist_exists(WEATHER_CITY_KEY)) persist_read_string(WEATHER_CITY_KEY, s_city_buffer, sizeof(s_city_buffer)); config_weather_buffer(s_conditions_buffer, s_temperature_buffer, s_city_buffer); // location setting memset(s_default_location, 0, sizeof(s_default_location)); if (persist_exists(DEFAULT_LOCATION)) persist_read_string(DEFAULT_LOCATION, s_default_location, sizeof(s_default_location)); memset(s_location_opt, 0, sizeof(s_location_opt)); if (persist_exists(LOCATION_OPT)) persist_read_string(LOCATION_OPT, s_location_opt, sizeof(s_location_opt)); config_location_setting(s_default_location, s_location_opt); }
static void load_text(int key, bool update_layer) { free_text(key); if (persist_exists(key)) { int size = persist_get_size(key); label_text[key] = malloc(size); persist_read_string(key, label_text[key], size); } else { label_text[key] = a2_strdup(label_default_text[key]); } if (update_layer) { text_layer_set_text(text_layers[key], label_text[key]); } }
char* GetThreadSubreddit(int index) { #ifdef USE_PERSIST_STRINGS if(persist_index_subreddit != index) { persist_index_subreddit = index; if(persist_read_string(PERSIST_OFFSET_THREAD_SUBREDDIT + index, persist_string_subreddit, PERSIST_STRING_MAX_LENGTH) == E_DOES_NOT_EXIST) { return NULL; } } return persist_string_subreddit; #else return threads[index].subreddit; #endif }
bool load_persistent(Menu *menu) { if(menu->id == 0 && persist_exists(0) && persist_read_int(0) > 0) { int size = persist_read_int(0); menu_allocation(menu, size); for(int i = 1; persist_exists(i); i++) { persist_read_string(i, menu->row[i-1]->title, 32); snprintf(menu->title, 32, "%s", "Favorites"); snprintf(menu->row[i-1]->subtitle, 32, "%s", ""); menu->size = size; } return true; } return false; }
// Call once from init()/deinit() void cache_init() { app_log_ts(APP_LOG_LEVEL_DEBUG, " cache_init() "); if (persist_exists(STATE_KEY)){ persist_read_data(STATE_KEY, state_cache, sizeof(state_cache)); } if (persist_exists(TIME_KEY)){ persist_read_data(TIME_KEY, time_cache, sizeof(time_cache)); } if (persist_exists(HEIGHT_KEY)){ persist_read_data(HEIGHT_KEY, height_cache, sizeof(height_cache)); } if (persist_exists(PORTNAME_KEY)){ persist_read_string(PORTNAME_KEY, portname_cache, sizeof(portname_cache)); } app_log_ts(APP_LOG_LEVEL_DEBUG, " cache_init() - exit "); }
SaveState slots_load_state() { persist_read_string(DATA_WORKOUT_SAVE_STATE, res, 200); SaveState state = (SaveState) { .save1_in_use = false, .save2_in_use = false, .save3_in_use = false }; read_key_values_unsafe(&state, res, state_read_callback); return state; } void slots_save_state(SaveState state) { snprintf(res, 200, "1=%d;2=%d;3=%d;", state.save1_in_use ? 1 : 0, state.save2_in_use ? 1 : 0, state.save3_in_use ? 1 : 0); APP_LOG(APP_LOG_LEVEL_WARNING, "updating state: %s", res); persist_write_string(DATA_WORKOUT_SAVE_STATE, res); }
static void main_window_load(Window *window) { //Initialize the backgrounds we can select s_dog_bg = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_DOG); s_cat_bg = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_CAT); s_bird_bg = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_BIRD); // Create time TextLayer s_time_layer = text_layer_create(GRect(0, 0, 144, 32)); text_layer_set_background_color(s_time_layer, GColorClear); text_layer_set_text_color(s_time_layer, GColorBlack); // Improve the layout to be more like a watchface s_time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MULI_24)); text_layer_set_font(s_time_layer, s_time_font); text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter); //Check for saved background option char facebg[20]; persist_read_string(KEY_BG, facebg, sizeof(facebg)); if(strcmp(facebg,"dog") == 0){ s_bg_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_DOG); }else if(strcmp(facebg,"cat") == 0){ s_bg_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_CAT); }else if(strcmp(facebg,"bird") == 0){ s_bg_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BG_BIRD); } //Declare a bitmap layer //static BitmapLayer *s_bitmap_layer; //Create bitmap layer and set it to show the GBitmap s_bitmap_layer = bitmap_layer_create(GRect(0,0,144,168)); bitmap_layer_set_bitmap(s_bitmap_layer,s_bg_bitmap); //Add the bitmaplayer as a child layer to the window: layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_bitmap_layer)); // Add text layer as a child layer to the Window's root layer layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_time_layer)); }
static void draw_row_callback(GContext *ctx, const Layer *cell_layer, MenuIndex *cell_index, void *callback_context) { int event_no = get_event_no_from_row_index(cell_index->row); if (!persist_exists(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE)) return; char event_title[PERSIST_STRING_MAX_LENGTH]; persist_read_string(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE, event_title, PERSIST_STRING_MAX_LENGTH); char event_subtitle[55]; char duration_string[10] = ""; if (persist_exists(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_START_DATE)) { int start_date = persist_read_int(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_START_DATE); if (persist_exists(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE)) { int end_date = persist_read_int(event_no * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE); int duration = end_date - start_date; if (duration / 3600.0 != 24) { format_date_time(event_subtitle, 40, (time_t)start_date, 1); float_to_string(duration_string, 10, duration / 3600.0); strcat(event_subtitle, ", "); strcat(event_subtitle, duration_string); strcat(event_subtitle, "h"); } else { format_date_time(event_subtitle, 40, (time_t)start_date, 0); } } else { format_date_time(event_subtitle, 40, (time_t)start_date, 1); } } menu_cell_basic_draw(ctx, cell_layer, event_title, event_subtitle, NULL); }
static void init(void) { //initialize invertTime invertTime.offMin = 255; invertTime.offHour = 255; invertTime.onMin = 255; invertTime.onHour = 255; invertTime.updateMin = 255; invertTime.updateHour = 255; invertTime.type = OFF; // load user settings if(persist_exists(KEY_HAND_ORDER)) { persist_read_string(KEY_HAND_ORDER, s_hand_order, 4); } if(persist_exists(KEY_TEXT_TIME)) { s_show_text_time = persist_read_bool(KEY_TEXT_TIME); } if(persist_exists(KEY_INVERT)) { s_inverted = persist_read_bool(KEY_INVERT); } if(persist_exists(PS_INVERT_TIME)) { persist_read_data(PS_INVERT_TIME, &invertTime, sizeof(invertTime)); } //register service to receive config from phone app_message_register_inbox_received((AppMessageInboxReceived)in_recv_handler); app_message_register_outbox_failed(outbox_failed_callback); app_message_register_outbox_sent(outbox_sent_callback); app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); // create main window and assign to pointer s_main_window = window_create(); //assign main window handlers window_set_window_handlers(s_main_window, (WindowHandlers) { .load = main_window_load, .unload = main_window_unload });
// Makes sure storage is populated (by checking and, on absence, writing // defaults) and then reading values. void storage_init(void) { LOG_FUNC(); // THIS MUST NEVER BE ENABLED */for (unsigned int i = 0; i <= MAXIMUM_EVER_USED; i++) { // THIS MUST NEVER BE ENABLED */ if ((i % 10000) == 0) { // THIS MUST NEVER BE ENABLED */ LOG_EXT(LOG_STORAGE, "storage_init(): working key %d", i); // THIS MUST NEVER BE ENABLED */ } // THIS MUST NEVER BE ENABLED */ if (persist_exists(i)) { // THIS MUST NEVER BE ENABLED */ LOG_EXT(LOG_STORAGE, "storage_init(): deleting key %d", i); // THIS MUST NEVER BE ENABLED */ persist_delete(i); // THIS MUST NEVER BE ENABLED */ } // THIS MUST NEVER BE ENABLED */} if (!persist_exists(SELECTED_VERSION)) { persist_write_string(SELECTED_VERSION, "Regular"); LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %s", SELECTED_VERSION, "Regular"); } persist_read_string(SELECTED_VERSION, storage.selectedVersion, 64); if (!persist_exists(BATTERY_ESTIMATE)) { persist_write_data(BATTERY_ESTIMATE, (void*)&battery_estimate_data_init, sizeof(battery_estimate_data)); LOG_EXT(LOG_STORAGE, "storage_init(): init %d", BATTERY_ESTIMATE); } persist_read_data(BATTERY_ESTIMATE, (void*)&(storage.battery_estimate), sizeof(battery_estimate_data)); if (!persist_exists(LAST_FULL_TIMESTAMP)) { persist_write_int(LAST_FULL_TIMESTAMP, (time_t)-1); LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %ld", LAST_FULL_TIMESTAMP, (time_t)-1); } storage.last_full_timestamp = persist_read_int(LAST_FULL_TIMESTAMP); if (!persist_exists(BATTERY_DISPLAY)) { persist_write_int(BATTERY_DISPLAY, 7); LOG_EXT(LOG_STORAGE, "storage_init(): init %d with data %d", BATTERY_DISPLAY, 1); } storage.battery_display = persist_read_int(BATTERY_DISPLAY); app_log_storage_log(LOG_STORAGE_SU); }
void readConfig() { if (persist_exists(CONFIG_KEY_DATEORDER)) { USDate = persist_read_int(CONFIG_KEY_DATEORDER); } else { USDate = 1; persist_write_int(CONFIG_KEY_DATEORDER, USDate); } if (persist_exists(CONFIG_KEY_WEEKDAY)) { showWeekday = persist_read_int(CONFIG_KEY_WEEKDAY); } else { showWeekday = 0; persist_write_int(CONFIG_KEY_WEEKDAY, showWeekday); } if (persist_exists(CONFIG_KEY_BATTERY)) { batteryStatus = persist_read_int(CONFIG_KEY_BATTERY); } else { batteryStatus = 1; persist_write_int(CONFIG_KEY_BATTERY, batteryStatus); } if (persist_exists(CONFIG_KEY_BLUETOOTH)) { bluetoothStatus = persist_read_int(CONFIG_KEY_BLUETOOTH); } else { bluetoothStatus = 1; persist_write_int(CONFIG_KEY_BLUETOOTH, bluetoothStatus); } if (persist_exists(CONFIG_KEY_INVERT)) { invertStatus = persist_read_int(CONFIG_KEY_INVERT); } else { invertStatus = 0; persist_write_int(CONFIG_KEY_INVERT, invertStatus); } if (persist_exists(CONFIG_KEY_LANG)) { curLang = persist_read_int(CONFIG_KEY_LANG); } else { curLang = LANG_ENGLISH; persist_write_int(CONFIG_KEY_LANG, curLang); } if (persist_exists(CONFIG_KEY_STRIPES)) { stripedDigits = persist_read_int(CONFIG_KEY_STRIPES); } else { stripedDigits = 1; persist_write_int(CONFIG_KEY_STRIPES, stripedDigits); } if (persist_exists(CONFIG_KEY_ROUNDCORNERS)) { roundCorners = persist_read_int(CONFIG_KEY_ROUNDCORNERS); } else { roundCorners = 1; persist_write_int(CONFIG_KEY_ROUNDCORNERS, roundCorners); } if (persist_exists(CONFIG_KEY_FULLDIGITS)) { fullDigits = persist_read_int(CONFIG_KEY_FULLDIGITS); } else { fullDigits = 0; persist_write_int(CONFIG_KEY_FULLDIGITS, fullDigits); } if (persist_exists(CONFIG_KEY_COLORTHEME)) { colorTheme = persist_read_int(CONFIG_KEY_COLORTHEME); } else { colorTheme = 0; persist_write_int(CONFIG_KEY_COLORTHEME, colorTheme); } if (persist_exists(CONFIG_KEY_THEMECODE)) { persist_read_string(CONFIG_KEY_THEMECODE, themeCodeText, sizeof(themeCodeText)); } else { strcpy(themeCodeText, "ffffffffffc0"); persist_write_string(CONFIG_KEY_THEMECODE, themeCodeText); } decodeThemeCode(themeCodeText); APP_LOG(APP_LOG_LEVEL_DEBUG, "Stored config :"); APP_LOG(APP_LOG_LEVEL_DEBUG, " dateorder=%d, weekday=%d, battery=%d, BT=%d, invert=%d", USDate, showWeekday, batteryStatus, bluetoothStatus, invertStatus); APP_LOG(APP_LOG_LEVEL_DEBUG, " lang=%d, stripedDigits=%d, roundCorners=%d, fullDigits=%d", curLang, stripedDigits, roundCorners, fullDigits); APP_LOG(APP_LOG_LEVEL_DEBUG, " colorTheme=%d, themecode=%s", colorTheme, themeCodeText); }
static void init() { APP_LOG(APP_LOG_LEVEL_DEBUG, "GlobalTime initialising... build: %s", build_time); // Create main Window element and assign to pointer s_main_window = window_create(); window_set_background_color(s_main_window, GColorBlack); // Create popup window s_popup_window = window_create(); window_set_background_color(s_popup_window, GColorBlack); popup_window_load(s_popup_window); ResHandle big_handle = resource_get_handle(RESOURCE_ID_FONT_COMFORTAA_BOLD_33); s_big_font = fonts_load_custom_font(big_handle); ResHandle medium_handle = resource_get_handle(RESOURCE_ID_FONT_COMFORTAA_BOLD_23); s_medium_font = fonts_load_custom_font(medium_handle); ResHandle small_handle = resource_get_handle(RESOURCE_ID_FONT_COMFORTAA_REGULAR_15); s_small_font = fonts_load_custom_font(small_handle); s_bmp_bt = gbitmap_create_with_resource(RESOURCE_ID_BMP_BT); s_bmp_nobt = gbitmap_create_with_resource(RESOURCE_ID_BMP_NOBT); s_bmp_charge = gbitmap_create_with_resource(RESOURCE_ID_BMP_CHARGE); s_bmp_nocharge = gbitmap_create_with_resource(RESOURCE_ID_BMP_NOCHARGE); s_bmp_battery[0] = gbitmap_create_with_resource(RESOURCE_ID_BMP_00); s_bmp_battery[1] = gbitmap_create_with_resource(RESOURCE_ID_BMP_10); s_bmp_battery[2] = gbitmap_create_with_resource(RESOURCE_ID_BMP_20); s_bmp_battery[3] = gbitmap_create_with_resource(RESOURCE_ID_BMP_30); s_bmp_battery[4] = gbitmap_create_with_resource(RESOURCE_ID_BMP_40); s_bmp_battery[5] = gbitmap_create_with_resource(RESOURCE_ID_BMP_50); s_bmp_battery[6] = gbitmap_create_with_resource(RESOURCE_ID_BMP_60); s_bmp_battery[7] = gbitmap_create_with_resource(RESOURCE_ID_BMP_70); s_bmp_battery[8] = gbitmap_create_with_resource(RESOURCE_ID_BMP_80); s_bmp_battery[9] = gbitmap_create_with_resource(RESOURCE_ID_BMP_90); // Read current TZ config persist_read_string(KEY_TZ1, s_tz[0], TZ_SIZE); persist_read_string(KEY_TZ2, s_tz[1], TZ_SIZE); persist_read_string(KEY_TZ3, s_tz[2], TZ_SIZE); persist_read_string(KEY_TZ4, s_tz[3], TZ_SIZE); persist_read_string(KEY_TZ5, s_tz[4], TZ_SIZE); persist_read_string(KEY_TZ6, s_tz[5], TZ_SIZE); persist_read_string(KEY_TZ7, s_tz[6], TZ_SIZE); persist_read_string(KEY_TZ8, s_tz[7], TZ_SIZE); s_offset[0] = persist_read_int(KEY_OFFSET1); s_offset[1] = persist_read_int(KEY_OFFSET2); s_offset[2] = persist_read_int(KEY_OFFSET3); s_offset[3] = persist_read_int(KEY_OFFSET4); s_offset[4] = persist_read_int(KEY_OFFSET5); s_offset[5] = persist_read_int(KEY_OFFSET6); s_offset[6] = persist_read_int(KEY_OFFSET7); s_offset[7] = persist_read_int(KEY_OFFSET8); persist_read_string(KEY_LABEL1, s_label[0], LABEL_SIZE); persist_read_string(KEY_LABEL2, s_label[1], LABEL_SIZE); persist_read_string(KEY_LABEL3, s_label[2], LABEL_SIZE); persist_read_string(KEY_LABEL4, s_label[3], LABEL_SIZE); persist_read_string(KEY_LABEL5, s_label[4], LABEL_SIZE); persist_read_string(KEY_LABEL6, s_label[5], LABEL_SIZE); persist_read_string(KEY_LABEL7, s_label[6], LABEL_SIZE); persist_read_string(KEY_LABEL8, s_label[7], LABEL_SIZE); for (int i = 0; i < CONFIG_SIZE; i++) { APP_LOG(APP_LOG_LEVEL_DEBUG, "Loaded TZ configuration 1: %s - %s (%ld)", s_label[i], s_tz[i], s_offset[i]); } sort_times(); // Register a callback for the UTC offset information // TODO register failure callbacks too app_message_register_inbox_received(inbox_received_callback); // Connect to AppMessage stream app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); // Send a request for TZ offsets send_tz_request(); // Set handlers to manage the elements inside the Window window_set_window_handlers(s_main_window, (WindowHandlers) { .load = main_window_load, .unload = main_window_unload });
static void handle_init(void) { time_t rawtime; time (&rawtime); struct tm * tick_time; tick_time = localtime(&rawtime); tick_time->tm_year = 2014 - 1900; tick_time->tm_mon = 12 - 1; tick_time->tm_mday = 9; tick_time->tm_hour = 12 - 1; tick_time->tm_min = 0; tick_time->tm_sec = 0; start_time = mktime(tick_time); tick_time = localtime(&rawtime); tick_time->tm_year = 2015 - 1900; tick_time->tm_mon = 12 - 1; tick_time->tm_mday = 9; tick_time->tm_hour = 12 - 1; tick_time->tm_min = 0; tick_time->tm_sec = 0; end_time = mktime(tick_time); strcpy(text_otslujul, "Ты отслужил"); strcpy(text_ostalos, "До дембеля осталось"); strcpy(text_uje, "Ты дембель уже"); // Read stored settings if (persist_exists(MSG_START_TIME)) start_time = persist_read_int(MSG_START_TIME); if (persist_exists(MSG_END_TIME)) end_time = persist_read_int(MSG_END_TIME); if (persist_exists(MSG_TEXT_OTSLUJIL)) persist_read_string(MSG_TEXT_OTSLUJIL, text_otslujul, sizeof(text_otslujul)); if (persist_exists(MSG_TEXT_OSTALOS)) persist_read_string(MSG_TEXT_OSTALOS, text_ostalos, sizeof(text_ostalos)); if (persist_exists(MSG_TEXT_UJE)) persist_read_string(MSG_TEXT_UJE, text_uje, sizeof(text_uje)); // Open communication channel app_message_register_inbox_received(in_received_handler); app_message_open(256, 256); // Create a window and text layer window = window_create(); // Current time layer time_layer = text_layer_create(GRect(0, 0, 144, 50)); // Set the text, font, and text alignment text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD)); text_layer_set_background_color(time_layer, GColorClear); text_layer_set_text_alignment(time_layer, GTextAlignmentCenter); // Add the text layer to the window layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer)); // Left time layer left_time_layer = text_layer_create(GRect(0, 47, 144, 80)); // Set the text, font, and text alignment text_layer_set_font(left_time_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18)); text_layer_set_background_color(left_time_layer, GColorClear); text_layer_set_text_alignment(left_time_layer, GTextAlignmentCenter); // Add the text layer to the window layer_add_child(window_get_root_layer(window), text_layer_get_layer(left_time_layer)); // Another Left time layer left_time_layer2 = text_layer_create(GRect(0, 67, 144, 80)); // Set the text, font, and text alignment text_layer_set_font(left_time_layer2, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); text_layer_set_background_color(left_time_layer2, GColorClear); text_layer_set_text_alignment(left_time_layer2, GTextAlignmentCenter); // Add the text layer to the window layer_add_child(window_get_root_layer(window), text_layer_get_layer(left_time_layer2)); // Percent layer percent_layer = text_layer_create(GRect(0, 130, 144, 80)); // Set the text, font, and text alignment text_layer_set_font(percent_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD)); text_layer_set_background_color(percent_layer, GColorClear); text_layer_set_text_alignment(percent_layer, GTextAlignmentCenter); // Add the text layer to the window layer_add_child(window_get_root_layer(window), text_layer_get_layer(percent_layer)); // Create progress bar progress_layer = layer_create(GRect(2, 150, 140, 15)); layer_set_update_proc(progress_layer, &progress_layer_update_callback); layer_add_child(window_get_root_layer(window), progress_layer); time_t now = time(NULL); handle_tick(localtime(&now), 0); // Push the window window_stack_push(window, true); // Subscribe to time updates tick_timer_service_subscribe(MINUTE_UNIT, handle_tick); //light_enable(true); // For taking photos only! }