Exemple #1
0
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);
    }
  }
}
Exemple #2
0
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);
  }
}
Exemple #3
0
/*
 * 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 pause_click_handler(ClickRecognizerRef recognizer, void *context) {
  int calib_stored = persist_exists(CALIB_PKEY) ? persist_read_int(CALIB_PKEY) : CALIB_DEFAULT;
  if (calib_stored != 0 && calibrating == 0) {
    pause++;
    pause = pause % 2;
    if (pause == 0) {
      end_time = time(NULL);
      double elapsed = difftime(end_time, start_time);
      result = (int)floor(sum_x/elapsed);
      display(text_layer_3, "Score: %d", result);
      action_bar_layer_set_icon(s_action_bar, BUTTON_ID_SELECT, s_icon_play);
      int calib_stored = persist_exists(CALIB_PKEY) ? persist_read_int(CALIB_PKEY) : CALIB_DEFAULT;
      display(text_layer_4, "Calib: %d", calib_stored);
      text_layer_set_text(text_layer_2, "");
      if (result > 2*calib_stored) {
        send(0, 1);
        text_layer_set_text(text_layer_1, "YOU'RE DRUNK");
        dialog_message_window_push();
        
      }
      else {
        send(0, 0);
        text_layer_set_text(text_layer_1, "YOU'RE FINE");
        
      }
    }
    else {
      sum_x = 0;
      text_layer_set_text(text_layer_2, "RUNNING");
      text_layer_set_text(text_layer_3, "");
      action_bar_layer_set_icon(s_action_bar, BUTTON_ID_SELECT, s_icon_pause);   
      start_time = time(NULL);
    }
  }
}
Exemple #5
0
void save_charge_log(ChargeLog* charge_log)
{
  int32_t log_count = 0;
  int32_t log_index = 0;
  
  if (persist_exists(PERSIST_KEY_LOG_COUNT)) {
    log_count = persist_read_int(PERSIST_KEY_LOG_COUNT);
  }
      
  if (persist_exists(PERSIST_KEY_LOG_INDEX)) {
    log_index = persist_read_int(PERSIST_KEY_LOG_INDEX);
  }
  
  log_count++;
  
  uint32_t key_log = PERSIST_KEY_LOG_BASE + (log_index + log_count - 1) % MAX_LOG_COUNT;
  
  if (log_count > MAX_LOG_COUNT) {
    log_count--;
    log_index++;
  }
  
  persist_write_int(PERSIST_KEY_LOG_COUNT, log_count);
  persist_write_int(PERSIST_KEY_LOG_INDEX, log_index);
  persist_write_data(key_log, charge_log, sizeof(*charge_log));
  
  if (launch_reason() != APP_LAUNCH_WAKEUP) {
    layer_mark_dirty(s_graph_layer);
  }
}
static void loadPersistentValues() {
  backgroundBlack = persist_exists(PERSIST_KEY_BACKGROUND) ? persist_read_int(PERSIST_KEY_BACKGROUND) : DEFAULT_BACKGROUND;
  showDay = persist_exists(PERSIST_KEY_SHOW_DAY) ? persist_read_int(PERSIST_KEY_SHOW_DAY) : DEFAULT_SHOWDAY;
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Loaded values from storage - background=%d, showDay=%d",
		  persist_exists(PERSIST_KEY_BACKGROUND) ? backgroundBlack : -1,
		  persist_exists(PERSIST_KEY_SHOW_DAY)? showDay : -1);
}                      
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);
}
Exemple #8
0
// 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 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_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);
	}
	
	APP_LOG(APP_LOG_LEVEL_DEBUG, "Stored config (dateorder=%d, weekday=%d, lang=%d, stripedDigits=%d)",
			USDate, showWeekday, curLang, stripedDigits);
}
Exemple #10
0
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);
}
Exemple #11
0
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);
  }
}
Exemple #12
0
void options_init() {
	if(persist_exists(OPTION_LARGE_FONT))
		large_font = persist_read_bool(OPTION_LARGE_FONT);
	if(persist_exists(OPTION_TASK_ACTIONS_POSITION))
		task_actions_position = persist_read_int(OPTION_TASK_ACTIONS_POSITION);
	LOG("lg font? %d", large_font);
	LOG("act pos? %d", task_actions_position);
}
// Load existing config from persistent storage
void load_config() {
  if (persist_exists(MESSAGE_KEY_INVERT)) {
    config_invert = persist_read_bool(MESSAGE_KEY_INVERT);
  }
  if (persist_exists(MESSAGE_KEY_DATE_FORMAT)) {
    config_date_format = persist_read_int(MESSAGE_KEY_DATE_FORMAT);
  }
}
Exemple #14
0
void read_settings_from_memory() {
    if (persist_exists(KEY_SCALE_CHOICE))
        scale = persist_read_int(KEY_SCALE_CHOICE);
    if (persist_exists(KEY_CLOCK_FORMAT))
        clock_format = persist_read_int(KEY_CLOCK_FORMAT);
    if (persist_exists(KEY_DATE_FORMAT))
        date_format = persist_read_int(KEY_DATE_FORMAT);
}
Exemple #15
0
static void load_persistent_data(){
    uint32_t data_from = persist_exists(DATE_SAVE) ? (uint32_t)persist_read_int(DATE_SAVE) : get_today();
    
    if (data_from == get_today()){
        rounds_done = persist_exists(COMPLETED_COUNT) ? persist_read_int(COMPLETED_COUNT) : 0;
        rounds_canceled = persist_exists(CANCELED_COUNT) ? persist_read_int(CANCELED_COUNT) : 0;
    }
}
Exemple #16
0
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);
  }
}
Exemple #17
0
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;
}
Exemple #18
0
void handle_init() {
  keyIndex = (persist_exists(KEY_INDEX_KEY) ? persist_read_int(KEY_INDEX_KEY) : 0);

  unsigned char offset = '0';
  unsigned char rawDST = 'N';
  unsigned char rawCount = '1';

  resource_load_byte_range(resource_get_handle(RESOURCE_ID_GMT_OFFSET), 0, &offset, 1);

  timeZoneIndex = (persist_exists(TIME_ZONE_KEY) ? persist_read_int(TIME_ZONE_KEY) : (offset - '0'));

  resource_load_byte_range(resource_get_handle(RESOURCE_ID_IS_DST), 0, &rawDST, 1);

  isDST = (persist_exists(IS_DST_KEY) ? persist_read_bool(IS_DST_KEY) : (rawDST == 'Y'));

  resource_load_byte_range(resource_get_handle(RESOURCE_ID_SECRET_COUNT), 0, &rawCount, 1);

  keyCount = rawCount - '0';
  
  window = window_create();
  window_stack_push(window, true /* Animated */);

  //Great for debugging the layout.
  //window_set_background_color(&window, GColorBlack);

  Layer* rootLayer = window_get_root_layer(window);
  GRect rootLayerRect = layer_get_bounds(rootLayer);
  barLayer = layer_create(GRect(0,70,rootLayerRect.size.w,5));
  layer_set_update_proc(barLayer, bar_layer_update);
  layer_add_child(rootLayer, barLayer);

  currentKey = text_layer_create(GRect(0,0,rootLayerRect.size.w,22));
  text_layer_set_font(currentKey, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(currentKey, GTextAlignmentCenter);
  layer_add_child(rootLayer, text_layer_get_layer(currentKey));

  currentCode = text_layer_create(GRect(0,32,rootLayerRect.size.w,36));
  text_layer_set_font(currentCode, fonts_get_system_font(FONT_KEY_BITHAM_34_MEDIUM_NUMBERS));
  text_layer_set_text_alignment(currentCode, GTextAlignmentCenter);
  layer_add_child(rootLayer, text_layer_get_layer(currentCode));

  currentTime = text_layer_create(GRect(0,rootLayerRect.size.h-(15+22),(rootLayerRect.size.w/3)*2,22));
  text_layer_set_font(currentTime, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(currentTime, GTextAlignmentLeft);
  layer_add_child(rootLayer, text_layer_get_layer(currentTime));

  currentOffset = text_layer_create(GRect((rootLayerRect.size.w/3)*2,rootLayerRect.size.h-(15+22),rootLayerRect.size.w/3,22));
  text_layer_set_font(currentOffset, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(currentOffset, GTextAlignmentRight);
  layer_add_child(rootLayer, text_layer_get_layer(currentOffset));

  // Attach our desired button functionality
  window_set_click_config_provider(window, (ClickConfigProvider) click_config_provider);

  reload();
}
static void init() {
    s_icon_plus = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_PLUS);
    s_icon_minus = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_MINUS);

    // Get the count from persistent storage for use if it exists, otherwise use the default
    s_player1_score = persist_exists(PLAYER1_SCORE_PKEY) ? persist_read_int(PLAYER1_SCORE_PKEY) : PLAYER_SCORE_DEFAULT;
    s_player2_score = persist_exists(PLAYER2_SCORE_PKEY) ? persist_read_int(PLAYER2_SCORE_PKEY) : PLAYER_SCORE_DEFAULT;

    s_main_window = window_create();
    window_set_window_handlers(s_main_window, (WindowHandlers) {
        .load = main_window_load,
         .unload = main_window_unload,
    });
static uint16_t get_events_count_callback(struct MenuLayer *menu_layer, uint16_t section_index, void *callback_context) {
    int i = 0;
    int past_events = 0;
    time_t now = time(0);
    while (persist_exists(i*PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE)) {
        if (persist_exists(i*PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE)) {
            int end_date = persist_read_int(i * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE);
            if (end_date < now)
                past_events++;
        }
        i++;
    }
    return i - past_events;
}
static int get_event_no_from_row_index(int index) {
    int i = 0;
    int past_events = 0;
    time_t now = time(0);
    while ((i - past_events) <= index && persist_exists(i*PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_TITLE)) {
        if (persist_exists(i*PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE)) {
            int end_date = persist_read_int(i * PERSIST_EVENT_FIELDCOUNT + PERSIST_EVENT_END_DATE);
            if (end_date < now)
                past_events++;
        }
        i++;
    }
    return i - 1;
}
Exemple #22
0
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);
  }
}
Exemple #23
0
static void init(void) {
  //(void)ctx;
	
  app_message_register_inbox_received(in_received_handler);
  app_message_register_inbox_dropped(in_dropped_handler);
  app_message_open(64, 0);

  if(persist_exists(KEY_24H)) SHOW_24H = persist_read_bool(KEY_24H);
  if(persist_exists(KEY_DATE)) SHOW_TEXT_DATE = persist_read_bool(KEY_DATE);
  if(persist_exists(KEY_VIBE)) BT_VIBE = persist_read_bool(KEY_VIBE);
  if(persist_exists(KEY_INVERT)) INVERT = persist_read_bool(KEY_INVERT);
	
  if(INVERT) {
	  BACKGROUND_COLOR = GColorWhite;
	  FOREGROUND_COLOR = GColorBlack;
  }
  else {
	  BACKGROUND_COLOR = GColorBlack;
	  FOREGROUND_COLOR = GColorWhite;		 		 
  }
	
  window = window_create();
  window_set_background_color(window, BACKGROUND_COLOR);
  window_stack_push(window, true);

 
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);
	
  // Init the layer for the minute display
  minute_display_layer = layer_create(bounds);
  layer_set_update_proc(minute_display_layer, minute_display_layer_update_callback);
  layer_add_child(window_layer, minute_display_layer);

  // Init the layer for the hour display
  hour_display_layer = layer_create(bounds);
  layer_set_update_proc(hour_display_layer, hour_display_layer_update_callback);
  layer_add_child(window_layer, hour_display_layer);

  // Init the layer for the battery display
  battery_display_layer = layer_create(bounds);
  layer_set_update_proc(battery_display_layer, battery_display_layer_update_callback);
  layer_add_child(window_layer, battery_display_layer);
  
  setup_time_date_layers();
	
  tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
  bluetooth_connection_service_subscribe(handle_bluetooth_event); 
}
static void init_sliding_row(SlidingTextData *data, SlidingRow *row, GRect pos, GFont font,
        int delay) {
  row->label = text_layer_create(pos);

  text_layer_set_background_color(row->label, GColorClear);

  if (persist_exists(KEY_TEXT_COLOR)) {
    int color = persist_read_int(KEY_TEXT_COLOR);
    GColor text_color = GColorFromHEX(color);
    text_layer_set_text_color(row->label, text_color);
  } else {
    text_layer_set_text_color(row->label, GColorWhite);
  }
  
  if (font) {
    text_layer_set_font(row->label, font);
    row->unchanged_font = true;
  } else {
    row->unchanged_font = false;
  }

  row->state = IN_FRAME;
  row->next_string = NULL;

  row->left_pos = -pos.size.w;
  row->right_pos = pos.size.w;
  row->still_pos = pos.origin.x;

  row->movement_delay = delay;
  row->delay_count = 0;

  data->last_hour = -1;
  data->last_minute = -1;
}
static void window_load(Window *window)
{
    // Check for saved settings
    mInvertColors = persist_exists(KEY_INVERT) ? persist_read_bool(KEY_INVERT) : false;
    mBackColor = (mInvertColors) ? GColorWhite : GColorBlack;
    mForeColor = (mInvertColors) ? GColorBlack : GColorWhite;

    mStarSpeed = STAR_SPEED_SLOW;//persist_exists(KEY_STAR_SPEED) ? persist_read_int(KEY_STAR_SPEED) : STAR_SPEED_FAST;
    mFramerate = FRAMERATE_SMOOTH;//persist_exists(KEY_FRAMERATE) ? persist_read_int(KEY_FRAMERATE) : FRAMERATE_POWER;

	window_set_background_color(window, mBackColor);
	canvas = layer_create(GRect(0, 0, SCREEN_WIDTH , SCREEN_HEIGHT));
	layer_set_update_proc(canvas, (LayerUpdateProc) render);
	layer_add_child(window_get_root_layer(window), canvas);
    
    mFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_TETRIS_24));
	
	// Set initial time so display isn't blank
    mTimeText = NULL;
	struct tm *t;
	time_t temp;
	temp = time(NULL);
	t = localtime(&temp);
	set_time_display(t);

	start();
}
static void endtrial_callback() {
  pause++;
  vibes_short_pulse();
  end_time = time(NULL);
  double elapsed = difftime(end_time, start_time);
  result = (int)floor(sum_x/elapsed);
  
  display(text_layer_3, "Final: %d", result);
  
  action_bar_layer_set_icon(s_action_bar, BUTTON_ID_SELECT, s_icon_play);
  int calib_stored = persist_exists(CALIB_PKEY) ? persist_read_int(CALIB_PKEY) : CALIB_DEFAULT;

  if (result > 2*calib_stored) {
    send(0,1);
    text_layer_set_text(text_layer_1, "YOU'RE DRUNK");
    text_layer_set_text(text_layer_4, "");
    dialog_message_window_push();
  }
  else {
    send(0,0);
    text_layer_set_text(text_layer_1, "YOU'RE FINE");
    text_layer_set_text(text_layer_2, "");
    text_layer_set_text(text_layer_4, "");
  }

}
Exemple #27
0
static void init(void) {
	if(!persist_exists(CONFIG_WORK)){
		persist_write_int(CONFIG_WORK,25);
		persist_write_int(CONFIG_REST,5);
	}
	show_mainwindow();
}
Exemple #28
0
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);
}
Exemple #29
0
/**
 * 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;
}
Exemple #30
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;
}