Esempio n. 1
0
void ui_hide(Window* w)
{
    app_message_register_inbox_received(0);
    app_message_set_context(w);

    window_stack_remove(w, true);
}
Esempio n. 2
0
void ui_show(const ui_ops_t* ops, Window* w)
{
    window_stack_push(w, true);

    app_message_set_context(w);
    app_message_register_inbox_received(ops->inbox);
}
Esempio n. 3
0
static void app_message_init(void) {
	app_message_open(124 /* inbound_size */, 124 /* outbound_size */);
	app_message_register_inbox_received(in_received_handler);
	app_message_register_inbox_dropped(in_dropped_handler);
	app_message_register_outbox_sent(out_sent_handler);
	app_message_register_outbox_failed(out_failed_handler);
}
Esempio n. 4
0
void wait_for_js_ready(JsReadyCallback callback) {
  s_js_ready = callback;

  app_message_deregister_callbacks();
  app_message_register_inbox_received(inbox_received_handler);
  app_message_open(2026, 656);
}
int main(void) {
	appmessage_max_size = app_message_inbox_size_maximum();
	if (appmessage_max_size > 4096)
		appmessage_max_size = 4096; //Limit inbox size to conserve RAM.

	#ifdef PBL_PLATFORM_APLITE
		//Aplite has so little memory, we can't squeeze much more than that out of appmessage buffer.
		appmessage_max_size = 124;
	#endif

	app_message_register_inbox_received(received_data);
	app_message_register_outbox_sent(sent_data);
	app_message_open(appmessage_max_size, 408);

	loadingMode = true;
	send_initial_packet();
	app_timer_register(3000, loading_retry_timer, NULL);

	switchWindow(0);
	app_event_loop();
	window_stack_pop_all(false);

	free(config_periodicVibrationPattern);

    AppLaunchReason appLaunchReason = launch_reason();
    if (appLaunchReason == APP_LAUNCH_PHONE && !config_dontClose) {
        // If app was launched by phone and close to last app is disabled, always exit to the watchface instead of to the menu
        exit_reason_set(APP_EXIT_ACTION_PERFORMED_SUCCESSFULLY);
    }

	return 0;
}
Esempio n. 6
0
static void app_message_init(void) {
    app_message_register_inbox_dropped(app_message_inbox_dropped);
    app_message_register_inbox_received(app_message_inbox_received);
    app_message_register_outbox_failed(app_message_outbox_failed);
    app_message_register_outbox_sent(app_message_outbox_sent);
    app_message_open(app_message_inbox_size_maximum(), 256);
}
Esempio n. 7
0
void handle_init(void) {
	// Create a window and text layer
	window = window_create();
	text_layer = text_layer_create(GRect(0, 0, 144, 154));
	
	// Set the text, font, and text alignment
	text_layer_set_text(text_layer, "Project Kina");
	text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
	text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
	
	// Add the text layer to the window
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));

	// Push the window
	window_stack_push(window, true);
	
	// App Logging!
	APP_LOG(APP_LOG_LEVEL_DEBUG, "Just pushed a window!");
  
   app_message_register_inbox_received(in_received_handler);
   app_message_register_inbox_dropped(in_dropped_handler);
   app_message_register_outbox_sent(out_sent_handler);
   app_message_register_outbox_failed(out_failed_handler);

   const int inbound_size = 64;
   const int outbound_size = 64;
   app_message_open(inbound_size, outbound_size);
}
Esempio n. 8
0
void init() {
	window = window_create();
  window_set_background_color(window, GColorBlack);
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
	window_set_window_handlers(window, handlers);
  window_set_fullscreen(window, true);

	//Register AppMessage events
	app_message_register_inbox_received(in_received_handler);
	app_message_open(512, 512);		//Large input and output buffer sizes

	window_stack_push(window, true);

  // Init the text layer used to show the time
    time_layer = text_layer_create(GRect(0, 0, 144 /* width */, 50 /* height */));
    text_layer_set_text_color(time_layer, GColorBlack);
    text_layer_set_background_color(time_layer, GColorWhite);
    text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
    text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);

    // Ensures time is displayed immediately (will break if NULL tick event accessed).
    // (This is why it's a good idea to have a separate routine to do the update itself.)
    time_t now = time(NULL);
    struct tm *current_time = localtime(&now);
    handle_battery(battery_state_service_peek());
    handle_second_tick(current_time, SECOND_UNIT);
    tick_timer_service_subscribe(SECOND_UNIT, &handle_second_tick);
    battery_state_service_subscribe(&handle_battery);

    layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));
}
int main() {
	app_message_register_outbox_sent(data_delivered);
	app_message_register_inbox_received(received_data);

	app_message_open(124, 50);

	DictionaryIterator *iterator;
	app_message_outbox_begin(&iterator);
	dict_write_uint8(iterator, 0, 0);
	dict_write_uint8(iterator, 1, 0);
	dict_write_uint16(iterator, 2, PROTOCOL_VERSION);
	#ifdef PBL_PLATFORM_APLITE
		dict_write_uint8(iterator, 3, 0);
	#else
		dict_write_uint8(iterator, 3, 1);
	#endif

	app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
	app_message_outbox_send();

	switchWindow(0);
	app_event_loop();
	window_stack_pop_all(false);
	return 0;
}
Esempio n. 10
0
void handle_init(void) {
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Init. Register callbacks, create windows and text layer.");

    // Register callbacks
    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);

    // Open AppMessage
    app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());

    // Create a window and text layer
    window = window_create();
    text_layer = text_layer_create(GRect(0, 0, 144, 154));

    // Set the text, font, and text alignment
    text_layer_set_text(text_layer, "Hi, I'm a Pebble!");
    text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
    text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);

    // Add the text layer to the window
    layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));

    // Push the window
    window_stack_push(window, true);

    // App Logging!
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Just pushed a window!");
}
Esempio n. 11
0
//=====================================
// initiliase/tear down
static void init() {
  // register with the time service
  tick_timer_service_subscribe(SECOND_UNIT, tick_handler);

  //register for battery info updates
  battery_state_service_subscribe(battery_callback);

  // register for bluetooth events
  bluetooth_connection_service_subscribe(bluetooth_callback);

  // register callbacks
  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);

  //open app message
  app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());

  //create main window element and assign to pointer
  s_main_window = window_create();
  window_set_background_color(s_main_window, GColorCadetBlue);

  //set handlers to manage elements inside Window
  window_set_window_handlers(s_main_window, (WindowHandlers){
    .load = main_window_load,
    .unload = main_window_unload
  });
Esempio n. 12
0
int main( void ) {
	window = window_create();
	window_stack_push(window, true);
	
	// Register AppMessage handlers
	app_message_register_inbox_received(in_received_handler); 
	app_message_register_inbox_dropped(in_dropped_handler); 
	app_message_register_outbox_failed(out_failed_handler);
		
	app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());

	desc_text = text_layer_create(GRect(0, 0, 144, 16));
	text_layer_set_text_alignment(desc_text, GTextAlignmentCenter);
  	layer_add_child(window_get_root_layer(window), text_layer_get_layer(desc_text));
  	text_layer_set_text(desc_text, "current letter (phone)");

  	alphabet_text = text_layer_create(GRect(0, 18, 144, 50));
	text_layer_set_text_alignment(alphabet_text, GTextAlignmentCenter);
	text_layer_set_font(alphabet_text, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(alphabet_text));
	text_layer_set_text(alphabet_text, "*");

	app_event_loop();
	
	app_message_deregister_callbacks();
	window_destroy(window);
}
static void init(void) {
	// Initialize Pebble Autoconfig to register App Message handlers and restores settings
	autoconfig_init();

	// Here the restored or defaulted settings are available
	logSettings("restored");

	// Register our custom receive handler which in turn will call Pebble Autoconfigs receive handler
	app_message_register_inbox_received(in_received_handler);
	
	window = window_create();
	Layer *window_layer = window_get_root_layer(window);
	GRect bounds = layer_get_frame(window_layer);

	for (int i = 0; i < SETTING_COUNT; ++i) {
		layer[i] = text_layer_create(GRect(10, 10 + i*35, bounds.size.w - 10, 28));
		layer_add_child(window_layer, text_layer_get_layer(layer[i]));
	}

	updateDisplay();

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

	window_stack_push(window, true);
}
Esempio n. 14
0
int
main(void)
{
  AppMessageResult rslt;
  Window *top;
  
  top = menu_create();
  if (!top) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "Failed to create window!");
    return 1;
  }

  app_message_set_context(top);
  app_message_register_inbox_received(msg_received);
  rslt = app_message_open(app_message_inbox_size_maximum(),
                          app_message_outbox_size_maximum());
  if (rslt != APP_MSG_OK) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "Failed to open message boxes: %d!", rslt);
    return 1;
  }

  window_stack_push(top, true);

  app_event_loop();
     
  app_message_deregister_callbacks();
  window_destroy(top);
  return 0;
}
Esempio n. 15
0
void handle_init(void) {
  my_window = window_create();

//  text_layer = text_layer_create(GRect(0, 0, 144, 20));
  // Create time TextLayer
  s_time_layer = text_layer_create(GRect(0, 55, 144, 50));
  text_layer_set_background_color(s_time_layer, GColorClear);
  text_layer_set_text_color(s_time_layer, GColorBlack);
  text_layer_set_text(s_time_layer, "00:00");

  // Improve the layout to be more like a watchface
  text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
  text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);

  // Add it as a child layer to the Window's root layer
  layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(s_time_layer));
  tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
  update_time();
  window_set_click_config_provider(my_window, config_provider);
  app_message_register_inbox_received(in_received_handler);
   app_message_register_inbox_dropped(in_dropped_handler);
   app_message_register_outbox_sent(out_sent_handler);
   app_message_register_outbox_failed(out_failed_handler);
const uint32_t inbound_size = 64;
   const uint32_t outbound_size = 64;
   app_message_open(inbound_size, outbound_size);
  window_stack_push(my_window, true);
}
Esempio n. 16
0
void  app_msg_init(app_msg_coords_recvd_callback successCallback,
                   app_msg_coords_failed_callback failureCallback)
{

   //  Hook in caller's callback, before it might possibly be called.
   coords_recvd_callback = successCallback;
   coords_failed_callback = failureCallback;

   fRequestOutstanding = false;

   // Register PebbleOS message handlers
   app_message_register_inbox_received(in_received_handler);
   app_message_register_inbox_dropped(in_dropped_handler);
   app_message_register_outbox_failed(out_failed_handler);

   // Init buffers

   //  Pebble's current minima are larger than we need, and using the larger
   //  values may cost heap we don't have.
   app_message_open(min(64, APP_MESSAGE_INBOX_SIZE_MINIMUM),
                    min(64, APP_MESSAGE_OUTBOX_SIZE_MINIMUM));

   //  too early here: better for caller to explicitly request from window_load()
//   app_msg_RequestLatLong();

}  /* end of app_msg_init */
Esempio n. 17
0
static void init() {
  // Subscribe to Wakeup API
  wakeup_service_subscribe(wakeup_handler);
  
  // Register callbacks
  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(400,400);
  
  // Was this a wakeup launch?
  if (launch_reason() == APP_LAUNCH_WAKEUP) {
    // The app was started by a wakeup
    WakeupId id = 0;
    int32_t reason = 0;

    // Get details and handle the wakeup
    wakeup_get_launch_event(&id, &reason);
    wakeup_handler(id, reason);
  } else {
    // Launch main page
    init_main_window();
    
    // Launch the splash page
    init_splash_window();
  }
}
Esempio n. 18
0
void handle_init(void) {
  load_config();

  srand((uint32_t) time(NULL));

  window = window_create();
  window_stack_push(window, true);
  
  Layer *window_layer = window_get_root_layer(window);

  text_layer = text_layer_create(GRect(0, -2, 144, 168));
  text_layer_set_background_color(text_layer, GColorClear);
  text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
  layer_add_child(window_layer, text_layer_get_layer(text_layer));

  update_colors();
  
  tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
  handle_minute_tick(NULL, MINUTE_UNIT);

  app_message_register_inbox_received(in_received_handler);
  const uint32_t inbound_size = 64;
  const uint32_t outbound_size = 64;
  app_message_open(inbound_size, outbound_size);
}
Esempio n. 19
0
bool owm_weather_fetch(OWMWeatherCallback *callback) {
  if(!s_info) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "OWM Weather library is not initialized!");
    return false;
  }

  if(!callback) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "OWMWeatherCallback was NULL!");
    return false;
  }

  s_callback = callback;

  if(!bluetooth_connection_service_peek()) {
    s_status = OWMWeatherStatusBluetoothDisconnected;
    s_callback(s_info, s_status);
    return false;
  }

  app_message_deregister_callbacks();
  app_message_register_inbox_received(inbox_received_handler);
  app_message_open(2026, 656);

  return fetch();
}
Esempio n. 20
0
static void init(void)
{
    memset(&time_digits_layers, 0, sizeof(time_digits_layers));
    memset(&time_digits_images, 0, sizeof(time_digits_images));

    const int inbound_size = 64;
    const int outbound_size = 64;
    app_message_open(inbound_size, outbound_size);  

    window = window_create();
    if (window == NULL)
    {
        return;
    }

    window_set_background_color(window, GColorBlack);
    
    canvas = layer_create(GRect(0, 0, 144, 168));
	layer_set_update_proc(canvas, (LayerUpdateProc) render);
	layer_add_child(window_get_root_layer(window), canvas);
	
    window_stack_push(window, true);
    Layer *window_layer = window_get_root_layer(window);
    
    load_settings();
    
    // Open AppMessage connection
    app_message_register_inbox_received(inbox_received_handler);
    app_message_open(128, 128);
    
    //owm_weather_init(5ba77aab84470992ddc7e49e4985aeab);
    //events_app_message_open();
    //owm_weather_fetch();    
    handle_weather();
    
    handle_battery(battery_state_service_peek());
    battery_state_service_subscribe(handle_battery);
 
    // Create time and date layers
    GRect dummy_frame = { {0, 0}, {0, 0} };

    for (int i = 0; i < TOTAL_TIME_DIGITS; i++)
    {
        time_digits_layers[i] = bitmap_layer_create(dummy_frame);
        layer_add_child(window_layer, bitmap_layer_get_layer(time_digits_layers[i]));
    }

    mFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_20));
    mDayText = malloc(mDayTextSize);
    mWeatherText = malloc(mWeatherTextSize);
    mBatteryText = malloc(mBatteryTextSize);
    
    // Avoids a blank screen on watch start.
    time_t now = time(NULL);
    struct tm *tick_time = localtime(&now);
    handle_tick(tick_time, DAY_UNIT + HOUR_UNIT + MINUTE_UNIT);
    
    tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
}
Esempio n. 21
0
static void app_message_init(void) {
  // Register message handlers
  app_message_register_inbox_received(in_received_handler);
  app_message_register_inbox_dropped(in_dropped_handler);
  app_message_register_outbox_failed(out_failed_handler);
  // Init buffers
  app_message_open(64, 64);
}
Esempio n. 22
0
void communication_init() {
  APP_LOG(APP_LOG_LEVEL_INFO, "Initializing communication");
  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(1024, 64);
}
Esempio n. 23
0
void handle_init(void) {
	// Create a window and text layer
	window = window_create();
	text_layer = text_layer_create(GRect(0, TIME_HEIGHT, 144, 168 - TIME_HEIGHT));

	show_seconds = persist_read_bool(KEY_SHOW_SECONDS);
	invert_face = persist_read_bool(KEY_INVERT);
	metric_units = persist_read_bool(KEY_UNITS);
	
	latitude[0] = 0;
	longitude[0] = 0;
	location[0] = 0;
	weather[0] = 0;
	// Set the text, font, and text alignment
	//text_layer_set_text(text_layer, "");
	// http://www.openweathermap.org/current
	// https://developer.getpebble.com/blog/2013/07/24/Using-Pebble-System-Fonts/
	// https://github.com/JvetS/PebbleSimulator/blob/master/PebbleSimulator/pebble_fonts.h
	text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
	// https://developer.getpebble.com/2/api-reference/group___graphics_types.html
	text_layer_set_text_alignment(text_layer, GTextAlignmentLeft);

	// Add the text layer to the window
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));

//	date_layer = text_layer_create(GRect(0, 112, 144, 56));
//	text_layer_set_text_alignment(date_layer, GTextAlignmentCenter);
//	text_layer_set_font(date_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
//	layer_add_child(window_get_root_layer(window), text_layer_get_layer(date_layer));
	time_layer = text_layer_create(GRect(0, 0, 144, TIME_HEIGHT));
	text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
	text_layer_set_font(time_layer, fonts_get_system_font(FONT_PRO_32));
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));

	inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
	layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(inverter_layer));
	layer_set_hidden(inverter_layer_get_layer(inverter_layer), invert_face);
	
	battery_state_service_subscribe(handle_battery_change);
	handle_battery_change(battery_state_service_peek());

	bluetooth_connection_service_subscribe(handle_bluetooth_change);
	handle_bluetooth_change(bluetooth_connection_service_peek());
	
	app_message_register_inbox_received(in_received_handler);
	app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());

	time_t current_time = time(0);
	handle_timechanges(localtime(&current_time), SECOND_UNIT);
	
	tick_timer_service_subscribe(SECOND_UNIT, handle_timechanges);
	
	// Push the window
	window_stack_push(window, true);

	// App Logging!
	//APP_LOG(APP_LOG_LEVEL_DEBUG, "Hello World from the applogs!");
}
Esempio n. 24
0
static void initialize_ui() {
  s_window = window_create();
  window_set_fullscreen(s_window, false);
  window_set_background_color(s_window, GColorBlack);
  Layer *window_layer = window_get_root_layer(s_window);
  GRect bounds = layer_get_frame(window_layer);
  
  s_icon_vol_up = gbitmap_create_with_resource(RESOURCE_ID_ICON_VOL_UP);
  s_icon_pause = gbitmap_create_with_resource(RESOURCE_ID_ICON_PAUSE);
  s_icon_play = gbitmap_create_with_resource(RESOURCE_ID_ICON_PLAY);
  s_icon_vol_dn = gbitmap_create_with_resource(RESOURCE_ID_ICON_VOL_DN);
  s_icon_speaker = gbitmap_create_with_resource(RESOURCE_ID_ICON_SPEAKER);
  s_res_gothic_24_bold = fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD);
  s_res_gothic_18 = fonts_get_system_font(FONT_KEY_GOTHIC_18);

  // s_lyr_backround
  s_lyr_background = layer_create(bounds);
  layer_set_update_proc(s_lyr_background, lyr_background_update_proc);
  layer_add_child(window_layer, (Layer *) s_lyr_background);
  // s_player_bar
  s_action_bar = action_bar_layer_create();
  action_bar_layer_add_to_window(s_action_bar, s_window);
  action_bar_layer_set_icon(s_action_bar, BUTTON_ID_UP, s_icon_vol_up);
  action_bar_layer_set_icon(s_action_bar, BUTTON_ID_SELECT, s_icon_pause);
  action_bar_layer_set_icon(s_action_bar, BUTTON_ID_DOWN, s_icon_vol_dn);
  action_bar_layer_set_click_config_provider(s_action_bar, click_provider);
  layer_add_child(window_layer, (Layer *) s_action_bar);
  // s_txt_title
  s_txt_title = text_layer_create(GRect(4, 0, 116, 76));
  text_layer_set_background_color(s_txt_title, GColorClear);
  text_layer_set_text_color(s_txt_title, GColorWhite);
  text_layer_set_text_alignment(s_txt_title, GTextAlignmentCenter);
  text_layer_set_font(s_txt_title, s_res_gothic_24_bold);
  text_layer_set_text(s_txt_title, "Loading...");
  layer_add_child(window_layer, (Layer *) s_txt_title);
  // s_txt_artist
  s_txt_artist = text_layer_create(GRect(4, 78, 116, 56));
  text_layer_set_background_color(s_txt_artist, GColorClear);
  text_layer_set_text_color(s_txt_artist, GColorWhite);
  text_layer_set_text_alignment(s_txt_artist, GTextAlignmentCenter);
  text_layer_set_font(s_txt_artist, s_res_gothic_18);
  layer_add_child(window_layer, (Layer *) s_txt_artist);
  // s_bmap_speaker
  s_bmp_speaker = bitmap_layer_create(GRect(2, 134, 8, 12));
  bitmap_layer_set_bitmap(s_bmp_speaker, s_icon_speaker);
  layer_add_child(window_layer, (Layer *) s_bmp_speaker);
  // s_lyr_volume
  s_lyr_volume = layer_create_with_data(GRect(16, 136, 100, 8), sizeof(uint32_t));
  layer_set_update_proc(s_lyr_volume, lyr_volume_update_proc);
  uint32_t *len = (uint32_t *) layer_get_data(s_lyr_volume);
	*len = 0;
  layer_add_child(window_layer, (Layer *) s_lyr_volume);
  
  app_message_register_inbox_received(inbox_received_callback);
  app_message_register_inbox_dropped(inbox_dropped_callback);

  outbox_send("GET_STATUS");
}
Esempio n. 25
0
static void setupMessages() {
    app_comm_set_sniff_interval(SNIFF_INTERVAL_NORMAL);
    
    app_message_register_inbox_received(message_handler);
    app_message_register_inbox_dropped(message_dropped);
    
    app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
    APP_LOG(APP_LOG_LEVEL_DEBUG, "App Message set up.");
}
Esempio n. 26
0
void init(void) {
	// Register AppMessage handlers
	app_message_register_inbox_received(in_received_handler);
	app_message_register_inbox_dropped(in_dropped_handler);
  app_message_register_outbox_sent(out_sent_handler);
	app_message_register_outbox_failed(out_failed_handler);

	app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
}
Esempio n. 27
0
static void init(void) {
  app_message_register_inbox_received(in_received_handler);
  app_message_register_inbox_dropped(in_dropped_handler);
  app_message_register_outbox_sent(out_sent_handler);
  app_message_register_outbox_failed(out_failed_handler);
  app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
  
  show_concurrent_visits();
}
Esempio n. 28
0
static void handle_init() {
  SlidingTextData *data = (SlidingTextData*)malloc(sizeof(SlidingTextData));
  s_data = data;

  data->render_state.next_hours = 0;
  data->render_state.next_minutes = 0;
  data->render_state.demo_time.secs = 0;
  data->render_state.demo_time.mins = 0;
  data->render_state.demo_time.hour = 0;

  data->window = window_create();

  int bgcolor = persist_read_int(KEY_BACKGROUND_COLOR);
  GColor back_color = GColorFromHEX(bgcolor);
  window_set_background_color(data->window, back_color);

  data->bitham42_bold = fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD);
  data->bitham42_light = fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT);

  Layer *window_layer = window_get_root_layer(data->window);
  GRect layer_frame = layer_get_frame(window_layer);
  const int16_t width = layer_frame.size.w;
  init_sliding_row(data, &data->rows[0], GRect(0, 20, width, 60), data->bitham42_bold, 6);
  layer_add_child(window_layer, text_layer_get_layer(data->rows[0].label));

  init_sliding_row(data, &data->rows[1], GRect(0, 56, width, 96), data->bitham42_light, 3);
  layer_add_child(window_layer, text_layer_get_layer(data->rows[1].label));

  init_sliding_row(data, &data->rows[2], GRect(0, 92, width, 132), data->bitham42_light, 0);
  layer_add_child(window_layer, text_layer_get_layer(data->rows[2].label));

  GFont norm14 = fonts_get_system_font(FONT_KEY_GOTHIC_14);

  data->demo_label = text_layer_create(GRect(0, -3, 100, 20));
  text_layer_set_background_color(data->demo_label, GColorClear);

  int color = persist_read_int(KEY_TEXT_COLOR);
  GColor text_color = GColorFromHEX(color);

  text_layer_set_text_color(data->demo_label, text_color);
  text_layer_set_font(data->demo_label, norm14);
  text_layer_set_text(data->demo_label, "demo mode");
  layer_add_child(window_layer, text_layer_get_layer(data->demo_label));

  layer_set_hidden(text_layer_get_layer(data->demo_label), true);
  layer_mark_dirty(window_layer);

  make_animation();

  tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);

  const bool animated = true;
  window_stack_push(data->window, animated);

  app_message_register_inbox_received(inbox_received_handler);
  app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
}
Esempio n. 29
0
void comm_init() {
    // Register AppMessage handlers
    app_message_register_inbox_received(inbox_received_callback);
    app_message_register_inbox_dropped(in_dropped_handler);
    app_message_register_outbox_failed(out_failed_handler);

    app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());

}
void appmessagecontroller_load( Window *window )
{
    app_message_register_inbox_received(inboxReceivedCallback);
    app_message_register_inbox_dropped(inboxDroppedCallback);
    app_message_register_outbox_failed(outboxFailedCallback);
    app_message_register_outbox_sent(outboxSentCallback);
    
    app_message_open(200, 200);
}