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!");
}
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;
}
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 strap_init() {
if (!persist_read_bool(STRAP_OPT_OUT)) {
memset(cur_activity, 0, sizeof(cur_activity));
strap_set_activity("UNKNOWN");
app_message_register_outbox_sent(strap_out_sent_handler);
app_message_register_outbox_failed(strap_out_failed_handler);
// detect if app crashed last time
if (persist_read_bool(STRAP_CRASH_WATCHER)) {
strap_log_action("STRAP_CRASH");
}
// set persistent boolean that will be removed when app is deinited
// we will check for existance on init, and if it is true
persist_write_bool(STRAP_CRASH_WATCHER,true);
// start sending accl data in 30 seconds
#ifndef DISABLE_ACCL
acclStart = app_timer_register(30 * 1000, app_timer_accl_start,NULL);
#endif
battTimer = app_timer_register(1 * 10 * 1000, app_timer_battery,NULL);
//app_timer_register(30 * 1000,log_timer, NULL);
app_timer_register(1 * 1000,log_action,"STRAP_START");
} else {
app_log(APP_LOG_LEVEL_INFO, "log", 0, "USER OPTED OUT OF STRAP METRICS");
}
}
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;
}
void appmessage_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_max();
}
static void handle_init(void) {
window = window_create();
window_stack_push(window, true /* Animated */);
// child init
simplebig_init(window);
status_init(window);
termo_init(window);
// 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
AppMessageResult result = app_message_open(APP_MESSAGE_INBOX_SIZE_MINIMUM, APP_MESSAGE_OUTBOX_SIZE_MINIMUM);
if (result != APP_MSG_OK) {
APP_LOG(APP_LOG_LEVEL_ERROR, "Can't open inbox");
}
// handlers
tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
UnobstructedAreaHandlers ua_handler = {
.change = handle_unobstructed_change
};
unobstructed_area_service_subscribe(ua_handler, NULL);
// style
set_style();
// draw first frame
force_update();
}
void appmessage_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(128 /* inbound_size */, 64 /* outbound_size */);
}
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);
}
void messsages_open_send() {
// first register callbacks
app_message_register_inbox_received(messages_inbox_received);
app_message_register_inbox_dropped(messages_inbox_dropped);
app_message_register_outbox_sent(messages_outbox_sent);
app_message_register_outbox_failed(messages_outbox_failed);
if (app_message_open(APP_MESSAGE_INBOX_SIZE_MINIMUM, APP_MESSAGE_OUTBOX_SIZE_MINIMUM) != APP_MSG_OK) {
APP_LOG(APP_LOG_LEVEL_ERROR, "Open Message Failed");
return;
}
DictionaryIterator* dic_iterator;
if (app_message_outbox_begin(&dic_iterator) != APP_MSG_OK) {
APP_LOG(APP_LOG_LEVEL_ERROR, "Begin Message Outbox Failed");
return;
}
char buffer[50];
time_t now;
time(&now);
strftime(buffer, sizeof(buffer),"P: %H:%M %S", localtime(&now));
// write some data
dict_write_cstring(dic_iterator, 1, buffer);
dict_write_end(dic_iterator);
// send
app_message_outbox_send();
APP_LOG(APP_LOG_LEVEL_INFO,"Message %s sent",buffer);
}
// 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;
}
}
//=====================================
// 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 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);
}
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();
}
}
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);
}
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 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 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);
}
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());
}
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());
}
int main() {
app_message_register_outbox_sent(data_delivered);
app_message_register_inbox_received(received_data);
app_message_open(124, 50);
tick_timer_service_subscribe(SECOND_UNIT, (TickHandler) second_tick);
init_menu_window();
app_event_loop();
return 0;
}
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 accl_init(void) {
tick_timer_service_subscribe(SECOND_UNIT, handle_second_tick);
accel_data_service_subscribe(10, &accel_data_handler);
accel_service_set_sampling_rate(sample_freq); //This is the place that works
app_message_register_outbox_failed(accl_out_failed_handler);
app_message_register_outbox_sent(accl_out_received_handler);
timer = app_timer_register(timer_interval, timer_callback, NULL);
app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
}
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 app_message_init()
{
const uint32_t inbound_size = 64;
const uint32_t outbound_size = 64;
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(inbound_size, outbound_size);
}
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());
}
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);
}
