Beispiel #1
0
static void send_to_phone() {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Preparing data to send to Phone");

  if (listSize == 0) return;
  DictionaryIterator *dict;
  app_message_outbox_begin(&dict);

  int indexToSend = (int) menu_layer_get_selected_index(s_menu_layer).row;
  APP_LOG(APP_LOG_LEVEL_DEBUG, "statusList[indexToSend] set to: %s", statusList[indexToSend]);
  
  if (strcmp(statusList[indexToSend],"Ready") != 0 &&
     strcmp(statusList[indexToSend],"Pending...") != 0) {
    free (statusList[indexToSend]);
    statusList[indexToSend] = NULL;
   APP_LOG(APP_LOG_LEVEL_DEBUG, "?Preparing data to send to Phone");
  }
  menu_layer_reload_data(s_menu_layer);
  statusList[indexToSend] = "Pending...";
  APP_LOG(APP_LOG_LEVEL_DEBUG, "statusList[%d] set to Waiting...", indexToSend);

  APP_LOG(APP_LOG_LEVEL_DEBUG, "Menu index to send: %d", indexToSend);
  dict_write_uint8(dict,KEY_INDEX,indexToSend);
  const uint32_t final_size = dict_write_end(dict);
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Sent message to phone! (%d bytes)", (int) final_size);
  app_message_outbox_send();
}
Beispiel #2
0
static void timer_callback(void *data) {
	DictionaryIterator *iter;
	app_message_outbox_begin(&iter);
	dict_write_uint8(iter, KEY_METHOD, KEY_METHOD_READY);
	dict_write_end(iter);
	app_message_outbox_send();
}
Beispiel #3
0
// Data Request
// Params- char*:request (location/update/lastStopRequest)
static void requestData(char *request) {
    time(&lastUpdate);
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_cstring(iter, 45, request);
    app_message_outbox_send();
}
Beispiel #4
0
void reset_sequence_number() {
    DictionaryIterator *iter = NULL;
    app_message_outbox_begin(&iter);
    if(!iter) return;
    dict_write_int32(iter, SM_SEQUENCE_NUMBER_KEY, 0xFFFFFFFF);
    app_message_outbox_send();
}
Beispiel #5
0
// 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;
  }
}
Beispiel #6
0
static void app_focus_handler(bool in_focus)
{
    // Send App Message Out
    
    DictionaryIterator *iterator;
    
    if (app_message_outbox_begin(&iterator) != APP_MSG_OK)
    {
        return;
    }
    
    if (in_focus)
    {
        if (dict_write_cstring(iterator, MESSAGE_KEY, "IN FOCUS") != DICT_OK)
        {
            return;
        }
    }
    else
    {
        if (dict_write_cstring(iterator, MESSAGE_KEY, "NOT IN FOCUS") != DICT_OK)
        {
            return;
        }
    }
    
    app_message_outbox_send();
}
Beispiel #7
0
/**
 * Sends inbox size to phone as a
 * little-endian byte array of length 4.
 */
void broadcast_inbox_size(uint32_t size) {
    DictionaryIterator *dict;
    app_message_outbox_begin(&dict);
    dict_write_data(dict, INBOX_SIZE_KEY, (uint8_t *)&size, 4);
    dict_write_end(dict);
    app_message_outbox_send();
}
 // 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);
 }
void request_weather(WeatherData *weather_data)
{
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Request weather, retry: %i", retry_count);

  if (retry_count > MAX_RETRY) {
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Too many retries");
    retry_count = 0;
    return;
  }

  if (!bluetooth_connection_service_peek()) {
    weather_data->error = WEATHER_E_DISCONNECTED;
    return;
  }

  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  
  if (iter == NULL) {
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Null iter");
    return;
  }

  dict_write_cstring(iter, KEY_SERVICE, weather_data->service);
  dict_write_cstring(iter, KEY_SCALE, weather_data->scale);
  dict_write_uint8(iter, KEY_DEBUG, (uint8_t)weather_data->debug);
  dict_write_uint8(iter, KEY_BATTERY, (uint8_t)weather_data->battery);

  dict_write_end(iter);

  app_message_outbox_send();
}
void option_picked(int index, void* context)
{
  DictionaryIterator *iterator;
	app_message_outbox_begin(&iterator);	
	
	if(index == 0){
    if (vibrateEnabledStatus == 1){
	    vibrateEnabledStatus = 0;
	  } else {
	    vibrateEnabledStatus = 1;
	  }
	  dict_write_uint8(iterator, 0, 10);
	  dict_write_uint8(iterator, 1, vibrateEnabledStatus);	
	} else if(index == 1){
	  if (inverterEnabledStatus == 1){	  
	    dict_write_uint8(iterator, 0, 11);
	    dict_write_uint8(iterator, 1, 0);	
	  } else {
	    dict_write_uint8(iterator, 0, 11);
	    dict_write_uint8(iterator, 1, 1);	
	  }
	}
	
	app_message_outbox_send();
	app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
	app_comm_set_sniff_interval(SNIFF_INTERVAL_NORMAL);
	
}
Beispiel #11
0
uint8_t getLight(Light *light, GetLightCallback callback)
{
    DictionaryIterator *iter = NULL;
    AppMessageResult result = app_message_outbox_begin(&iter);
    if (result != APP_MSG_OK) {
        app_log(APP_LOG_LEVEL_WARNING, __FILE__, __LINE__, ",unable to send request, status %d", result);
        return false;
    }
    DictionaryResult result2 = dict_write_data(iter, TAG_LIGHT, (uint8_t *)light, sizeof(Light));
    if (result2 != DICT_OK) {
        app_log(APP_LOG_LEVEL_WARNING, __FILE__, __LINE__, ",unable to send data, status %d", result2);
        return false;
    }
    uint16_t r = REQUEST_GET;
    result2 = dict_write_data(iter, TAG_REQUEST_TYPE, (uint8_t *)&r, sizeof(uint16_t));
    if (result2 != DICT_OK) {
        app_log(APP_LOG_LEVEL_WARNING, __FILE__, __LINE__, ",unable to send request, status %d", result2);
        return false;
    }
    result2 = dict_write_data(iter, TAG_ADDRESS, (uint8_t *)&light, sizeof(Light *));
    if (result2 != DICT_OK) {
        app_log(APP_LOG_LEVEL_WARNING, __FILE__, __LINE__, ",unable to send request, status %d", result2);
        return false;
    }
    result2 = dict_write_data(iter, TAG_CALLBACK, (uint8_t *)&callback, sizeof(GetLightCallback));
    if (result2 != DICT_OK) {
        app_log(APP_LOG_LEVEL_WARNING, __FILE__, __LINE__, ",unable to send request, status %d", result2);
        return false;
    }

    app_message_outbox_send();
    return true;
}
Beispiel #12
0
void send_requestx(int slot, int command)
{
	AppMessageResult result;
	DictionaryIterator *dict;
	result = app_message_outbox_begin(&dict);

	if (result == APP_MSG_OK)
	{
		dict_write_uint8(dict, slot, command);
		dict_write_end(dict);
		result = app_message_outbox_send();

		if (result == APP_MSG_OK)
		{
			app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
		}
	}
	else
	{
		current_slot = slot;
		current_command = command;
		if (command_timer == NULL)
		{
			command_timer = app_timer_register(250, handle_resend, NULL);
		}
	}
}
static void select_click_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context) {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Got a click for row %d", cell_index->row);
  if (hint_layer) {
    text_layer_destroy(hint_layer);
    hint_layer = NULL;
  }
  if (cell_index->row > 0) {
    app_timer_reschedule(locationtimer, 1000 * (nextcall + 10));
    if (cell_index->row == 1) {
      strcpy(command, "set");
    text_layer_set_text(distance_layer, "0");
    } else
      snprintf(command, sizeof(command), "set%d", (cell_index->row)-2);
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    if (iter == NULL) {
      vibes_short_pulse();
      APP_LOG(APP_LOG_LEVEL_WARNING, "Can not send command %s to phone!", command);
      return;
    }
    dict_write_cstring(iter, CMD_KEY, command);
    const uint32_t final_size = dict_write_end(iter);
    app_message_outbox_send();
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Sent command '%s' to phone! (%d bytes)", command, (int) final_size);
  }
  window_stack_pop(animated);
}
static void pin_set_handler(ClickRecognizerRef recognizer, void *context) {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Pin set");
  if (hint_layer) {
    text_layer_destroy(hint_layer);
    hint_layer = NULL;
  } 
  else {
    app_timer_reschedule(locationtimer, 1000 * (nextcall + 10));
    strcpy(command, "pin");
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    if (iter == NULL) {
      vibes_short_pulse();
      APP_LOG(APP_LOG_LEVEL_WARNING, "Can not send command %s to phone!", command);
      return;
    }
    dict_write_cstring(iter, CMD_KEY, command);
    const uint32_t final_size = dict_write_end(iter);
    app_message_outbox_send();
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Sent command '%s' to phone! (%d bytes)", command, (int) final_size);
    if (!hint_layer) {
      Layer *window_layer = window_get_root_layer(window);
      hint_layer = text_layer_create(hint_layer_size);
      text_layer_set_font(hint_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
      text_layer_set_text_alignment(hint_layer, GTextAlignmentCenter);
      layer_add_child(window_layer, text_layer_get_layer(hint_layer));
    }
    text_layer_set_text(hint_layer, "\nSetting\ntimeline\npin...");
  }
}
Beispiel #15
0
void play_pause() {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint8(iter, KEY_CMD_EXECUTED,CMD_PLAY_PAUSE);
    dict_write_end(iter);
    app_message_outbox_send();
}
void request_from_phone() {
  // Declare the dictionary's iterator
  DictionaryIterator *out_iter;

  // Prepare the outbox buffer for this message
  AppMessageResult result = app_message_outbox_begin(&out_iter);

  if (result == APP_MSG_OK) {
    // A dummy value
    int value = 0;
  
    // Add an item to ask for weather data
    dict_write_int(out_iter, MESSAGE_KEY_phone_battery, &value, sizeof(int), true);
  } else {
    // The outbox cannot be used right now
    APP_LOG(APP_LOG_LEVEL_ERROR, "Error preparing the outbox: %d", (int)result);
  }

  // Send this message
  result = app_message_outbox_send();
  
  // Check the result
  if (result != APP_MSG_OK) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "Error sending the outbox: %d", (int)result);
  }
}
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();

}
void appmessagecontroller_sendMessage( int key, int value )
{
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  dict_write_uint8(iter, key, value);
  app_message_outbox_send();
}
Beispiel #19
0
static void down_click_handler(ClickRecognizerRef recognizer, void *context) {
	int raceRoundInt = atoi(raceRoundChar);
//	APP_LOG(APP_LOG_LEVEL_DEBUG, "raceRoundChar = %s",  raceRoundChar); 
//	APP_LOG(APP_LOG_LEVEL_DEBUG, "currently round %d", raceRoundInt); 
//	APP_LOG(APP_LOG_LEVEL_DEBUG, "creating new round %d = current round+1", raceRoundInt + 1); 
	text_layer_set_text(round_layer, "getting race");
	raceRoundInt = raceRoundInt + 1; 
	if (raceRoundInt > 19) {
		raceRoundInt = 19; 
		APP_LOG(APP_LOG_LEVEL_DEBUG, "max round reached"); 
	}
		
	//int i;
	char roundRequestChar[] = "123456";
	snprintf(roundRequestChar, sizeof(roundRequestChar), "%d", raceRoundInt);
//	APP_LOG(APP_LOG_LEVEL_DEBUG, "race round string = %%s %s", roundRequestChar);   
	//text_layer_set_text(&countLayer, buf);
	
	//Tuplet request_tuple = TupletCString(REQUEST_KEY, roundRequestChar);
//	Tuplet request_tuple; 
	DictionaryIterator *iter;
	app_message_outbox_begin(&iter);
	
	if (iter == NULL) {
		return; 
	}
	dict_write_cstring(iter, REQUEST_KEY, roundRequestChar);
//	dict_write_tuplet(iter, &request_tuple); 
	dict_write_end(iter); 
	
	app_message_outbox_send(); 
	//send_message(); 
  	//fetch_msg();
}
Beispiel #20
0
static void select_click_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context)
{
  switch(cell_index->row){
    case 0:
      finish_init();
      
      DictionaryIterator *iter;
      app_message_outbox_begin(&iter);
      char * phone_num = (char*)malloc(11 * sizeof(char));
      phone_num[0] = cont_num[0];
      phone_num[1] = cont_num[1];
      phone_num[2] = cont_num[2];
      phone_num[3] = cont_num[4];
      phone_num[4] = cont_num[5];
      phone_num[5] = cont_num[6];
      phone_num[6] = cont_num[8];
      phone_num[7] = cont_num[9];
      phone_num[8] = cont_num[10];
      phone_num[9] = cont_num[11];
      phone_num[10] = '\0';
      Tuplet value = TupletCString(1, phone_num);
      dict_write_tuplet(iter, &value);
      int number = (int)(amount * 10);
      dict_write_int(iter, 2, &number, sizeof(int), 0);
      app_message_outbox_send();
      
      break;
    case 1:
      amount = 0;
      was_back = 1;
      show_home();
      break;
  }
}
void sendScore(uint16_t score)
{
  // Begin dictionary
  DictionaryIterator *iter;
  app_message_outbox_begin(&iter);
  
  // Add a key-value pair
  DictionaryResult result = dict_write_uint16(iter, 1, score);
  switch(result)
  {
    case DICT_OK:
      APP_LOG(APP_LOG_LEVEL_INFO, "nothing went wrong in message construction");
      break;
    case DICT_INVALID_ARGS:
    case DICT_MALLOC_FAILED:
    case DICT_INTERNAL_INCONSISTENCY:
    case DICT_NOT_ENOUGH_STORAGE:
    default:
      APP_LOG(APP_LOG_LEVEL_INFO, "something went wrong in message construction");
      break;
  }
  uint32_t size = dict_write_end(iter);
  APP_LOG(APP_LOG_LEVEL_INFO, "size of dictionary: %u", (unsigned int)size);
  
  // Send the message!
  app_message_outbox_send();
  
}
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;
}
Beispiel #23
0
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);
}
Beispiel #24
0
void read_presets() {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint8(iter, KEY_CMD_EXECUTED,CMD_GET_PRESETS);
    dict_write_end(iter);
    app_message_outbox_send();
}
Beispiel #25
0
void messaging_requestNewWeatherData() {
    // just send an empty message for now
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint32(iter, 0, 0);
    app_message_outbox_send();
}
Beispiel #26
0
void shut_off() {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint8(iter, KEY_CMD_EXECUTED,CMD_SHUT_OFF);
    dict_write_end(iter);
    app_message_outbox_send();
}
Beispiel #27
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();
}
Beispiel #28
0
void next_track() {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint8(iter, KEY_CMD_EXECUTED,CMD_NEXT_TRACK);
    dict_write_end(iter);
    app_message_outbox_send();
}
Beispiel #29
0
static void category_menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context) {
  switch (cell_index->row) {
    case 0:
      // Info Sessions
      info_sessions_window_push();

      // Send AppMessage to get info sessions
      DictionaryIterator *iter;
      app_message_outbox_begin(&iter);
      dict_write_uint8(iter, KEY_GET_DATA, INFO_SESSION);
      dict_write_end(iter);
      app_message_outbox_send();

      break;
    case 1:
      // Lunch Menus
      display_food_menus_action_menu(LUNCH_MENU);

      break;
    case 2:
      // Dinner Menus
      display_food_menus_action_menu(DINNER_MENU);

      break;
  }
}
Beispiel #30
0
static void in_received_handler(DictionaryIterator *iter, void *context) {
  Tuple *tuple;

  // send the launch_arg when we receive ready from JS
  tuple = dict_find(iter, APP_KEY_READY);
  if (tuple) {
    DictionaryIterator *iter;
    app_message_outbox_begin(&iter);
    dict_write_uint32(iter, APP_KEY_ACTION, launch_get_args());
    dict_write_end(iter);
    app_message_outbox_send();
  }

  // update text
  tuple = dict_find(iter, APP_KEY_TEXT);
  if (tuple) {
    snprintf(text, sizeof(text), "%s", tuple->value->cstring);
    text_layer_set_text(text_layer, text);
  }

  // quit the app
  tuple = dict_find(iter, APP_KEY_QUIT);
  if (tuple) {
    window_stack_pop_all(false);
  }
}