Ejemplo n.º 1
0
void handle_init(AppContextRef ctx) {

  window_init(&window, "Simplicity");
  window_stack_push(&window, true /* Animated */);
  window_set_background_color(&window, GColorBlack);

  resource_init_current_app(&APP_RESOURCES);

  layer_init(&time_layer, GRect(0, 12, 144, 168-68));
  layer_add_child(&window.layer, &time_layer);

  text_layer_init(&text_date_layer, window.layer.frame);
  text_layer_set_text_color(&text_date_layer, GColorWhite);
  text_layer_set_background_color(&text_date_layer, GColorClear);
  layer_set_frame(&text_date_layer.layer, GRect(8, 0, 144-8, 168-68));
  text_layer_set_font(&text_date_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_21)));
  layer_add_child(&time_layer, &text_date_layer.layer);


  text_layer_init(&text_time_layer, window.layer.frame);
  text_layer_set_text_color(&text_time_layer, GColorWhite);
  text_layer_set_background_color(&text_time_layer, GColorClear);
  layer_set_frame(&text_time_layer.layer, GRect(7, 24, 144-7, 168-92));
  text_layer_set_font(&text_time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_BOLD_SUBSET_49)));
  layer_add_child(&time_layer, &text_time_layer.layer);


  layer_init(&line_layer, window.layer.frame);
  line_layer.update_proc = &line_layer_update_callback;
  layer_add_child(&time_layer, &line_layer);

  layer_init(&car_layer, GRect(0, 90, 144, 168-90));
  layer_add_child(&window.layer, &car_layer);

  text_layer_init(&text_rated_layer, window.layer.frame);
  text_layer_set_text_color(&text_rated_layer, GColorWhite);
  text_layer_set_background_color(&text_rated_layer, GColorClear);
  layer_set_frame(&text_rated_layer.layer, GRect(8, 0, 144-8, 168-68));
  text_layer_set_font(&text_rated_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_21)));
  layer_add_child(&car_layer, &text_rated_layer.layer);
	
  text_layer_init(&text_state_layer, window.layer.frame);
  text_layer_set_text_color(&text_state_layer, GColorWhite);
  text_layer_set_background_color(&text_state_layer, GColorClear);
  layer_set_frame(&text_state_layer.layer, GRect(8, 20, 144-8, 168-68));
  text_layer_set_font(&text_state_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_21)));
  layer_add_child(&car_layer, &text_state_layer.layer);
	
  layer_init(&battery_layer, GRect(72, 10, 144-70, 10));
  battery_layer.update_proc = &battery_layer_update_callback;
  layer_add_child(&car_layer, &battery_layer);

  Tuplet initial_values[] = {
    TupletInteger(TESLA_RATED_REMAIN_KEY, (uint16_t) 148),
    TupletCString(TESLA_STATE_STRING_KEY, "Charging"),
	TupletInteger(TESLA_BATTERY_PERCENT_KEY, (uint8_t) 72),
  };
  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
                sync_tuple_changed_callback, sync_error_callback, NULL);
}
Ejemplo n.º 2
0
static void fetch_data(void) {

  Tuplet style_tuple = TupletInteger(STYLE_KEY, 0);
  Tuplet bluetoothvibe_tuple = TupletInteger(BLUETOOTHVIBE_KEY, 0);
  Tuplet hourlyvibe_tuple = TupletInteger(HOURLYVIBE_KEY, 0);
  Tuplet blink_tuple = TupletInteger(BLINK_KEY, 0);
  Tuplet dateformat_tuple = TupletInteger(DATEFORMAT_KEY, 0);
  Tuplet units_tuple = TupletInteger(WEATHER_UNITS, 0);
  Tuplet weather_temperature_tuple = TupletInteger(WEATHER_TEMPERATURE_KEY, 0);
  Tuplet weather_icon_tuple = TupletInteger(WEATHER_ICON_KEY, 0);
  Tuplet weather_high_tuple = TupletInteger(WEATHER_TEMPERATUREHIGH_KEY, 0);
  Tuplet weather_low_tuple = TupletInteger(WEATHER_TEMPERATURELOW_KEY, 0);

  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);

  if (iter == NULL) {
    return;
  }

  dict_write_tuplet(iter, &style_tuple);
  dict_write_tuplet(iter, &bluetoothvibe_tuple);
  dict_write_tuplet(iter, &hourlyvibe_tuple);
  dict_write_tuplet(iter, &units_tuple);
  dict_write_tuplet(iter, &weather_temperature_tuple);
  dict_write_tuplet(iter, &weather_icon_tuple);
  dict_write_tuplet(iter, &weather_high_tuple);
  dict_write_tuplet(iter, &weather_low_tuple);
  dict_write_tuplet(iter, &blink_tuple);
  dict_write_tuplet(iter, &dateformat_tuple);
  dict_write_end(iter);

  app_message_outbox_send();
}
Ejemplo n.º 3
0
// Next or previous
void go_next_or_prev(uint8_t key, uint8_t cmd){
  if (current == -1 || max == -1){
    //Not all data has been received, unable to determine if you can go next/prev
    return;
  }
  if (current == 1 && cmd == BUTTON_PREVIOUS){
    //First already, cannot prev, exit
    return;
  }
  if (current == max && cmd == BUTTON_NEXT){
    //Last in list, exit
    return;
  }
  resetData();
  if (debugMode)
    APP_LOG(APP_LOG_LEVEL_INFO, "Sending data to phone");
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
      
  Tuplet value = TupletInteger(key, cmd);
  dict_write_tuplet(iter, &value);
  
  if (current != -1){
    Tuplet page = TupletInteger(MESSAGE_CURRENT_FAV, current);
    dict_write_tuplet(iter, &page);
  }
  
  app_message_outbox_send();
}
Ejemplo n.º 4
0
/*----------------------------------------------------------------------------*/
void accel_data_callback(void * data, uint32_t num_samples)
{
  AppMessageResult result;
  AccelData * vector = (AccelData*) data;

  if (vector->did_vibrate) {
    syncStats.sync_vib++;
    return;
  }

  if (syncChangeCount > 0) {
    syncStats.sync_missed++;
    return;
  }

  /* Build the dictionary to hold this vector */
  Tuplet vector_dict[] = {
    TupletInteger(PP_KEY_CMD, PP_CMD_VECTOR),
    TupletInteger(PP_KEY_X, (int) vector->x),
    TupletInteger(PP_KEY_Y, (int) vector->y),
    TupletInteger(PP_KEY_Z, (int) vector->z),
  };

  /* Send the newly built dictionary to the remote side. */
  result = app_sync_set( &sync, vector_dict, ARRAY_LENGTH(vector_dict) );

  if (result != APP_MSG_OK) {
      APP_LOG(APP_LOG_LEVEL_DEBUG, "app_sync_set: APP_MSG_%s",
             AppMessageResult_to_String(result));
  }
  else {
    syncChangeCount = ARRAY_LENGTH(vector_dict);
    syncStats.sync_set++;
  }
}
Ejemplo n.º 5
0
void submit_time_to_task(ClickRecognizerRef recognizer, Window *window) {
	app_message_outbox_begin(&iter);
	Tuplet value = TupletCString(0, "postTask");
	dict_write_tuplet(iter, &value);
	Tuplet start = TupletInteger(1, start_time);
	dict_write_tuplet(iter, &start);
	Tuplet duration = TupletInteger(1, elapsed_time);
	dict_write_tuplet(iter, &duration);
	app_message_outbox_send();
}
Ejemplo n.º 6
0
static void config_init(void) {
    // no need for large inbox/outbox, just handling configuration messages
    app_message_open(100, 100);

    Tuplet initial_values[] = {
        TupletInteger(BACKGROUND_COLOR_KEY, pcb_background.argb),
        TupletInteger(SILKSCREEN_COLOR_KEY, pcb_silkscreen.argb)
    };
    app_sync_init(
        &s_sync, s_sync_buffer, sizeof(s_sync_buffer), 
        initial_values, ARRAY_LENGTH(initial_values), 
        sync_changed_handler, sync_error_handler, NULL);
}
Ejemplo n.º 7
0
void request_send_acc(void) {
	
	uint16_t ms;
	time_t now;
	time_ms(&now, &ms);
	char buffer[15];
	snprintf(buffer, sizeof(buffer) - 1, "%lu%03d", now, ms);
	
	// snprintf(xyz_str,22 ,"X,Y,Z: %d,%d,%d",acc_data[0],acc_data[1],acc_data[2] );
	//APP_LOG(APP_LOG_LEVEL_DEBUG, "%s",xyz_str);
	app_message_outbox_begin(&iter);

    long long nowz = now;
    nowz = nowz * 1000 + ms;

    

	Tuplet t = TupletStaticCString(KEY_OFFSET + T_TIME_BASE, buffer, strlen(buffer));
	dict_write_tuplet(iter, &t);
	Tuplet act = TupletStaticCString(KEY_OFFSET + T_ACTIVITY, cur_activity, strlen(cur_activity));
	dict_write_tuplet(iter, &act);
    
    for(int i = 0; i < NUM_SAMPLES; i++) {
    
        int point = KEY_OFFSET + (10 * i);
        
        Tuplet ts = TupletInteger(point + T_TS, (int)(nowz - accl_data[i].timestamp));
        dict_write_tuplet(iter, &ts);
        
        Tuplet x = TupletInteger(point + T_X, accl_data[i].x);
        dict_write_tuplet(iter, &x);

        Tuplet y = TupletInteger(point + T_Y, accl_data[i].y);
        dict_write_tuplet(iter, &y);

        Tuplet z = TupletInteger(point + T_Z, accl_data[i].z);
        dict_write_tuplet(iter, &z);

        Tuplet dv = TupletStaticCString(point + T_DID_VIBRATE, accl_data[i].did_vibrate?"1":"0", 1);
        dict_write_tuplet(iter, &dv);

	}
	
	app_message_outbox_send();
	waiting_data = false;
	msg_run = true;
	acc_count++;
}
Ejemplo n.º 8
0
static void http_capture_send_buffer() {
	int len = 64;
	if (http_capture_sentLen+len > 18*168)
		len = 18*168 - http_capture_sentLen;
	if (len <= 0)
		return;
		
	Tuplet start = TupletInteger(0xFFF9, http_capture_sentLen);
	Tuplet buf = TupletBytes(1000, &http_capture_frameBuffer[http_capture_sentLen], len);

	DictionaryIterator *iter;
	app_message_out_get(&iter);

	if (iter == NULL)
		return;

	dict_write_tuplet(iter, &start);
	dict_write_tuplet(iter, &buf);
	dict_write_end(iter);

	http_capture_sentLen += len;

	app_message_out_send();
	app_message_out_release();	
}
Ejemplo n.º 9
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  
  temperature_layer = text_layer_create(GRect(0, 140, 155, 40));
  text_layer_set_text_color(temperature_layer, GColorWhite);
  text_layer_set_background_color(temperature_layer, GColorBlack);
  text_layer_set_font(temperature_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
  text_layer_set_text_alignment(temperature_layer, GTextAlignmentCenter);
  text_layer_set_text(temperature_layer, temperature);

  Tuplet initial_values[] = {
    TupletInteger(WEATHER_ICON_KEY, (uint8_t) 1),
    TupletCString(WEATHER_TEMPERATURE_KEY, "1234\u00B0C"),
  };
  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
      sync_tuple_changed_callback, sync_error_callback, NULL);

  layer_add_child(window_layer, text_layer_get_layer(temperature_layer));
  
  s_time_layer = text_layer_create(GRect(0, 0, 150, 40));
  text_layer_set_background_color(s_time_layer, GColorBlack);
  text_layer_set_text_color(s_time_layer, GColorWhite);
  text_layer_set_text(s_time_layer, "00:00:00");
  
  text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
  text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_time_layer));
  
  changeWeatherCode(0);
  
  timer = app_timer_register(delta, (AppTimerCallback) timer_callback, NULL);
}
Ejemplo n.º 10
0
static void init() {
  window = window_create();
  window_set_background_color(window, GColorBlack);
  window_set_fullscreen(window, true);

  icon_layer = bitmap_layer_create(GRect(32, 10, 80, 80));
  bitmap_layer_set_bitmap(icon_layer, icon_bitmap);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(icon_layer));

  temperature_layer = text_layer_create(GRect(0, 100, 144, 68));
  text_layer_set_text_color(temperature_layer, GColorWhite);
  text_layer_set_background_color(temperature_layer, GColorClear);
  text_layer_set_font(temperature_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
  text_layer_set_text_alignment(temperature_layer, GTextAlignmentCenter);
  text_layer_set_text(temperature_layer, temperature);
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(temperature_layer));

  Tuplet initial_values[] = {
    TupletInteger(WEATHER_ICON_KEY, (uint8_t) 1),
    TupletCString(WEATHER_TEMPERATURE_KEY, "1234\u00B0C"),
  };

  app_message_open(64, 64);
  send_cmd();

  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
      sync_tuple_changed_callback, sync_error_callback, NULL);


  window_stack_push(window, true /* Animated */);
}
Ejemplo n.º 11
0
/* Setup app message callbacks for weather */
void qtp_setup_app_message() {
#ifdef QTP_DEBUG
	APP_LOG(APP_LOG_LEVEL_DEBUG, "QTP: setting app message for weather");
#endif

	const int inbound_size = 100;
	const int outbound_size = 100;
	app_message_open(inbound_size, outbound_size);
	Tuplet initial_values[] = {
		TupletInteger(QTP_WEATHER_ICON_KEY, (uint8_t) 8),
		TupletCString(QTP_WEATHER_TEMP_F_KEY, "---\u00B0F"),
		TupletCString(QTP_WEATHER_TEMP_C_KEY, "---\u00B0F"),
		TupletCString(QTP_WEATHER_CITY_KEY, "Atlanta      "),
		TupletCString(QTP_WEATHER_DESC_KEY, "                       ")
	};
#ifdef QTP_DEBUG
	APP_LOG(APP_LOG_LEVEL_DEBUG, "QTP: weather tuples intialized");
#endif

	app_sync_init(&qtp_sync, qtp_sync_buffer, sizeof(qtp_sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
	  qtp_sync_changed_callback, qtp_sync_error_callback, NULL);
#ifdef QTP_DEBUG
	APP_LOG(APP_LOG_LEVEL_DEBUG, "QTP: weather app message initialized");
#endif

}
Ejemplo n.º 12
0
 // Menu callback
 void select_menu_callback(int index, void *context) {
	app_message_outbox_begin(&iter);
	static char* select_action;
	if  (strcmp(menu_action, "c") == 0) {
		select_action = "selClient";
	} else if(strcmp(menu_action, "t") == 0) {
		select_action = "selTask";
		snprintf(task_title, 40, "Task:\n%s", list_menu_items[index].title);
		text_layer_set_text(task_layer, task_title);
	} else if (strcmp(menu_action, "p") == 0) {
		select_action = "selProj";
		snprintf(project_title, 40, "Project:\n%s", list_menu_items[index].title);
		text_layer_set_text(task_layer, project_title);
	} else {
		// strcmp failed to find a match
		APP_LOG(APP_LOG_LEVEL_DEBUG, "No match on strcmp, value of menu_action follows");
		APP_LOG(APP_LOG_LEVEL_DEBUG, menu_action);
	}
	Tuplet action_type = TupletCString(0, select_action);
	dict_write_tuplet(iter, &action_type);
	Tuplet selected = TupletInteger(1, index);
	dict_write_tuplet(iter, &selected);
	app_message_outbox_send(); // this send is causing crash :S

	//pop the menu off
	window_stack_pop(true);
 }
Ejemplo n.º 13
0
static void send_cmd(void) {

	DictionaryIterator *iter;
	app_message_outbox_begin(&iter);

	if (iter == NULL) {
		return;
	}
	static char *bgptr = last_bg;
		static char *bgptr2 = last_bg_2;
	static char *timeptr = new_time;
		static char *timeptr_2 = new_time_2;

	Tuplet alertval = TupletInteger(3, 0);
	Tuplet bgVal = TupletCString(1, bgptr);
	Tuplet bgVal2 = TupletCString(4, bgptr2);
	Tuplet lastTimeVal = TupletCString(2, timeptr);
	Tuplet lastTimeVal2 = TupletCString(6, timeptr_2);


	dict_write_tuplet(iter, &alertval);
	dict_write_tuplet(iter, &bgVal);
	dict_write_tuplet(iter, &bgVal2);
	dict_write_tuplet(iter, &lastTimeVal);
	dict_write_tuplet(iter, &lastTimeVal2);

	dict_write_end(iter);

	app_message_outbox_send();

}
Ejemplo n.º 14
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_icon_layer = bitmap_layer_create(GRect(32, 10, 80, 80));
  layer_add_child(window_layer, bitmap_layer_get_layer(s_icon_layer));

  s_temperature_layer = text_layer_create(GRect(0, 75, bounds.size.w, 68));
  text_layer_set_text_color(s_temperature_layer, GColorWhite);
  text_layer_set_background_color(s_temperature_layer, GColorClear);
  text_layer_set_font(s_temperature_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
  text_layer_set_text_alignment(s_temperature_layer, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(s_temperature_layer));

  s_city_layer = text_layer_create(GRect(0, 105, bounds.size.w, 68));
  text_layer_set_text_color(s_city_layer, GColorWhite);
  text_layer_set_background_color(s_city_layer, GColorClear);
  text_layer_set_font(s_city_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
  text_layer_set_text_alignment(s_city_layer, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(s_city_layer));

  Tuplet initial_values[] = {
    TupletInteger(WEATHER_ICON_KEY, (uint8_t) 1),
    TupletCString(WEATHER_TEMPERATURE_KEY, "1234\u00B0C"),
    TupletCString(WEATHER_CITY_KEY, "St Pebblesburg"),
  };

  app_sync_init(&s_sync, s_sync_buffer, sizeof(s_sync_buffer), 
      initial_values, ARRAY_LENGTH(initial_values),
      sync_tuple_changed_callback, sync_error_callback, NULL
  );

  request_weather();
}
Ejemplo n.º 15
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);

  icon_layer = bitmap_layer_create(GRect(12, -5, 120, 120));
  layer_add_child(window_layer, bitmap_layer_get_layer(icon_layer));

  temperature_layer = text_layer_create(GRect(0, 100, 144, 68));
  text_layer_set_text_color(temperature_layer, GColorWhite);
  text_layer_set_background_color(temperature_layer, GColorClear);
  text_layer_set_font(temperature_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT));
  text_layer_set_text_alignment(temperature_layer, GTextAlignmentCenter);
  text_layer_set_text(temperature_layer, temperature);

  Tuplet initial_values[] = {
    TupletInteger(WEATHER_ICON_KEY, (uint8_t) 0),
    TupletCString(WEATHER_TEMPERATURE_KEY, "70\u00B0F"),
    TupletCString(WEATHER_REALFEEL_KEY, "70\u00B0F"),
  };
    
  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
      sync_tuple_changed_callback, sync_error_callback, NULL);
  
  window_set_click_config_provider(window, (ClickConfigProvider) config_provider);

  layer_add_child(window_layer, text_layer_get_layer(temperature_layer));
}
Ejemplo n.º 16
0
static void window_load(Window *window) {
    Layer *window_layer = window_get_root_layer(window);
    
    datetime_layer = text_layer_create(GRect(0, 100, 144, 22));
    text_layer_set_text_color(datetime_layer, GColorBlack);
    text_layer_set_background_color(datetime_layer, GColorWhite);
    text_layer_set_font(datetime_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
    text_layer_set_text_alignment(datetime_layer, GTextAlignmentCenter);
    layer_add_child(window_layer, text_layer_get_layer(datetime_layer));
    
    icon_layer = bitmap_layer_create(GRect(84, 0, 60, 60));
    layer_add_child(window_layer, bitmap_layer_get_layer(icon_layer));
    
    bg_layer = text_layer_create(GRect(0, 5, 83, 68));
    text_layer_set_text_color(bg_layer, GColorWhite);
    text_layer_set_background_color(bg_layer, GColorClear);
    text_layer_set_font(bg_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_MEDIUM_NUMBERS));
    text_layer_set_text_alignment(bg_layer, GTextAlignmentCenter);
    layer_add_child(window_layer, text_layer_get_layer(bg_layer));
    
    readtime_layer = text_layer_create(GRect(0, 48, 144, 115));
    text_layer_set_text_color(readtime_layer, GColorWhite);
    text_layer_set_background_color(readtime_layer, GColorClear);
    text_layer_set_font(readtime_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT));
    text_layer_set_text_alignment(readtime_layer, GTextAlignmentCenter);
    layer_add_child(window_layer, text_layer_get_layer(readtime_layer));
    
    message_layer = text_layer_create(GRect(0, 124, 144, 68));
    text_layer_set_text_color(message_layer, GColorBlack);
    text_layer_set_background_color(message_layer, GColorWhite);
    text_layer_set_font(message_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
    text_layer_set_text_alignment(message_layer, GTextAlignmentCenter);
    layer_add_child(window_layer, text_layer_get_layer(message_layer));
    
    Tuplet initial_values[] = {
        TupletInteger(CGM_ICON_KEY, (uint8_t) 4),
        TupletCString(CGM_BG_KEY, ""),
        TupletCString(CGM_READTIME_KEY, ""),
        TupletInteger(CGM_ALERT_KEY, 0),
        TupletCString(CGM_TIME_NOW, "loading..."),
        TupletCString(CGM_DELTA_KEY, " ")
    };

    app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),sync_tuple_changed_callback, sync_error_callback, NULL);

    timer = app_timer_register(100, timer_callback, NULL);
}
Ejemplo n.º 17
0
static bool  app_msg_RequestLatLong_internal(void)
{

   bool fMyRet = true;

#if TESTING_DISABLE_LOCATION_REQUEST
   return true;
#endif

   Tuplet fetch_tuple = TupletInteger(MSG_KEY_GET_LAT_LONG, 1); 

   DictionaryIterator *iter;
   AppMessageResult amRet;

   amRet = app_message_outbox_begin(&iter);

   if (amRet != APP_MSG_OK)
   {
      APP_LOG(APP_LOG_LEVEL_DEBUG, "app_message_outbox_begin failed, ret = %04X", amRet);
      return false; 
   }

   if (iter == NULL)
   {
      APP_LOG(APP_LOG_LEVEL_DEBUG, "app_message_outbox_begin returned null iter");
      return false;
   }

   DictionaryResult dRet;

   dRet = dict_write_tuplet(iter, &fetch_tuple);
   if (dRet != DICT_OK)
   {
      APP_LOG(APP_LOG_LEVEL_DEBUG, "dict_write_tuplet failed, ret = %04X", dRet);
      fMyRet = false;
      //  fall through to call end anyway
   }

   unsigned uRet;

   uRet = dict_write_end(iter);
   if (uRet == 0)
   {
      fMyRet = false;
   }

   if (fMyRet)
   {
      amRet = app_message_outbox_send();
      if (amRet != APP_MSG_OK)
      {
         APP_LOG(APP_LOG_LEVEL_DEBUG, "app_message_outbox_send failed, ret = %04X", amRet);
         fMyRet = false;
      }
   }

   return fMyRet;

}  /* end of app_msg_RequestLatLong_internal(void) */
Ejemplo n.º 18
0
static void setLED(int newLEDState) {
  Tuplet value = TupletInteger(KEY_LED,newLEDState);
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);

  dict_write_tuplet(iter,&value);
  app_message_outbox_send();
}
Ejemplo n.º 19
0
static void notifySpark(int sparkkey) {
  Tuplet value = TupletInteger(KEY_NOTIFY,sparkkey);
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);

  dict_write_tuplet(iter,&value);
  app_message_outbox_send();
}
Ejemplo n.º 20
0
void select_click_handler(ClickRecognizerRef recognizer, void *context) {
   text_layer_set_text(s_time_layer, "Retrieve");
  DictionaryIterator *iter;
 app_message_outbox_begin(&iter);
Tuplet value = TupletInteger(1, 42);
 dict_write_tuplet(iter, &value);
app_message_outbox_send();
}
Ejemplo n.º 21
0
// Change to another client
void change_client_click(ClickRecognizerRef recognizer, Window *window) {
	app_message_outbox_begin(&iter);
	Tuplet value = TupletCString(0, "getClients");
	dict_write_tuplet(iter, &value);
	Tuplet pager = TupletInteger(1, page);
	dict_write_tuplet(iter, &pager);
	app_message_outbox_send();
}
Ejemplo n.º 22
0
static void select_click_handler(ClickRecognizerRef recognizer, void *context) {
    DictionaryIterator *iter2;
    app_message_outbox_begin(&iter2);
    BatteryChargeState cs = battery_state_service_peek();
    Tuplet value = TupletInteger(3, cs.charge_percent);
    dict_write_tuplet(iter2, &value);
    app_message_outbox_send();
}
Ejemplo n.º 23
0
static void select_click_handler(ClickRecognizerRef recognizer, void *context) {
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  Tuplet value = TupletInteger(1, 42);
  dict_write_tuplet(iter, &value);
  app_message_outbox_send();
  text_layer_set_text(text_layer, "Select button tapped.");
}
Ejemplo n.º 24
0
/* 
 * Call on the phone to ring
 */
static void ring() {
  //Ring the phone
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  Tuplet ringTuplet = TupletInteger(RING, 2550);
  dict_write_tuplet(iter, &ringTuplet);
  app_message_outbox_send();
}
Ejemplo n.º 25
0
static void select_callback(int index, void *context) {	
	int * pointerToValue = (int*) context;
	if(* pointerToValue == 0){
		send_to_phone( TupletInteger(101, index)); //index maps to courseIdx!
		vibes_short_pulse();
		window_stack_pop(true); //close this window (course menu)
	}
}
Ejemplo n.º 26
0
static void down_click_handler(ClickRecognizerRef recognizer, void *context) {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    
    Tuplet value = TupletInteger(SELECT, STR_CHANGE_DOWN);
    dict_write_tuplet(iter, &value);
    
    app_message_outbox_send();
}
Ejemplo n.º 27
0
void send_int(uint8_t key, uint8_t cmd) {
	DictionaryIterator *iter;
 	app_message_outbox_begin(&iter);

 	Tuplet value = TupletInteger(key, cmd);
 	dict_write_tuplet(iter, &value);

 	app_message_outbox_send();
}
Ejemplo n.º 28
0
void getTL(){

    DictionaryIterator *it;
    app_message_outbox_begin(&it);
    Tuplet tuplet = TupletInteger(KEY_RESOURCE, r);
    dict_write_tuplet(it, &tuplet);
    dict_write_end(it);
    app_message_outbox_send();
}
Ejemplo n.º 29
0
static void window_load(Window *window) {
	Layer *window_layer = window_get_root_layer(window);
	
	font_last_price_small = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DIAVLO_MEDIUM_39));
	font_last_price_large = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DIAVLO_MEDIUM_39));
  font_hash_large = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DIAVLO_MEDIUM_39));
	
	text_five_layer = text_layer_create(GRect(0, 0, 144-0, 168-0));
	text_layer_set_text_color(text_five_layer, GColorWhite);
	text_layer_set_background_color(text_five_layer, GColorClear);
	text_layer_set_font(text_five_layer, font_last_price_large);
	text_layer_set_text_alignment(text_five_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(text_five_layer));
  
  text_hash_layer = text_layer_create(GRect(0, 64, 144-0, 168-40));
	text_layer_set_text_color(text_hash_layer, GColorWhite);
	text_layer_set_background_color(text_hash_layer, GColorClear);
	text_layer_set_font(text_hash_layer, fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
	text_layer_set_text_alignment(text_hash_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(text_hash_layer));
  

	
	
	text_date_layer = text_layer_create(GRect(8, 96, 144-8, 168-96));
	text_layer_set_text_color(text_date_layer, GColorWhite);
	text_layer_set_background_color(text_date_layer, GColorClear);
	text_layer_set_font(text_date_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DIAVLO_15)));
	layer_add_child(window_layer, text_layer_get_layer(text_date_layer));
	
	text_time_layer = text_layer_create(GRect(7, 114, 144-7, 168-114));
	text_layer_set_text_color(text_time_layer, GColorWhite);
	text_layer_set_background_color(text_time_layer, GColorClear);
	text_layer_set_font(text_time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DIAVLO_HEAVY_44)));
	layer_add_child(window_layer, text_layer_get_layer(text_time_layer));
	
	tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
	
	time_t now = time(NULL);
	struct tm *t = localtime(&now);
	update_time(t);
	
	Tuplet initial_values[] = {
		TupletCString(FIVE_HASH, "---"),
    //TupletCString(FIVE_HASH, "---"),
//		TupletCString(HOUR_HASH, "---"),
		TupletInteger(INVERT_COLOR_KEY, persist_read_bool(INVERT_COLOR_KEY)),
	};
	
	app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
				  sync_tuple_changed_callback, sync_error_callback, NULL);
	
	//send_cmd();last_price
	timer = app_timer_register(2000, timer_callback, NULL);
	//set_timer();
}
Ejemplo n.º 30
0
void request_config(void) {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Requesting config");
  Tuplet request_tuple = TupletInteger(REQUEST_CONFIG, 1);
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  if (!iter) return;
  dict_write_tuplet(iter, &request_tuple);
  dict_write_end(iter);
  app_message_outbox_send();
}