int NETWORK_register()
{
int rval = 0;
struct NetworkState *state = 0;
state = (struct NetworkState*) malloc(sizeof(struct NetworkState));
abort_if(!state, "could not allocate state");
struct NetworkCallbacks *callbacks = 0;
callbacks = (struct NetworkCallbacks*) malloc(sizeof(struct NetworkCallbacks));
abort_if(!callbacks, "could not allocate callbacks");
state->callbacks = callbacks;
callbacks->on_ok = 0;
callbacks->on_habit = 0;
callbacks->on_count = 0;
callbacks->on_ok_context = 0;
callbacks->on_habit_context = 0;
callbacks->on_count_context = 0;
app_message_register_inbox_received(NETWORK_on_received);
app_message_open(1024, 1024);
app_message_set_context(state);
CLEANUP:
return rval;
}
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 ui_hide(Window* w)
{
app_message_register_inbox_received(0);
app_message_set_context(w);
window_stack_remove(w, true);
}
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);
}
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 simply_msg_init(SimplyData *simply) {
const uint32_t size_inbound = 1024;
const uint32_t size_outbound = 512;
app_message_open(size_inbound, size_outbound);
app_message_set_context(simply);
app_message_register_inbox_received(received_callback);
app_message_register_inbox_dropped(dropped_callback);
app_message_register_outbox_sent(sent_callback);
app_message_register_outbox_failed((AppMessageOutboxFailed) failed_callback);
}
static void on_app_ready(void* context) {
if (current_window == splash_window_get_base(splash_window)) {
// Send appReady msg back to JS
DictionaryIterator *iterator;
app_message_outbox_begin(&iterator);
dict_write_int8(iterator, MSG_APP_READY, 1);
app_message_outbox_send();
// This is a bad thing to do, don't do this...
app_message_set_context(menu_window_get_base(menu_window));
app_message_register_inbox_received(base_window_get_inbox_handler(menu_window_get_base(menu_window)));
}
}
SimplyMsg *simply_msg_create(Simply *simply) {
SimplyMsg *self = malloc(sizeof(*self));
*self = (SimplyMsg) { .simply = simply };
simply->msg = self;
app_message_open(APP_MSG_SIZE_INBOUND, APP_MSG_SIZE_OUTBOUND);
app_message_set_context(simply);
app_message_register_inbox_received(received_callback);
app_message_register_inbox_dropped(dropped_callback);
app_message_register_outbox_sent(sent_callback);
app_message_register_outbox_failed((AppMessageOutboxFailed) failed_callback);
return self;
}
//! Create window data and layers in here, as well as any variable prepping
//! @param window A pointer to the window the load was called by
static void prv_window_load_handler(Window *window) {
// window properties
Layer *root = window_get_root_layer(window);
GRect bounds = layer_get_bounds(root);
WindowData *data = (WindowData*)malloc(sizeof(WindowData));
// check return
if (data) {
// set window properties
window_set_user_data(window, data);
window_set_click_config_provider_with_context(window, prv_click_config_provider, data);
// create drawing layer and store pointer to window data in it
data->draw_layer = layer_create_with_data(bounds, sizeof(StickFigure*));
WindowData **layer_data = (WindowData**)layer_get_data(data->draw_layer);
(*layer_data) = data;
layer_set_update_proc(data->draw_layer, prv_layer_update_proc_handler);
layer_add_child(root, data->draw_layer);
// create the stick figure
data->stick_figure = stick_figure_create();
stick_figure_snap_pose(data->stick_figure, PoseWaitingForStart, prv_get_epoch_ms());
// create the button
data->button = drawing_button_create();
// set some window data properties
data->start_epoch = 0;
// load image resources
data->config_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_CONFIG);
data->grid_1_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_GRID_1);
data->grid_2_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_GRID_2);
// open app message communication with the phone
app_message_set_context(data);
app_message_register_inbox_received(prv_inbox_recived);
app_message_open(APP_MESSAGE_INBOX_SIZE_MINIMUM, APP_MESSAGE_OUTBOX_SIZE_MINIMUM);
// start first refresh
data->app_timer = app_timer_register(REFRESH_RATE_MS_PER_FRAME, prv_app_timer_callback, data);
return;
}
// error handling
window_stack_remove(window, false);
APP_LOG(APP_LOG_LEVEL_ERROR, "Error: Failed to allocate memory for WindowData.");
}
void init_network(WeatherData *weather_data)
{
int max_in = 1200; //app_message_inbox_size_maximum();
int max_out = 500; //app_message_outbox_size_maximum();
app_message_register_inbox_received(appmsg_in_received);
app_message_register_inbox_dropped(appmsg_in_dropped);
app_message_register_outbox_sent(appmsg_out_sent);
app_message_register_outbox_failed(appmsg_out_failed);
app_message_set_context(weather_data);
app_message_open(max_in, max_out);
APP_LOG(APP_LOG_LEVEL_DEBUG, "AppMessage max_IN: %i, max_OUT: %i", max_in, max_out);
weather_data->error = WEATHER_E_OK;
weather_data->updated = 0;
weather_data->js_ready = false;
weather_data->hourly_updated = 0;
weather_data->hourly_enabled = false;
retry_count = 0;
}
static void set_current_window(BaseWindow* base_window) {
current_window = base_window;
app_message_set_context(base_window);
app_message_register_inbox_received(base_window_get_inbox_handler(base_window));
}
void imagedownload_deinitialize() {
imagedownload_destroy_context(app_message_get_context());
app_message_set_context(NULL);
}
