Exemple #1
0
void workout_delete_by_slot(uint16_t slot_number) {
    SaveState state = slots_load_state();

    uint32_t data_position;
    switch (slot_number) {
        case 1:
            data_position = DATA_WORKOUT_SAVE_1;
            state.save1_in_use = false;
            break;
        case 2:
            data_position = DATA_WORKOUT_SAVE_2;
            state.save2_in_use = false;
            break;
        case 3:
            data_position = DATA_WORKOUT_SAVE_3;
            state.save3_in_use = false;
            break;
        default:
            return;
    }

    persist_delete(data_position);

    for (int i = 0; i < M__COUNT; i++) {
        persist_delete(data_position + 1 + i);
    }

    slots_save_state(state);
}
Exemple #2
0
/**
 * Function that saves the presets into persistent storage.
 */
void presets_save(void){
	int block = 0;
	uint8_t num_presets = presets_get_count();
	if (num_presets == 0){
		while (persist_exists(STORAGE_PRESET_START + block)){
			persist_delete(STORAGE_PRESET_START + block);
			block++;
		}
		return;
	}
	for (int i = 0; i < num_presets; i+= PRESET_BLOCK_SIZE){
		PresetBlock *presetBlock = malloc(sizeof(PresetBlock));
		presetBlock->count = num_presets;
		presetBlock->time = time(NULL);
		for (int j = 0; j < PRESET_BLOCK_SIZE; j++){
			if (i+j >= num_presets)
				break;
			presetBlock->presets[j] = *presets_get(i+j);
		}
		persist_write_data(STORAGE_PRESET_START+block, presetBlock, sizeof(PresetBlock));
		free(presetBlock);
		block++;
	}
	return;
}
Exemple #3
0
void timers_save(void) {
  if (timers_count() == 0) {
    persist_delete(PERSIST_TIMER_START);
    return;
  }
  TimerBlock* block = NULL;
  uint8_t block_count = 0;
  for (uint8_t b = 0; b < timers_count(); b += 1) {
    if (NULL == block) {
      block = malloc(sizeof(TimerBlock));
      block->total_timers = timers_count();
      block->save_time = time(NULL);
    }

    uint8_t timer_block_pos = b % TIMER_BLOCK_SIZE;
    block->timers[timer_block_pos] = *timers_get(b);

    bool is_last_timer_in_block = timer_block_pos == (TIMER_BLOCK_SIZE - 1);
    if (is_last_timer_in_block) {
      persist_write_data(PERSIST_TIMER_START + block_count, block, sizeof(TimerBlock));
      block_count += 1;
      free(block);
      block = NULL;
    }
  }
  if (block) {
    persist_write_data(PERSIST_TIMER_START + block_count, block, sizeof(TimerBlock));
  }
  persist_write_int(PERSIST_TIMERS_VERSION, TIMERS_VERSION_CURRENT);
}
void strap_deinit() {
    if (!persist_read_bool(STRAP_OPT_OUT)) {
        persist_delete(STRAP_CRASH_WATCHER);
        strap_log_action("STRAP_FINISH");
        accl_deinit();
    }

}
Exemple #5
0
void jobs_list_save(uint8_t first_key) {
  Job_ptr* job_ptr = first_job_ptr;
  while (job_ptr) {
    persist_write_data(first_key++, job_ptr->Job, sizeof(Job));
    job_ptr=job_ptr->Next_ptr;
  }
  // if we've delete a job then need to delete the saved version or it will come back!
  persist_delete(first_key);
}
Exemple #6
0
status_t persist_write_int(const uint32_t key, const int32_t value) {
  persist_delete(key);
  Persist* persist = malloc(sizeof(Persist));
  persist->key = key;
  persist->type = NUMBER;
  persist->number = value;
  linked_list_append(persistence, persist);
  return 0;
}
Exemple #7
0
int persist_write_data(const uint32_t key, const void *data, const size_t size) {
  persist_delete(key);
  Persist* persist = malloc(sizeof(Persist));
  persist->key = key;
  persist->type = DATA;
  persist->data = malloc(size);
  memcpy(persist->data, data, size);
  linked_list_append(persistence, persist);
  return size;
}
Exemple #8
0
int persist_write_string(const uint32_t key, const char *cstring) {
  persist_delete(key);
  Persist* persist = malloc(sizeof(Persist));
  persist->key = key;
  persist->type = STRING;
  persist->str = malloc(strlen(cstring) + 1);
  strcpy(persist->str, cstring);
  linked_list_append(persistence, persist);
  return strlen(cstring);
}
Exemple #9
0
void ClearPersistedData(void)
{
	if(persist_exists(PERSISTED_IS_DATA_SAVED))
	{
		int maxKey = persist_read_int(PERSISTED_MAX_KEY_USED);
		int i;
		for(i = 0; i <= maxKey; ++i)
		{
			persist_delete(i);
		}
	}
}
Exemple #10
0
void sustenance_storage_update_sustenance(int id, struct Sustenance *sustenance) {
	int next_id = sustenance_first_pkey + id;
	if (persist_exists(next_id)) {
		bool existed = persist_delete(next_id);
		APP_LOG(APP_LOG_LEVEL_DEBUG, "STORAGE. UPDATE SUSTENANCE. DELETED EXISTING KEY. EXISTED: %d", existed);
	}

	int bytesWritten = persist_write_data(next_id, sustenance, sizeof(struct Sustenance));
	int expectedBytesWritten = sizeof(struct Sustenance);
	APP_LOG(APP_LOG_LEVEL_DEBUG, "STORAGE. UPDATE SUSTENANCE. PKEY: %d. Expected bytes written: %d. Bytes written: %d", next_id, expectedBytesWritten, bytesWritten);
	APP_LOG(APP_LOG_LEVEL_DEBUG, "STORAGE. UPDATE SUSTENANCE. Type: %d. Substance: %d. Amount: %d", sustenance->type, sustenance->substance, sustenance->amount);
}
Exemple #11
0
void data_init() {
  // Nuke previus version settings
  if(!persist_exists(V_3_1)) {
    persist_write_bool(V_3_1, true);

    for(int i = 0; i < DataNumBoolKeys; i++) {
      persist_delete(i);
    }
    persist_delete(DataKeyForegroundColor);
    persist_delete(DataKeyBackgroundColor);

    write_defaults();
  } else {
    // Read settings
    for(int i = 0; i < DataNumBoolKeys; i++) {
      s_bool_settings[i] = persist_read_bool(i);
    }
    s_foreground = (GColor){ .argb = persist_read_int(DataKeyForegroundColor) };
    s_background = (GColor){ .argb = persist_read_int(DataKeyBackgroundColor) };
  }
}
Exemple #12
0
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, &current_version, sizeof(current_version));
}
Exemple #13
0
void ClearPersistedData(void)
{
	ProfileLogStart("ClearPersistedData");
	if(persist_exists(PERSISTED_IS_DATA_SAVED))
	{
		DEBUG_LOG("Clearing persisted data.");
		int maxKey = persist_read_int(PERSISTED_MAX_KEY_USED);
		int i;
		for(i = 0; i <= maxKey; ++i)
		{
			persist_delete(i);
		}
	}
	ProfileLogStop("ClearPersistedData");
}
Exemple #14
0
void main_save_data() {
  data_loaded_from_watch = true;
  persist_write_int(STORAGE_KEY_VERSION, CURRENT_STORAGE_VERSION);
  data_timestamp=time(NULL);
  persist_write_int(STORAGE_KEY_TIMESTAMP, data_timestamp);
  if (timer.Active) {
    persist_write_data(STORAGE_KEY_TIMER, &timer, sizeof(Timer));
  } else {
    persist_delete(STORAGE_KEY_TIMER);
  }
  persist_write_data(STORAGE_KEY_SETTINGS, &settings, sizeof(Settings));
  jobs_list_save(STORAGE_KEY_FIRST_JOB); 
  send_settings_to_phone();
  settings_menu_hide();
}
Exemple #15
0
void log_deinit() {
    if (eventLogSize > 0) {
        LOG(APP_LOG_LEVEL_DEBUG, "log not clean on exit, persisting remaining events");

        uint8_t bufferSize = log_calculate_serialized_size();
        uint8_t buffer[bufferSize];

        log_serialize(buffer);

        if (persist_write_data(PERSIST_LOG, buffer, bufferSize) != bufferSize) {
            LOG(APP_LOG_LEVEL_ERROR, "persist failed");
        } else {
            LOG(APP_LOG_LEVEL_DEBUG, "persisted %i events", (int)eventLogSize);
        }
    } else {
        persist_delete(PERSIST_LOG);
    }
}
void migrate_legacy_data() {
  // load legacy checklist information from storage
  s_checklist_length = persist_read_int(PERSIST_KEY_CHECKLIST_LENGTH);
  s_checklist_num_checked = 0;

  // load the legacy checklist data from storage
  for(int i = 0; i < MAX_CHECKLIST_ITEMS; i++) {
    persist_read_data(PERSIST_KEY_CHECKLIST_ITEM_FIRST + i, &s_checklist_items[i], sizeof(ChecklistItem));

    if(s_checklist_items[i].is_checked) {
      s_checklist_num_checked++;
    }
  }

  // now write the data in the new format
  save_data_to_storage();

  // delete the old data
  for(int i = 0; i < MAX_CHECKLIST_ITEMS; i++) {
    persist_delete(PERSIST_KEY_CHECKLIST_ITEM_FIRST + i);
  }
}
Exemple #17
0
status_t timers_save(void) {
  int block = 0;
  uint8_t num_timers = timers_get_count();
  if (num_timers == 0) {
    persist_delete(STORAGE_TIMER_START);
    return 0;
  }
  for (int t = 0; t < num_timers; t += TIMER_BLOCK_SIZE) {
    TimerBlock* timerBlock = malloc(sizeof(TimerBlock));
    timerBlock->count = num_timers;
    timerBlock->time = time(NULL);
    for (int u = 0; u < TIMER_BLOCK_SIZE; u += 1) {
      if (t + u >= num_timers) {
        break;
      }
      timerBlock->timers[u] = *timers_get(t + u);
    }
    persist_write_data(STORAGE_TIMER_START + block, timerBlock, sizeof(TimerBlock));
    free(timerBlock);
    block += 1;
  }
  return 0;
}
Exemple #18
0
void SetThreadSubreddit(struct ThreadData* thread, int index, char* str)
{
#ifdef USE_PERSIST_STRINGS
    if(str != NULL)
    {
        persist_write_string(PERSIST_OFFSET_THREAD_SUBREDDIT + index, str);
    }
    else
    {
        persist_delete(PERSIST_OFFSET_THREAD_SUBREDDIT + index);
    }
#else
    if(thread->subreddit != NULL)
    {
        nt_Free(thread->subreddit);
    }
    if(str != NULL)
    {
        thread->subreddit = (char*)nt_Malloc(sizeof(char) * (strlen(str) + 1));
        strcpy(thread->subreddit, str);
    }
#endif
}
void process_eventsmenu_message(DictionaryIterator *received) {
    Tuple *tuple;

    tuple = dict_find(received, KEY_INIT);
    if (tuple) {
        if (tuple->value->int8 == 0) {
            eventsmenu_firstload();
        } else {
        
            if (!persist_exists(PERSIST_KEY_VERSION)) {
    
                if(persist_exists(PERSIST_EVENT_TITLE))  
                    persist_write_int(PERSIST_KEY_VERSION, 21);
                else
                    persist_write_int(PERSIST_KEY_VERSION, APP_VERSION);
                      
            }
            
            if (persist_read_int(PERSIST_KEY_VERSION) < 22) {
                ui_messagebox_show("What's new", "Version 2.2: Added event reminders. To enable, visit app settings on phone.");
            }
            if (persist_read_int(PERSIST_KEY_VERSION) < 25) {
                ui_messagebox_show("What's new", "Version 2.5: Added auto refresh. To enable, visit app settings on phone.");
            }
            if (persist_read_int(PERSIST_KEY_VERSION) < APP_VERSION) {
                persist_write_int(PERSIST_KEY_VERSION, APP_VERSION);
            }
        }
        send_client_secret();
        wakeup_schedule_sync();
    }
    
    tuple = dict_find(received, KEY_SHOW_LOADING);
    if(tuple) {
        eventsmenu_loading();
    }
    
    tuple = dict_find(received, KEY_EVENT_ID);
    if(tuple) {
        current_event_id = tuple->value->uint8;
        if (persist_exists((current_event_id + 1) * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE))
            persist_delete((current_event_id + 1) * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE);
    }
    tuple = dict_find(received, KEY_EVENT_TITLE);
    if(tuple) {
        persist_write_string(PERSIST_EVENT_TITLE + current_event_id*PERSIST_EVENT_FIELDCOUNT, (char *)tuple->value->data);
    }
    tuple = dict_find(received, KEY_EVENT_START_DATE);
    if(tuple) {
        persist_write_int(PERSIST_EVENT_START_DATE + current_event_id*PERSIST_EVENT_FIELDCOUNT, tuple->value->uint32);
    }
    tuple = dict_find(received, KEY_EVENT_END_DATE);
    if(tuple) {
        persist_write_int(PERSIST_EVENT_END_DATE + current_event_id*PERSIST_EVENT_FIELDCOUNT, tuple->value->uint32);
    }
    tuple = dict_find(received, KEY_EVENT_LOCATION);
    if(tuple) {
        persist_write_string(PERSIST_EVENT_LOCATION + current_event_id*PERSIST_EVENT_FIELDCOUNT, (char *)tuple->value->data);
    }
    tuple = dict_find(received, KEY_EVENT_ATTENDEES);
    if(tuple) {
        persist_write_string(PERSIST_EVENT_ATTENDEES + current_event_id*PERSIST_EVENT_FIELDCOUNT, (char *)tuple->value->data);
    }
    tuple = dict_find(received, KEY_EVENT_BODY);
    if(tuple) {
        persist_write_string(PERSIST_EVENT_BODY + current_event_id*PERSIST_EVENT_FIELDCOUNT, (char *)tuple->value->data);
    }
    tuple = dict_find(received, KEY_REFRESH_UI);
    if(tuple) {
        APP_LOG(APP_LOG_LEVEL_DEBUG, "Refreshing events menu");
        menu_layer_reload_data(s_menu_layer);
        text_layer_set_text(s_title_layer, "Events (online)");
        wakeup_schedule_event_reminder();
        
        if (layer_get_hidden(menu_layer_get_layer(s_menu_layer))) {
            layer_set_hidden(text_layer_get_layer(s_message_layer), true);
            layer_set_hidden(menu_layer_get_layer(s_menu_layer), false);
        }
    } 
}
Exemple #20
0
void log_reset() {
    eventLogSize = firstEventIdx = 0;
    persist_delete(PERSIST_LOG);
}
Exemple #21
0
void in_received_handler(DictionaryIterator *received, void *context)
{
  APP_LOG(APP_LOG_LEVEL_DEBUG, "in_received_handler");
  
  Tuple *hh_in_bold_tuple = dict_find(received, MESSAGE_KEY_HH_IN_BOLD);
  if (hh_in_bold_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "hh_in_bold=%s",
            hh_in_bold_tuple->value->cstring);

    if (strcmp(hh_in_bold_tuple->value->cstring, "0") == 0)
    {
      persist_write_bool(MESSAGE_KEY_HH_IN_BOLD, false);
    }
    else
    {
      persist_write_bool(MESSAGE_KEY_HH_IN_BOLD, true);
    }
  }

  Tuple *mm_in_bold_tuple = dict_find(received, MESSAGE_KEY_MM_IN_BOLD);
  if (mm_in_bold_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "mm_in_bold=%s",
            mm_in_bold_tuple->value->cstring);

    if (strcmp(mm_in_bold_tuple->value->cstring, "1") == 0)
    {
      persist_write_bool(MESSAGE_KEY_MM_IN_BOLD, true);
    }
    else
    {
      persist_write_bool(MESSAGE_KEY_MM_IN_BOLD, false);
    }
  }
  
  Tuple *locale_tuple = dict_find(received, MESSAGE_KEY_LOCALE);
  if (locale_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "locale=%s",
            locale_tuple->value->cstring);

    if (strcmp(locale_tuple->value->cstring, "default") == 0)
    {
      if (persist_exists(MESSAGE_KEY_LOCALE)) 
      {
        persist_delete(MESSAGE_KEY_LOCALE);
      }
    }
    else if (strcmp(locale_tuple->value->cstring, "fr") == 0)
    {
      persist_write_int(MESSAGE_KEY_LOCALE, locale_fr);
    }
    else if (strcmp(locale_tuple->value->cstring, "de") == 0)
    {
      persist_write_int(MESSAGE_KEY_LOCALE, locale_de);
    }
    else if (strcmp(locale_tuple->value->cstring, "es") == 0)
    {
      persist_write_int(MESSAGE_KEY_LOCALE, locale_es);
    }
    else if (strcmp(locale_tuple->value->cstring, "it") == 0)
    {
      persist_write_int(MESSAGE_KEY_LOCALE, locale_it);
    }
    else
    {
      persist_write_int(MESSAGE_KEY_LOCALE, locale_en);
    }
  }
  
  Tuple *hh_strip_zero_tuple = dict_find(received, MESSAGE_KEY_HH_STRIP_ZERO);
  if (hh_strip_zero_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "hh_strip_zero=%s",
            hh_strip_zero_tuple->value->cstring);

    if (strcmp(hh_strip_zero_tuple->value->cstring, "0") == 0)
    {
      persist_write_bool(MESSAGE_KEY_HH_STRIP_ZERO, false);
    }
    else
    {
      persist_write_bool(MESSAGE_KEY_HH_STRIP_ZERO, true);
    }
  }
  
  Tuple *time_sep_tuple = dict_find(received, MESSAGE_KEY_TIME_SEP);
  if (time_sep_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "time_sep=%s",
            time_sep_tuple->value->cstring);

    if (strcmp(time_sep_tuple->value->cstring, "square") == 0)
    {
      persist_write_int(MESSAGE_KEY_TIME_SEP, time_sep_square);
    }
    else if (strcmp(time_sep_tuple->value->cstring, "round") == 0)
    {
      persist_write_int(MESSAGE_KEY_TIME_SEP, time_sep_round);
    }
    else if (strcmp(time_sep_tuple->value->cstring, "squareb") == 0)
    {
      persist_write_int(MESSAGE_KEY_TIME_SEP, time_sep_square_bold);
    }
    else if (strcmp(time_sep_tuple->value->cstring, "roundb") == 0)
    {
      persist_write_int(MESSAGE_KEY_TIME_SEP, time_sep_round_bold);
    }
    else
    {
      persist_write_int(MESSAGE_KEY_TIME_SEP, time_sep_none);
    }
  }
  
  Tuple *repeat_vib_tuple = dict_find(received, MESSAGE_KEY_REPEAT_VIB);
  if (repeat_vib_tuple)
  {
    app_log(APP_LOG_LEVEL_DEBUG,
            __FILE__,
            __LINE__,
            "repeat_vib=%s",
            repeat_vib_tuple->value->cstring);

    if (strcmp(repeat_vib_tuple->value->cstring, "1") == 0)
    {
      persist_write_bool(MESSAGE_KEY_REPEAT_VIB, true);
    }
    else
    {
      persist_write_bool(MESSAGE_KEY_REPEAT_VIB, false);
    }
  }  

  read_configuration();
  update_display();
}
Exemple #22
0
void pomClearTimer() {
    persist_delete(TIMER_STRUCT_KEY);
}
Exemple #23
0
static void reset_wakeup() {
  wakeup_cancel(s_wakeup_id);
  s_wakeup_id = -1;
  s_wakeup_timestamp = 0;
  persist_delete(PERSIST_WAKEUP);
}
Exemple #24
0
void persist_safe_delete(const uint32_t key) {
  if (persist_exists(key)) {
    persist_delete(key);
  }
}
Exemple #25
0
static void clearData() {
  persist_delete(STORAGE_WATERCNT_ML);
  persist_delete(STORAGE_DAY);
  persist_delete(STORAGE_GOAL_ML);
  persist_delete(STORAGE_DRINKS);
}
void __delete(int key) { 
    persist_delete(key);
}