void imagedownload_initialize(ImageDownloadCallback callback) {
ImageDownloadContext *ctx = imagedownload_create_context(callback);
APP_LOG(APP_LOG_LEVEL_DEBUG, "ImageDownloadContext = %p", ctx);
app_message_set_context(ctx);
app_message_register_inbox_received(imagedownload_receive);
app_message_register_inbox_dropped(imagedownload_dropped);
app_message_register_outbox_sent(imagedownload_out_success);
app_message_register_outbox_failed(imagedownload_out_failed);
APP_LOG(APP_LOG_LEVEL_DEBUG, "Max buffer sizes are %lu / %lu", app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
}
/**
* Init
*/
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(message_handler_outbox_failed_handler);
app_message_register_outbox_sent(message_handler_outbox_sent_handler);
APP_LOG(APP_LOG_LEVEL_DEBUG, "max inbox: %d max outbox: %d", (int) app_message_inbox_size_maximum(), (int) app_message_outbox_size_maximum());
// Init buffers
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
}
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;
}
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);
}
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!");
}
static void openAppMessage(void) {
#ifndef PBL_PLATFORM_APLITE
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
#else
app_message_open(8200, 1500);
#endif
}
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);
}
//=====================================
// 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
});
void init()
{
//create window
window = window_create();
window_set_background_color(window,GColorBlack);
window_stack_push(window, true);
Layer* window_layer = window_get_root_layer(window);
//load background
background = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND);
//load font
raleway_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_RALEWAY_22));
//create layer
layer = layer_create(GRect(0,0,144,168));
layer_set_update_proc(layer, update_layer);
layer_add_child(window_layer, layer);
//subscribe to seconds tick event
tick_timer_service_subscribe(SECOND_UNIT, (TickHandler) tick);
// 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());
}
void comm_init() {
app_message_register_inbox_received(inbox_received_handler);
const int inbox_size = app_message_inbox_size_maximum();
const int outbox_size = 64;
app_message_open(inbox_size, outbox_size);
}
void openweather_init(void) {
// init forecast structure
forecast_data.day = calloc(OPENWEATHER_FCAST_DAYS, sizeof(ForecastDayType));
// init json parser
json_register_callbacks(object_callback, array_callback);
// Open channel
const int inbound_size = app_message_inbox_size_maximum();
const int outbound_size = app_message_outbox_size_maximum();
APP_LOG(APP_LOG_LEVEL_DEBUG, "Determined sizes: Inbox %u Outbox %u", inbound_size, outbound_size);
app_message_open(inbound_size, outbound_size);
// Init sync
Tuplet initial_values[] = {
TupletCString(OPENWEATHER_KEY, "")
};
app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
sync_tuple_changed_callback, sync_error_callback, NULL);
// Set update
set_timer(OPENWEATHER_REFRESH_INTERVAL);
}
// 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;
}
}
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;
}
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(¤t_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!");
}
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());
}
static void init(){
tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
app_message_register_inbox_received(inbox_recieved_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());
s_m_window = window_create();
window_set_window_handlers(s_m_window, (WindowHandlers){ .load = m_window_load, .unload = m_window_unload});
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(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
update_times();
}
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.");
}
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();
}
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());
}
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());
}
void select_click_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context)
{
int which = cell_index->row;
//The array that will hold the on/off vibration times
uint32_t segments[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//Build the pattern (milliseconds on and off in alternating positions)
for(int i = 0; i < which + 1; i++)
{
segments[2 * i] = 200;
segments[(2 * i) + 1] = 100;
}
//Create a VibePattern data structure
VibePattern pattern = {
.durations = segments,
.num_segments = 16
};
//Do the vibration pattern!
vibes_enqueue_custom_pattern(pattern);
psleep( 1000 );
// create window to show
word_window = window_create();
window_set_window_handlers(word_window, (WindowHandlers) {
.load = word_window_load,
.unload = word_window_unload,
});
window_stack_push(word_window, true);
// create window to show
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_LOG(APP_LOG_LEVEL_DEBUG, "Loop index now %d", 1);
// Open AppMessage
app_message_open( app_message_inbox_size_maximum(), app_message_outbox_size_maximum() );
// Begin dictionary
DictionaryIterator *iter;
app_message_outbox_begin(&iter);
// Add a key-value pair
dict_write_uint8(iter, 0, 0);
// Send the message!
app_message_outbox_send();
}
void appmessage_init(void) {
app_message_register_inbox_dropped(in_dropped_handler);
app_message_register_outbox_sent(out_sent_handler);
app_message_register_outbox_failed(out_failed_handler);
if(!AppMessageOpened) {
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
AppMessageOpened = true;
}
}
void message_init() {
// 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());
}
void netdownload_request(char *url) {
DictionaryIterator *outbox;
app_message_outbox_begin(&outbox);
// Tell the javascript how big we want each chunk of data: max possible size - dictionary overhead with one Tuple in it.
uint32_t chunk_size = app_message_inbox_size_maximum() - dict_calc_buffer_size(1);
dict_write_int(outbox, NETDL_CHUNK_SIZE, &chunk_size, sizeof(uint32_t), false);
// Send the URL
dict_write_cstring(outbox, NETDL_URL, url);
app_message_outbox_send();
}
static void init() {
app_message_register_inbox_received(inbox);
app_message_register_inbox_dropped(inbox_fail);
app_message_register_outbox_sent(outbox_sucess);
app_message_register_outbox_failed(outbox_failed);
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
AccelLogging = create_list();
}
void comm_init() {
app_message_register_inbox_received(inbox_received_handler);
app_message_register_inbox_dropped(inbox_dropped_handler);
app_message_register_outbox_sent(outbox_sent_handler);
app_message_register_outbox_failed(outbox_failed_handler);
APP_LOG(APP_LOG_LEVEL_INFO, "inbox max: %d", (int)app_message_inbox_size_maximum());
const int inboxSize = NUM_ITEMS*MAX_LENGTH*2;
const int outboxSize = 128;
app_message_open(inboxSize, outboxSize);
}
void http_init(HttpInitCallback *callback) {
init_callback = callback;
uint32_t inbox_size = app_message_inbox_size_maximum();
uint32_t outbox_size = app_message_outbox_size_maximum();
app_message_register_inbox_received(on_message);
app_message_register_outbox_sent(on_sent);
app_message_open(inbox_size, outbox_size);
broadcast_inbox_size(inbox_size);
}
void imagedownload_request(char *url) {
DictionaryIterator *outbox;
app_message_outbox_begin(&outbox);
// Tell the javascript how big we want each chunk of data:
// max possible size - dictionary overhead with one zero-byte Tuple in it (since rest of tuple is our data).
uint32_t chunk_size = app_message_inbox_size_maximum() - dict_calc_buffer_size(1, 0);
dict_write_int(outbox, MYQR_CHUNK_SIZE, &chunk_size, sizeof(uint32_t), false);
// Send the URL
dict_write_cstring(outbox, MYQR_REQUEST_CODE, url);
app_message_outbox_send();
}
static void init() {
app_worker_launch();
app_worker_message_subscribe(worker_message_handler);
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
// Create main Window
s_main_window = window_create();
window_set_window_handlers(s_main_window, (WindowHandlers) {
.load = main_window_load,
.unload = main_window_unload
});
