// This should probably go in the helper file with the save logic.
// But it's late and I want to get saving/loading working.
static void load_game() {
// We already know that we have valid data (can_load).
lines_cleared = persist_read_int(SCORE_KEY);
level = (lines_cleared / 10) + 1;
if (level > 10) { level = 10; }
update_num_layer(lines_cleared, scoreStr, score_layer);
update_num_layer(level, levelStr, level_layer);
tick_time = max_tick - (tick_interval * level);
persist_read_data(GRID_KEY, grid, sizeof(grid));
persist_read_data(GRID_COL_KEY, grid_col, sizeof(grid_col));
blockType = persist_read_int(BLOCK_TYPE_KEY);
nextBlockType = persist_read_int(NEXT_BLOCK_TYPE_KEY);
blockX = persist_read_int(BLOCK_X_KEY);
blockY = persist_read_int(BLOCK_Y_KEY);
make_block(block, blockType, blockX, blockY);
make_block(nextBlock, nextBlockType, nextBlockX, nextBlockY);
rotation = persist_read_int(ROTATION_KEY);
if (rotation != 0) {
for (int i=0; i<rotation; i++) {
GPoint rPoints[4];
rotate_block(rPoints, block, blockType, i);
for (int j=0; j<4; j++) {
block[j] = rPoints[j];
}
}
}
}
void settings_load(void) {
if (persist_exists(PERSIST_SETTINGS)) {
if (! persist_exists(PERSIST_SETTINGS_VERSION)) {
DEBUG("Migrating settings from 2.X to 3.X");
OldSettings old_settings;
int res = persist_read_data(PERSIST_SETTINGS, &old_settings, sizeof(old_settings));
if (res >= 0) {
migrate_settings_01(old_settings);
return;
}
}
else if (persist_read_int(PERSIST_SETTINGS_VERSION) == SETTINGS_VERSION_TINY) {
SettingsTiny settings_tiny;
int res = persist_read_data(PERSIST_SETTINGS, &settings_tiny, sizeof(settings_tiny));
if (res >= 0) {
migrate_settings_02(settings_tiny);
return;
}
}
int res = persist_read_data(PERSIST_SETTINGS, &_settings, sizeof(_settings));
if (res < 0) {
LOG("Settings load failed: %d", res);
}
}
}
/**
* Function to restore the presets saved in persistent storage into the list.
*/
void presets_restore(void){
presets_clear();
if (!persist_exists(STORAGE_PRESET_START))
return;
int block = 0;
PresetBlock* presetBlock = malloc(sizeof(PresetBlock));
persist_read_data(STORAGE_PRESET_START, presetBlock, sizeof(PresetBlock));
uint8_t preset_count = presetBlock->count;
int save_time = presetBlock->time;
int now = time(NULL);
int seconds_elapsed = now-save_time;
int minutes_elapse = (int)(floorl(seconds_elapsed / 60));
for (int i = 0; i < preset_count; i++){
if (i > 0 && i % PRESET_BLOCK_SIZE == 0){
block += 1;
free(presetBlock);
presetBlock = malloc(sizeof(PresetBlock));
persist_read_data(STORAGE_PRESET_START + block, presetBlock, sizeof(PresetBlock));
}
Preset *preset = preset_clone(&presetBlock->presets[i % PRESET_BLOCK_SIZE]);
preset->eta -= minutes_elapse;
if (preset->eta <= 0)
preset->eta = PRESET_REFRESHING_ETA;
presets_add(preset);
}
free(presetBlock);
send_all_eta_req();
return;
}
void Settings_init() {
// first, check if we have any saved settings
if (persist_exists(SETTINGS_PERSIST_KEY)) {
// if we do, what version of the settings was saved?
uint32_t savedVersion = persist_read_int(SETTINGS_VERSION_KEY);
if(savedVersion == 2) { // in this case, we can direclty load the current version
persist_read_data(SETTINGS_PERSIST_KEY, &globalSettings, sizeof(Settings));
} else { // in this case, we're upgrading from the old version
// first, read in the settings using the original format
Settings_v0 oldSettings;
persist_read_data(SETTINGS_PERSIST_KEY, &oldSettings, sizeof(Settings_v0));
// now upgrade to the new format
globalSettings.timeColor = oldSettings.timeColor;
globalSettings.timeBgColor = oldSettings.timeBgColor;
globalSettings.sidebarColor = oldSettings.sidebarColor;
globalSettings.useMetric = oldSettings.useMetric;
globalSettings.sidebarOnRight = oldSettings.sidebarOnRight;
// fill the new settings, use the defaults
Settings_loadV2Defaults();
}
} else {
// if there weren't any saved settings, load the defaults
Settings_loadAllDefaults();
}
// if it doesn't exist, we get "0", which is the default anyway
Settings_showLeadingZero = persist_read_int(SETTING_LEADING_ZERO_KEY);
}
static void window_load(Window *window) {
Layer *root_layer = window_get_root_layer(window);
if (persist_exists(PERSIST_KEY_ID_POMODORO)) {
persist_read_data(PERSIST_KEY_ID_POMODORO, &pomodoro, sizeof(pomodoro));
}
if (persist_exists(PERSIST_KEY_ID_POMODORO_CYCLE)) {
persist_read_data(PERSIST_KEY_ID_POMODORO_CYCLE, &pomodoro.cycle, sizeof(pomodoro.cycle));
}
if (persist_exists(PERSIST_KEY_ID_POMODORO_CYCLE_NOW)) {
persist_read_data(PERSIST_KEY_ID_POMODORO_CYCLE_NOW, &pomodoro.timer, sizeof(pomodoro.timer));
if (pomodoro.cycle <= pomodoro.timer) pomodoro.timer = -1;
}
tick_timer_service_subscribe(HOUR_UNIT | MINUTE_UNIT, tick_handler);
// LOAD RESOURCE
uint8_t resource_id = (uint8_t)RESOURCE_ID_HANNA_B;
for (uint8_t i = 0; i < bitmaps_length; ++i) {
bitmaps[i] = gbitmap_create_with_resource((uint8_t)(resource_id + i));
}
load_layers(root_layer);
}
void readSettings(){
if( persist_exists(BLACK_KEY)) black = persist_read_bool(BLACK_KEY);
if( persist_exists(GRID_KEY)) grid = persist_read_bool(GRID_KEY);
if( persist_exists(INVERT_KEY)) invert = persist_read_bool(INVERT_KEY);
if( persist_exists(SHOWTIME_KEY)) showtime = persist_read_bool(SHOWTIME_KEY);
if( persist_exists(HIDELASTPREV_KEY)) hidelastprev = persist_read_bool(HIDELASTPREV_KEY);
if( persist_exists(HIDEAGENDA_KEY)) hideagenda = persist_read_bool(HIDEAGENDA_KEY);
if( persist_exists(NOTINVERTAGENDA_KEY)) notinvertagenda = persist_read_bool(NOTINVERTAGENDA_KEY);
if( persist_exists(BOLDEVENTS_KEY)) boldevents = persist_read_bool(BOLDEVENTS_KEY);
if( persist_exists(SHOWLABELS_KEY)) showlabels = persist_read_bool(SHOWLABELS_KEY);
if( persist_exists(SHOWDATE_KEY)) showdate = persist_read_bool(SHOWDATE_KEY);
if( persist_exists(START_OF_WEEK_KEY)) start_of_week = persist_read_int(START_OF_WEEK_KEY);
if( persist_exists(SHOWWEEKNO_KEY)) showweekno = persist_read_int(SHOWWEEKNO_KEY);
if( persist_exists(WEEKSTOSHOW_KEY)) weekstoshow = persist_read_int(WEEKSTOSHOW_KEY);
if( persist_exists(AGENDA_TITLE_KEY)) agenda_title_rows = persist_read_int(AGENDA_TITLE_KEY);
if( persist_exists(AGENDALENGTH_KEY)) agendaLength = persist_read_int(AGENDALENGTH_KEY);
for(int i = 0; i<MAX_AGENDA_LENGTH;i++ ){
if( persist_exists(AGENDATITLE_KEY+i)){
persist_read_data(AGENDATITLE_KEY+i,agendaTitle[i],sizeof(agendaTitle[i]));
persist_read_data(AGENDADATE_KEY+i, agendaDate[i], sizeof(agendaDate[i]));
persist_read_data(AGENDATIME_KEY+i, agendaTime[i], sizeof(agendaTime[i]));
}
}
}
/*
* 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();
}
bool LoadPersistedData(void)
{
CharacterData *characterData;
int floor = 0;
bool useWorkerApp = false;
if(!persist_exists(PERSISTED_IS_DATA_SAVED) || !persist_read_bool(PERSISTED_IS_DATA_SAVED))
return false;
if(!IsPersistedDataCurrent())
{
WARNING_LOG("Persisted data does not match current version, clearing.");
ClearPersistedData();
return false;
}
ProfileLogStart("LoadPersistedData");
INFO_LOG("Loading persisted data.");
characterData = GetCharacter();
persist_read_data(PERSISTED_CHARACTER_DATA, characterData, sizeof(CharacterData));
floor = persist_read_int(PERSISTED_CURRENT_FLOOR);
SetCurrentFloor(floor);
persist_read_data(PERSISTED_ITEM_DATA, GetItemsOwned(), GetSizeOfItemsOwned());
SetStatPointsPurchased(persist_read_int(PERSISTED_STAT_POINTS_PURCHASED));
SetVibration(persist_read_bool(PERSISTED_VIBRATION));
SetFastMode(persist_read_bool(PERSISTED_FAST_MODE));
if(persist_exists(PERSISTED_USE_OLD_ASSETS))
SetUseOldAssets(persist_read_bool(PERSISTED_USE_OLD_ASSETS));
useWorkerApp = persist_read_bool(PERSISTED_WORKER_APP);
if(useWorkerApp)
{
AttemptToLaunchWorkerApp();
}
else
{
// If the user has launched the worker app outside of MiniDungeon,
// they want it on.
if(WorkerIsRunning())
SetWorkerApp(true);
}
SetWorkerCanLaunch(persist_read_bool(PERSISTED_WORKER_CAN_LAUNCH));
if(persist_read_bool(PERSISTED_IN_COMBAT))
{
int currentMonster = persist_read_int(PERSISTED_MONSTER_TYPE);
int currentMonsterHealth = persist_read_int(PERSISTED_MONSTER_HEALTH);
ResumeBattle(currentMonster, currentMonsterHealth);
}
ProfileLogStop("LoadPersistedData");
if(characterData->level == 0)
{
// Something bad happened to the data, possible due to a watch crash
ERROR_LOG("Persisted data was broken somehow, clearing");
ClearPersistedData();
return false;
}
return true;
}
bool LoadPersistedData(void)
{
CharacterData *characterData;
int floor = 0;
if(!persist_exists(PERSISTED_IS_DATA_SAVED) || !persist_read_bool(PERSISTED_IS_DATA_SAVED))
return false;
if(!IsPersistedDataCurrent())
{
WARNING_LOG("Persisted data does not match current version, clearing.");
ClearPersistedData();
return false;
}
INFO_LOG("Loading persisted data.");
characterData = GetCharacter();
persist_read_data(PERSISTED_CHARACTER_DATA, characterData, sizeof(CharacterData));
floor = persist_read_int(PERSISTED_CURRENT_FLOOR);
SetCurrentFloor(floor);
uint8_t * itemsOwned = malloc(sizeof(uint8_t) * ITEM_TYPE_COUNT);
persist_read_data(PERSISTED_ITEM_DATA, itemsOwned, sizeof(itemsOwned));
SetItemOwned(itemsOwned);
free(itemsOwned);
SetStatPointsPurchased(persist_read_int(PERSISTED_STAT_POINTS_PURCHASED));
SetVibration(persist_read_bool(PERSISTED_VIBRATION));
SetFastMode(persist_read_bool(PERSISTED_FAST_MODE));
SetEasyMode(persist_read_bool(PERSISTED_EASY_MODE));
CardSave saves[NB_TYPE_CARDS];
persist_read_data(PERSISTED_CARD_DECK, saves, sizeof(saves));
SetCardSave(saves);
SetEntriesSize(persist_read_int(PERSISTED_ENTRIES_SIZE));
if(persist_read_bool(PERSISTED_IN_COMBAT))
{
persist_read_data(PERSISTED_MONSTER_TYPE, GetCurMonster(), sizeof(MonsterInfo));
ResumeBattle();
}
if(characterData->level == 0)
{
// Something bad happened to the data, possible due to a watch crash
ERROR_LOG("Persisted data was broken somehow, clearing");
ClearPersistedData();
return false;
}
return true;
}
static void history_load() {
if (persist_exists(MESSAGE_KEY_batches)) {
current_history_batch = persist_read_int(MESSAGE_KEY_batches);
}
if (current_history_batch < 0) {
// APP_LOG(APP_LOG_LEVEL_DEBUG, "No history in persistent storage: %d", current_history_batch);
return;
}
// APP_LOG(APP_LOG_LEVEL_DEBUG, "Reading %d history batches from persistent storage", current_history_batch+1);
int total_bytes_read = 0;
for (int i=0; i<=current_history_batch; i++) {
if (persist_exists(FIRST_HISTORY_BATCH+i)) {
// int result = persist_read_data(FIRST_HISTORY_BATCH+i, &history[i], sizeof(history[i]));
// APP_LOG(APP_LOG_LEVEL_DEBUG, "Loaded history batch %d, %d bytes, %d events, result %d", i, (int) sizeof(history[i]), history[i].last_event+1, result);
persist_read_data(FIRST_HISTORY_BATCH+i, &history[i], sizeof(history[i]));
total_bytes_read += sizeof(history[i]);
}
else {
APP_LOG(APP_LOG_LEVEL_WARNING, "No history batch %d although current_history_batch %d indicates its existence!", i, current_history_batch);
}
}
start_time = (int) history[0].event_time[0];
selected = (Selected) {current_history_batch, history[current_history_batch].last_event};
events = current_history_batch * HISTORY_BATCH_SIZE + history[current_history_batch].last_event + 1;
if (persist_exists(MESSAGE_KEY_avgMood)) {
average_mood = persist_read_int(MESSAGE_KEY_avgMood);
}
APP_LOG(APP_LOG_LEVEL_DEBUG, "Total history: %d batches, %d events, %d bytes", current_history_batch+1, events, total_bytes_read);
}
void cdt_init(void) {
if (persist_exists(KEY_CDT)) {
persist_read_data(KEY_CDT, &cdt, sizeof(cdt));
} else {
cdt_reset_all();
}
}
void bgpicker_init() {
// first, load and set all the background images
// awkwardly force bw images in the case of a black and white watch
#ifdef PBL_COLOR
bgpicker_dayparts[0].backgroundImageId = RESOURCE_ID_IMAGE_BG0_NIGHT;
bgpicker_dayparts[1].backgroundImageId = RESOURCE_ID_IMAGE_BG1_TWILIGHT;
bgpicker_dayparts[2].backgroundImageId = RESOURCE_ID_IMAGE_BG2_SUNRISE;
bgpicker_dayparts[3].backgroundImageId = RESOURCE_ID_IMAGE_BG3_MIDDAY;
bgpicker_dayparts[4].backgroundImageId = RESOURCE_ID_IMAGE_BG4_AFTERNOON;
bgpicker_dayparts[5].backgroundImageId = RESOURCE_ID_IMAGE_BG5_SUNSET;
bgpicker_dayparts[6].backgroundImageId = RESOURCE_ID_IMAGE_BG6_TWILIGHT;
bgpicker_dayparts[7].backgroundImageId = RESOURCE_ID_IMAGE_BG0_NIGHT;
#else
bgpicker_dayparts[0].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG0_NIGHT;
bgpicker_dayparts[1].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG1_TRANSITION;
bgpicker_dayparts[2].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG1_TRANSITION;
bgpicker_dayparts[3].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG2_DAY;
bgpicker_dayparts[4].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG2_DAY;
bgpicker_dayparts[5].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG1_TRANSITION;
bgpicker_dayparts[6].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG1_TRANSITION;
bgpicker_dayparts[7].backgroundImageId = RESOURCE_ID_IMAGE_BW_BG0_NIGHT;
#endif
// if we have a location set in persistent storage, use that
if (persist_exists(BGPICKER_LOC_KEY)) {
LocationInfo loc;
persist_read_data(BGPICKER_LOC_KEY, &loc, sizeof(LocationInfo));
bgpicker_updateLocation(loc);
} else {
// otherwise, just use the default data
bgpicker_setSunriseSunset(DEFAULT_SUNRISE_TIME, DEFAULT_SUNSET_TIME);
}
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
int i;
static char log[PERSIST_LOG_MAX][PERSIST_LOG_LEN]={""};
for(i=0;i<PERSIST_LOG_MAX;i++){
log_t logn;
persist_read_data(NUM_PERSIST_LOG+i, &logn, sizeof(logn));
if(logn.sets != 0 ){
if(cfg_adv){
snprintf(log[i], PERSIST_LOG_LEN,
"%02d%02d|%2dx(%3d+%3d+%3d+%2d)",
logn.mon, logn.day, //logn.hour, logn.min,
logn.sets, logn.time[0], logn.time[1], logn.time[2], logn.rest);
}
else{
snprintf(log[i], PERSIST_LOG_LEN,
"[%02d%02d %02d%02d]%2dx3x%3d(%2d)",
logn.mon, logn.day, logn.hour, logn.min,
logn.sets, logn.time[0], logn.rest);
}
APP_LOG(APP_LOG_LEVEL_DEBUG, "Loading %s from %d", log[i], i);
text_layer[i] = text_layer_create((GRect) { .origin = { 0, i*20 }, .size = { bounds.size.w, 20 } });
text_layer_set_text(text_layer[i], log[i]);
text_layer_set_text_alignment(text_layer[i], GTextAlignmentLeft);
layer_add_child(window_layer, text_layer_get_layer(text_layer[i]));
}
// Initialization
static void init() {
s_main_window = window_create();
s_set_window = window_create();
// Remove the statusbar on SDK 2
#ifdef PBL_SDK_2
window_set_fullscreen(s_main_window, true);
window_set_fullscreen(s_set_window, true);
#endif
// Read the persistent storage. Probably incorrectly
valueRead = persist_read_data(SETTINGS_KEY, &settings, sizeof(settings));
// Read the persistent storage better, meaning after that read fails, just go ahead and fix it
if (settings.c_1 == 0) {
settings.c_1 = 5;
settings.c_2 = 5;
settings.c_3 = 5;
settings.c_4 = 5;
settings.set = false;
}
window_set_background_color(s_main_window, GColorBlack);
window_set_background_color(s_set_window, GColorBlack);
window_set_window_handlers(s_main_window, (WindowHandlers) {
.load = main_window_load,
.unload = main_window_unload,
});
static void update_visible_layers(void) {
const bool refresh_layer_hidden = !updating && persist_exists(STORAGE_REWARDS_UPDATED_AT);
const bool cards_layer_hidden = updating || !refresh_layer_hidden || (current_page == 0);
const bool stats_layer_hidden = updating || !refresh_layer_hidden || !cards_layer_hidden;
const bool pager_layer_hidden = updating;
uint8_t num_cards = 0;
persist_read_data(STORAGE_NUMBER_OF_CARDS, &num_cards, sizeof(num_cards));
if (current_page > num_cards) {
current_page = num_cards;
}
if (!cards_layer_hidden) {
card_layer_set_index(card_layer, current_page - 1);
}
if (!pager_layer_hidden) {
pager_layer_set_values(pager_layer, current_page, num_cards + 1);
}
refresh_layer_set_updating(refresh_layer, updating);
layer_set_hidden(refresh_layer_get_layer(refresh_layer), refresh_layer_hidden);
layer_set_hidden(card_layer_get_layer(card_layer), cards_layer_hidden);
layer_set_hidden(stats_layer_get_layer(stats_layer), stats_layer_hidden);
layer_set_hidden(pager_layer_get_layer(pager_layer), pager_layer_hidden);
}
bool watchface_preferences_get_prefs(WatchfacePrefs *data_out) {
if (!data_out) {
return false;
}
const size_t buffer_size = sizeof(SerializedPrefs);
uint8_t buffer[buffer_size];
status_t status = persist_read_data(WATCHFACE_PREFS_KEY, buffer, buffer_size);
if (status == E_DOES_NOT_EXIST) {
*data_out = s_default_prefs;
return true;
}
size_t bytes_written = status;
SerializedPrefs *serialized_prefs = (SerializedPrefs *)buffer;
if ((bytes_written < buffer_size) ||
(serialized_prefs->version != SERIALIZED_PREFS_CURRENT_VERSION)) {
APP_LOG(APP_LOG_LEVEL_ERROR, "Did not completely write buffer. Missing %u bytes",
(buffer_size - bytes_written));
return false;
}
*data_out = (WatchfacePrefs) {
.background_color = {serialized_prefs->background_color},
.band_color = {serialized_prefs->band_color},
.time_text_color = {serialized_prefs->time_text_color},
static void show_charge_log()
{
if (!persist_exists(PERSIST_KEY_LOG_COUNT) || !persist_exists(PERSIST_KEY_LOG_INDEX)) {
return;
}
int log_count = persist_read_int(PERSIST_KEY_LOG_COUNT);
int log_index = persist_read_int(PERSIST_KEY_LOG_INDEX);
if (log_count == 0) {
return;
}
time_t now = time(NULL);
for (int i = 0; i < log_count; ++i) {
uint32_t key_log = PERSIST_KEY_LOG_BASE + (log_index + i) % MAX_LOG_COUNT;
ChargeLog charge_log;
persist_read_data(key_log, &charge_log, sizeof(charge_log));
static char buff[] = "999 4294967296 %100";
snprintf(buff, sizeof(buff), "%d %u %d%%", i, (unsigned)difftime(now, charge_log.time), charge_log.charge_state.charge_percent);
APP_LOG(APP_LOG_LEVEL_DEBUG, buff);
}
}
static void timers_migrate_2(void) {
if (! persist_exists(PERSIST_TIMER_START)) {
return;
}
int block_number = 0;
TimerBlockTiny* block = malloc(sizeof(TimerBlockTiny));
persist_read_data(PERSIST_TIMER_START, block, sizeof(TimerBlockTiny));
uint8_t timer_count = block->total_timers;
for (int t = 0; t < timer_count; t += 1) {
if (t > 0 && t % TIMER_BLOCK_SIZE == 0) {
block_number += 1;
if (NULL != block) {
free(block);
block = NULL;
}
block = malloc(sizeof(TimerBlockTiny));
persist_read_data(PERSIST_TIMER_START + block_number, block, sizeof(TimerBlockTiny));
}
TimerTiny* timer_tiny = &block->timers[t % TIMER_BLOCK_SIZE];
int seconds_elapsed = time(NULL) - block->save_time;
Timer* timer = malloc(sizeof(Timer));
timer->id = timer_tiny->id;
timer->current_time = timer_tiny->current_time;
timer->length = timer_tiny->length;
timer->repeat = timer_tiny->repeat;
timer->repeat_count = timer_tiny->repeat_count;
timer->status = timer_tiny->status;
timer->vibration = timer_tiny->vibration;
timer->type = timer_tiny->type;
timer->wakeup_id = timer_tiny->wakeup_id;
timer->timer = NULL;
strcpy(timer->label, timer_tiny->label);
timer_restore(timer, seconds_elapsed);
timers_add(timer);
}
if (NULL != block) {
free(block);
}
}
static void readDemoData(){
int currentDay = getCurrentDayNumber();
for(int i = 0; i < 6; i++){
persist_read_data(currentDay - (i+1), &weekData[i], sizeof(weekData[i]));
APP_LOG(APP_LOG_LEVEL_INFO, "Week data %d: seconds:%d mood:%d", currentDay - (i+1), weekData[i].sleepSeconds, weekData[i].mood);
}
}
void settings_load(void) {
if (persist_exists(STORAGE_SETTINGS)) {
int res = persist_read_data(STORAGE_SETTINGS, &_settings, sizeof(_settings));
if (res < 0) {
LOG("Settings load failed: %d", res);
}
}
}
void Weather_init() {
// if possible, load weather data from persistent storage
printf("starting weather!");
if (persist_exists(WEATHERINFO_PERSIST_KEY)) {
printf("current key exists!");
WeatherInfo w;
persist_read_data(WEATHERINFO_PERSIST_KEY, &w, sizeof(WeatherInfo));
Weather_weatherInfo = w;
#ifdef PBL_COLOR
Weather_currentWeatherIcon = gdraw_command_image_create_with_resource(w.currentIconResourceID);
#else
Weather_currentWeatherIcon = gbitmap_create_with_resource(w.currentIconResourceID);
#endif
} else {
printf("current key does not exist!");
// otherwise, use null data
Weather_currentWeatherIcon = NULL;
Weather_weatherInfo.currentTemp = INT32_MIN;
}
if (persist_exists(WEATHERFORECAST_PERSIST_KEY)) {
printf("forecast key exists!");
WeatherForecastInfo w;
persist_read_data(WEATHERFORECAST_PERSIST_KEY, &w, sizeof(WeatherForecastInfo));
Weather_weatherForecast = w;
#ifdef PBL_COLOR
Weather_forecastWeatherIcon = gdraw_command_image_create_with_resource(w.forecastIconResourceID);
#else
Weather_forecastWeatherIcon = gbitmap_create_with_resource(w.forecastIconResourceID);
#endif
} else {
printf("forecast key does not exist!");
Weather_forecastWeatherIcon = NULL;
Weather_weatherForecast.highTemp = INT32_MIN;
Weather_weatherForecast.lowTemp = INT32_MIN;
}
}
void timers_restore(void) {
if (! persist_exists(PERSIST_TIMERS_VERSION)) {
timers_migrate_1();
return;
}
if (TIMERS_VERSION_TINY == persist_read_int(PERSIST_TIMERS_VERSION)) {
timers_migrate_2();
return;
}
timers_clear();
time_t now = time(NULL);
uint16_t seconds_elapsed = 0;
TimerBlock* block = NULL;
if (persist_exists(PERSIST_TIMER_START)) {
block = malloc(sizeof(TimerBlock));
persist_read_data(PERSIST_TIMER_START, block, sizeof(TimerBlock));
uint8_t num_timers = block->total_timers;
uint8_t block_offset = 0;
seconds_elapsed = now - block->save_time;
for (uint8_t t = 0; t < num_timers; t += 1) {
if (! block) {
block = malloc(sizeof(TimerBlock));
persist_read_data(PERSIST_TIMER_START + block_offset, block, sizeof(TimerBlock));
}
Timer* timer = timer_clone(&block->timers[t % TIMER_BLOCK_SIZE]);
timers_add(timer);
timer_restore(timer, seconds_elapsed);
if (t % TIMER_BLOCK_SIZE == (TIMER_BLOCK_SIZE - 1)) {
free(block);
block = NULL;
block_offset += 1;
}
}
if (block) {
free(block);
block = NULL;
}
}
}
static void main_load_data(void) {
settings.Auto_sort=false;
settings.Show_clock=true;
settings.Hrs_day_x10=240;
settings.Last_reset=time(NULL);
stored_version = persist_read_int(STORAGE_KEY_VERSION); // defaults to 0 if key is missing
if (stored_version) {
data_loaded_from_watch = true;
if (persist_exists(STORAGE_KEY_TIMESTAMP)) data_timestamp=persist_read_int(STORAGE_KEY_TIMESTAMP);
persist_read_data(STORAGE_KEY_TIMER, &timer, sizeof(Timer));
if (persist_exists(STORAGE_KEY_SETTINGS)) {
persist_read_data(STORAGE_KEY_SETTINGS, &settings, sizeof(Settings));
}
jobs_list_load(STORAGE_KEY_FIRST_JOB, stored_version);
if (stored_version < STORAGE_KEY_VERSION) main_save_data();
}
}
Calendar read_calendar(const uint32_t key, Calendar def_value) {
if (persist_exists(key)) {
Calendar calendar;
persist_read_data(key, &calendar, sizeof(calendar));
return calendar;
} else {
return def_value;
}
}
uint32_t *sleepData(uint32_t dataCount) {
if (persist_exists(SLEEP_KEY)) {
uint32_t *buffer = malloc(dataCount * sizeof(uint32_t));
persist_read_data(SLEEP_KEY, buffer, dataCount * sizeof(uint32_t));
return buffer;
} else {
return NULL;
}
}
// 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 ");
}
static void window_down_click_handler(ClickRecognizerRef recognizer, void *context) {
if (updating) return;
uint8_t num_cards = 0;
persist_read_data(STORAGE_NUMBER_OF_CARDS, &num_cards, sizeof(num_cards));
if (num_cards > 0 && current_page < num_cards) {
current_page++;
update_visible_layers();
}
}
int get_data_keys(uint32_t *buffer) {
// Get out the values at the master key
uint32_t tmp[BUFFER_SIZE/4];
persist_read_data(MASTER_KEY, tmp, BUFFER_SIZE);
// Read the ints out 32 bits at a time
for(int i = 0; i < next_key; i++) {
buffer[i] = tmp[i] & 0x1FFFFFFF;
}
return next_key;
}
static void upgrade(void) {
Version saved_version = { 0, 0 };
persist_read_data(STORAGE_APP_VERSION, &saved_version, sizeof(saved_version));
if (saved_version.major < 3) {
for (uint32_t i = 0; i < 5; i++) {
persist_delete(i);
}
}
Version current_version = __pbl_app_info.app_version;
persist_write_data(STORAGE_APP_VERSION, ¤t_version, sizeof(current_version));
}
void load_clock() {
time_t now = time(NULL);
#ifdef PBL_SDK_2
struct tm *t = localtime(&now);
#else
struct tm *t = gmtime(&now);
#endif
tick_clock(t, true);
if(persist_exists(SW_BUTT)) {
sw_butt = persist_read_int(SW_BUTT);
persist_read_data(SW_STOP, ®, sizeof(reg));
lap.tm_hour = t->tm_hour - reg.tm_hour + 960;
lap.tm_hour += (t->tm_yday - reg.tm_yday) * 24;//days;
if(reg.tm_year != t->tm_year) {
lap.tm_hour += 365 * 24;//happy new year (close enough)
if((reg.tm_year%4 == 0) && ((reg.tm_year%100 != 0) || (reg.tm_year%400 == 0)))
lap.tm_hour += 24;//leap year day
if(t->tm_year - reg.tm_year > 1) {//greater than 1 year
reset_sw();//get a life!!
return;
}
}
lap.tm_min = t->tm_min - reg.tm_min + 60;
lap.tm_sec = t->tm_sec - reg.tm_sec + 60;
persist_read_data(SW_STORE, ®, sizeof(reg));
if((sw_butt&1)==1) {//add extra running time
reg.tm_hour += lap.tm_hour;
reg.tm_hour %= 960;//40 day timer
reg.tm_min += lap.tm_min;
reg.tm_min %= 60;
reg.tm_sec += lap.tm_sec;
reg.tm_sec %= 60;
}
persist_read_data(SW_LAP, &lap, sizeof(lap));
return;
}
reset_sw();
}
