void in_received_handler(DictionaryIterator *iter, void *context) {
#ifdef ENABLE_LOGS
APP_LOG(APP_LOG_LEVEL_DEBUG, "Watch: Message received");
#endif
int x = 0;
//processing usernames
for (x=0;x<MAX_NUM_USERS;x++){
Tuple *tuple = dict_find(iter, CONST_FRIEND1+x);
if (tuple){
set_username_for_friend_at_index(tuple->value->cstring,x);
}
}
//processing ids
for (x=0;x<MAX_NUM_USERS;x++){
Tuple *tuple = dict_find(iter, CONST_FRIEND1+x+100);
if (tuple){
set_id_for_friend_at_index(tuple->value->cstring,x);
}
}
//processing number of friends received, this message should be the last one done in JS
Tuple *tuple = dict_find(iter, CONST_FRIENDS_COUNT);
if (tuple){
set_num_friends(tuple->value->int32);
save_cache();
}
//Confirmation of Sending Message
Tuple *tuple2 = dict_find(iter, CONST_STATUS);
if (tuple2){
int error = tuple2->value->int32;
if (error == STYLE_ERROR) {
vibes_long_pulse();
show_message_window(_("Message|Failed"),STYLE_ERROR);
}
else {
vibes_short_pulse();
show_message_window(_("Message|Sent"),STYLE_SUCCESS);
}
}
//Confirmation of Sending Message
Tuple *tuple3 = dict_find(iter, CONST_ERROR_UPDATING_TOKEN);
if (tuple3){
int error = tuple3->value->int32;
if (error == STYLE_ERROR) {
vibes_long_pulse();
show_message_window(_("Failed|to Sync"),STYLE_ERROR);
}
else {
vibes_short_pulse();
show_message_window(_("Sync|Succeed"),STYLE_SUCCESS);
}
}
}
static void handle_vibe(DictionaryIterator *iter, SimplyData *simply) {
Tuple *tuple;
if ((tuple = dict_find(iter, 1))) {
switch ((VibeType) tuple->value->int32) {
case VibeShort: vibes_short_pulse(); break;
case VibeLong: vibes_short_pulse(); break;
case VibeDouble: vibes_double_pulse(); break;
}
}
}
static void vibrate_quarterly_pattern(int minutes) {
if(minutes % 15 == 0) {
vibes_short_pulse();
}
if(minutes % 30 == 0) {
vibes_short_pulse();
}
if(minutes % 45 == 0) {
vibes_short_pulse();
}
}
void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
switch (cell_index->section) {
case 0:
switch (cell_index->row) {
case 0:
if (loading==0) carga_calendario();
break;
case 1:
if (loading==0) carga_fpp();
break;
}
break;
case 1:
switch (cell_index->row) {
case 0:
if (loading==0){
send_int(5,5);
char version[20];
time_t now = time(NULL);
struct tm *tick_time = localtime(&now);
snprintf(version, 20, "Versión: %i-%i-%i",tick_time->tm_mday,(tick_time->tm_mon)+1,(tick_time->tm_year)-100);
vibes_short_pulse();
loading = 0;
layer_mark_dirty(menu_layer_get_layer(menu_layer));
}
break;
}
break;
}
}
static void update_hours(struct tm *tick_time) {
if(appStarted && hourlyvibe) {
//vibe!
vibes_short_pulse();
}
unsigned short display_hour = get_display_hour(tick_time->tm_hour);
set_container_image(&time_digits_images[0], time_digits_layers[0], BIG_DIGIT_IMAGE_RESOURCE_IDS[display_hour/10], GPoint(0, 14)); //n3v3r original 5-> je zahl nun 4 breiter
set_container_image(&time_digits_images[1], time_digits_layers[1], BIG_DIGIT_IMAGE_RESOURCE_IDS[display_hour%10], GPoint(32, 14)); //n3v3r original 33
if (!clock_is_24h_style()) {
if (tick_time->tm_hour >= 12) {
set_container_image(&time_format_image, time_format_layer, RESOURCE_ID_IMAGE_PM_MODE, GPoint(60, 2));
layer_set_hidden(bitmap_layer_get_layer(time_format_layer), false);
}
else {
layer_set_hidden(bitmap_layer_get_layer(time_format_layer), true);
}
if (display_hour/10 == 0) {
layer_set_hidden(bitmap_layer_get_layer(time_digits_layers[0]), true);
}
else {
layer_set_hidden(bitmap_layer_get_layer(time_digits_layers[0]), false);
}
}
}
static void endtrial_callback() {
pause++;
vibes_short_pulse();
end_time = time(NULL);
double elapsed = difftime(end_time, start_time);
result = (int)floor(sum_x/elapsed);
display(text_layer_3, "Final: %d", result);
action_bar_layer_set_icon(s_action_bar, BUTTON_ID_SELECT, s_icon_play);
int calib_stored = persist_exists(CALIB_PKEY) ? persist_read_int(CALIB_PKEY) : CALIB_DEFAULT;
if (result > 2*calib_stored) {
send(0,1);
text_layer_set_text(text_layer_1, "YOU'RE DRUNK");
text_layer_set_text(text_layer_4, "");
dialog_message_window_push();
}
else {
send(0,0);
text_layer_set_text(text_layer_1, "YOU'RE FINE");
text_layer_set_text(text_layer_2, "");
text_layer_set_text(text_layer_4, "");
}
}
/*
* Handle an up or down button press and validate results
*/
static void up_down_handler(int8_t delta) {
switch (current_field) {
case F_FROM_HOUR:
case F_TO_HOUR:
alter_time(current_field, delta, 23, 0);
break;
case F_FROM_MINUTE:
case F_TO_MINUTE:
alter_time(current_field, 5 * delta, 55, 0);
break;
case F_SMART_ALARM:
alter_time(current_field, 1, 1, 0);
break;
case F_DONE:
if (values[F_DONE] == 1)
hide_set_alarm();
else
vibes_short_pulse();
break;
}
uint32_t from = to_mins(values[F_FROM_HOUR], values[F_FROM_MINUTE]);
uint32_t to = to_mins(values[F_TO_HOUR], values[F_TO_MINUTE]);
values[F_DONE] = (from <= to);
write_values_to_fields();
}
void inbox(DictionaryIterator *iter, void *context){
Tuple *t = dict_read_first(iter);
if(t) process_tuple(t);
while(t != NULL){
t = dict_read_next(iter);
if(t) process_tuple(t);
}
if(current == INIT){
current = SPLASH;
}
else if(current == SPLASH){
current = HOME;
window_stack_push(home_window, true);
window_stack_remove(splash_window, false);
}
else if(current == LOADING){
push_appropriate_window();
}
else if(current == MATCHUP){
//APP_LOG(APP_LOG_LEVEL_INFO, "Old Ally: %d, Old Enemy: %d. Ally: %d, Enemy: %d.", old_matchup_ally_score_int,old_matchup_enemy_score_int,matchup_ally_score_int,matchup_enemy_score_int);
if( (old_matchup_ally_score_int > old_matchup_enemy_score_int && matchup_ally_score_int < matchup_enemy_score_int)
|| (old_matchup_ally_score_int < old_matchup_enemy_score_int && matchup_ally_score_int > matchup_enemy_score_int)
|| (old_matchup_ally_score_int == 0 && old_matchup_enemy_score_int == 0 && (matchup_ally_score_int != 0 || matchup_enemy_score_int != 0)))
{
vibes_short_pulse();
}
old_matchup_ally_score_int = matchup_ally_score_int;
old_matchup_enemy_score_int = matchup_enemy_score_int;
layer_mark_dirty(matchup_custom_layer);
}
}
static void timer_callback(struct tm *tick_time, TimeUnits units_changed) {
if (state.round_time == 0) {
if (state.stretch && stretch_settings.prepare != 0) {
state.round++;
state.round_time = stretch_settings.prepare;
vibes_long_pulse();
text_layer_set_text(ui.top_text, "Prepare");
state.stretch = 0;
} else {
if (stretch_settings.prepare == 0) {
state.round++;
}
state.round_time = stretch_settings.time;
vibes_short_pulse();
text_layer_set_text(ui.top_text, "Stretch");
state.stretch = 1;
}
update_ui();
}
if (state.running) {
update_time_ui();
}
}
bool ComputeRandomEvent(bool fastMode)
{
uint16_t chanceOfEvent = EVENT_CHANCE_BASE;
#if EVENT_CHANCE_SCALING
if(ticksSinceLastEvent > 3) {
chanceOfEvent += (ticksSinceLastEvent - 2) * 4;
}
#endif
if(!fastMode) {
uint16_t result = Random(100) + 1;
if(result > chanceOfEvent) {
if(Random(4) == 1) {
HealStamina(1);
}
return false;
}
}
if(GetVibration())
vibes_short_pulse();
ComputeAdventure();
#if EVENT_CHANCE_SCALING
ticksSinceLastEvent = 0;
#endif
return true;
}
static void update_hours(struct tm *tick_time) {
if (appStarted && hourlyvibe) {
//vibe!
vibes_short_pulse();
}
unsigned short display_hour = get_display_hour(tick_time->tm_hour);
set_container_image(&normal_time_digits_images[0], normal_time_digits_layers[0], NORMAL_IMAGE_RESOURCE_IDS[display_hour/10], GPoint(0, 40));
set_container_image(&normal_time_digits_images[1], normal_time_digits_layers[1], NORMAL_IMAGE_RESOURCE_IDS[display_hour%10], GPoint(34, 40));
if (!clock_is_24h_style()) {
if (display_hour/10 == 0) {
layer_set_hidden(bitmap_layer_get_layer(normal_time_digits_layers[0]), true);
} else if (flip == 0) {
layer_set_hidden(bitmap_layer_get_layer(normal_time_digits_layers[0]), false);
}
}
static char ampm_text[] = "am";
if (!clock_is_24h_style()) {
strftime(ampm_text, sizeof(ampm_text), "%P", tick_time);
text_layer_set_text(layer_ampm_text, ampm_text);
}
}
static void toggle_bluetooth_icon(bool connected) {
if(appStarted && !connected && bluetoothvibe) {
//vibe!
vibes_short_pulse();
}
layer_set_hidden(bitmap_layer_get_layer(bluetooth_layer), connected);
}
static void handle_tick(struct tm *t, TimeUnits units_changed) {
if (strcmp(configs.secondhandoption, "stop2go") == 0) {
for (int i=0; i<STOP2GO_TICK_RESOLUTION; i++) {
app_timer_register(1000 / STOP2GO_TICK_RESOLUTION * i, (void*)layer_mark_dirty, window_get_root_layer(s_window));
}
}
else {
layer_mark_dirty(window_get_root_layer(s_window));
}
// Hourly vibration
if (t->tm_min == 0 && t->tm_sec == 0) {
if (strcmp(configs.hourlyvibration, "short") == 0) {
vibes_short_pulse();
}
else if (strcmp(configs.hourlyvibration, "long") == 0) {
vibes_long_pulse();
}
else if (strcmp(configs.hourlyvibration, "double") == 0) {
vibes_double_pulse();
}
}
}
static void tick(struct tm *tick_time, TimeUnits units_changed)
{
if (s_second_rate < 2)
{
layer_mark_dirty(s_date_layer);
layer_mark_dirty(s_time_layer);
}
if (tick_time->tm_min == 0 && tick_time->tm_sec == 0 && s_vibe_hourly != SETTING_VIBE_DISABLED)
{
switch (s_vibe_hourly)
{
case SETTING_VIBE_LONG:
vibes_long_pulse();
break;
case SETTING_VIBE_SHORT:
vibes_short_pulse();
break;
case SETTING_VIBE_DOUBLE:
vibes_double_pulse();
break;
}
}
// Get weather update every 2 hours
if (s_weather_icon == -1 || s_weather_temp == -100 || tick_time->tm_mday*100+tick_time->tm_hour > s_last_update_time + 1)
{
request_weather();
}
if(tick_time->tm_hour % 2 == 0 && tick_time->tm_min == 0 && tick_time->tm_sec == 0)
{
request_weather();
}
}
void bluetoothHandler(bool connected)
{
APP_LOG(DebugLevel, "bluetoothHandler: start connected :%s:",connected ? "true" : "false");
bool prevConnected=false;
if(persist_exists(BT_STATUS)){
prevConnected = persist_read_bool(BT_STATUS);
APP_LOG(DebugLevel, "bluetoothHandler: initial key");
}
APP_LOG(DebugLevel, "bluetoothHandler: prevConnected :%s:",prevConnected ? "true" : "false");
if(connected && prevConnected) {
bitmap_layer_set_bitmap(GET_LAYER(BLUETOOTH_LAYER), bluetoothImageOn);
APP_LOG(DebugLevel, "bluetoothHandler: both true turned on connection");
}
if(!connected && !prevConnected) {
bitmap_layer_set_bitmap(GET_LAYER(BLUETOOTH_LAYER), bluetoothImageOff);
APP_LOG(DebugLevel, "bluetoothHandler: both false turned off connection");
}
if(connected && !prevConnected) {
bitmap_layer_set_bitmap(GET_LAYER(BLUETOOTH_LAYER), bluetoothImageOn);
APP_LOG(DebugLevel, "bluetoothHandler: turned on connection");
vibes_short_pulse();
}
if(!connected && prevConnected) {
bitmap_layer_set_bitmap(GET_LAYER(BLUETOOTH_LAYER), bluetoothImageOff);
APP_LOG(DebugLevel, "bluetoothHandler: turned off connection");
vibes_long_pulse();
btBuzzerTimer = app_timer_register(BUZZER_INTERVAL, buzzer2,NULL);
}
persist_write_bool(BT_STATUS, connected);
APP_LOG(DebugLevel, "bluetoothHandler: done saved :%s:",connected ? "true" : "false");
} // bluetoothHandler
void vibrate_quarterly() {
// load settings
ElCidSettings *settings = settings_load();
// don't vibrate if not set
if(!settings->QuarterHourlyVibrate) {
return;
}
// get hour from local time
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
// create pattern for vibration
int minutes = tick_time->tm_min;
// abort if not on the quarter hour
if(minutes == 0 || minutes % 15 != 0) {
return;
}
// get settings value after we know we need it
u_short vibration_type = settings->QuarterHourVibrationType;
// do pattern as configured
if(1 == vibration_type) {
vibes_short_pulse();
} else if(2 == vibration_type) {
vibes_long_pulse();
} else if(3 == vibration_type) {
vibes_double_pulse();
} else if(4 == vibration_type) {
vibrate_quarterly_pattern(minutes);
}
}
void handle_timer(AppContextRef ctx, AppTimerHandle handle, uint32_t cookie) {
(void)handle;
if(cookie == TIMER_UPDATE) {
if(started) {
remaining_time -= 1;
if (remaining_time == 0){
if (working_mode){
vibes_short_pulse();
}
else{
vibes_double_pulse();
}
start_timer(SHORT_TIMER_DELAY);
}else{
if (remaining_time < 0){
if (working_mode){
reset_relax_count_down();
}
else{
reset_work_count_down();
}
}else{
display_time();
}
start_timer(TIMER_DELAY);
}
}
}
}
void check_vibration(char *mode) {
if (strcmp(mode, MODE_LONG) == 0) {
vibes_long_pulse();
} else if (strcmp(mode, MODE_SHORT) == 0) {
vibes_short_pulse();
}
}
void calibrate_accel_end( bool keepData) {
int tries = 0;
vibes_short_pulse();
accel_data_service_unsubscribe();
if (keepData) {
thresholdUp -= (thresholdUp>>2);
// threshold set to 75% of max value: x - x/4, down = x'/2
while ((periodsSki != 3) && (tries < MAXCALIBTRY)) {
tries++;
// threshold set to 75% of max value: x - x/4, down = x'/2
// thresholdDown = thresholdUp>>1;
periodsLift = calibrationCount;
periodsSki = strokesDetected( calibrationSamples, calibrationCount);
periodsStatic = thresholdUp;
lastAccel.timestamp = 0;
app_log(APP_LOG_LEVEL_INFO, __FILE__ , __LINE__, "Calib detected: %i", (int)periodsSki);
if (periodsSki > 3) thresholdUp += thresholdUp>>3;
if (periodsSki < 3) thresholdUp -= thresholdUp>>3;
}
if (periodsSki != 3) {
thresholdUp = MOVINGTHRESHOLD;
thresholdDown = STATICTHRESHOLD;
}
persist_write_int(THUPKEY, thresholdUp);
persist_write_int(THDOWNKEY, thresholdUp>>1);
}
else
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...");
}
}
void main_window_set_status( bool connected )
{
if ( LOCAL_last_status == connected )
return;
if ( LOCAL_last_status >= 0 )
vibes_short_pulse();
LOCAL_last_status = connected;
GColor front = GColorWhite;
GColor back = GColorBlack;
if ( connected == true )
{
back = GColorWhite;
front = GColorBlack;
}
for ( int loop = 0; loop < 4; loop ++ )
{
text_layer_set_background_color( LOCAL_layers[loop], back );
text_layer_set_text_color( LOCAL_layers[loop] , front );
}
}
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 inbox_received_handler(DictionaryIterator *iter, void *context) {
Tuple *show_seconds_hand_t = dict_find(iter, KEY_SHOW_SECONDS_HAND);
Tuple *connection_lost_vibe_t = dict_find(iter, KEY_CONNECTION_LOST_VIBE);
Tuple *color_reverse_t = dict_find(iter, KEY_COLOR_REVERSE);
if (show_seconds_hand_t) {
s_show_seconds_hand = show_seconds_hand_t->value->int8;
persist_write_bool(KEY_SHOW_SECONDS_HAND, s_show_seconds_hand);
APP_LOG(APP_LOG_LEVEL_DEBUG, "s_show_seconds_hand %d", s_show_seconds_hand);
//vibes_short_pulse();
}
if (connection_lost_vibe_t) {
s_connection_lost_vibe = connection_lost_vibe_t->value->int8;
persist_write_bool(KEY_CONNECTION_LOST_VIBE, s_connection_lost_vibe);
APP_LOG(APP_LOG_LEVEL_DEBUG, "s_connection_lost_vibe %d", s_connection_lost_vibe);
vibes_short_pulse();
}
if (color_reverse_t) {
s_color_reverse = color_reverse_t->value->int8;
persist_write_bool(KEY_COLOR_REVERSE, s_color_reverse);
APP_LOG(APP_LOG_LEVEL_DEBUG, "s_color_reverse %d", s_color_reverse);
set_color_data();
set_layer_color();
}
}
static void counter_timeout(void)
{
//Create variable to store count, down from 3
static int8_t count = 3;
static char count_str[] = " ";
count--;
if (0 == count)
{
//reset the counter for next time,
app_timer_cancel(s_counter_timer);
count = 3;
//Alert chugger with short vibration
vibes_short_pulse();
//Start Accelerometer service
uint32_t num_samples = 5;
accel_data_service_subscribe(num_samples, data_handler);
accel_service_set_sampling_rate(ACCEL_SAMPLING_100HZ);
}
else
{
SINGLE_DIGIT_TO_ASCII(count, count_str);
text_layer_set_text(s_count_layer, count_str);
app_timer_register(1000, (AppTimerCallback) counter_timeout, NULL);
}
}
/*
static void send(int key, int msg)
{
DictionaryIterator *iter;
app_message_outbox_begin(&iter);
dict_write_int(iter, key, &msg, sizeof(int), true);
app_message_outbox_send();
}
*/
static void inbox_received_handler(DictionaryIterator *iterator, void *context) {
// Get the first pair
Tuple *t = dict_read_first(iterator);
// Process all pairs present
while(t != NULL) {
// Process this pair's key
switch(t->key) {
case KEY_VIBRATE:
// Trigger vibration
text_layer_set_text(s_text_layer, "Vibrate!");
vibes_short_pulse();
break;
case KEY_DISTANCE:
// When distance recieved set text to distance
text_layer_set_text(s_text_layer,"Distance: ");
break;
case KEY_ETA:
text_layer_set_text(s_text_layer,"ETA:");
break;
default:
APP_LOG(APP_LOG_LEVEL_INFO, "Unknown key: %d", (int)t->key);
break;
}
// Get next pair, if any
t = dict_read_next(iterator);
}
}
static void handle_bluetooth(bool connected)
{
if(!connected)
{
if(vibrate) vibes_short_pulse();
}
}
// App message callbacks
void out_sent_handler(DictionaryIterator *sent, void *context)
{
//APP_LOG(APP_LOG_LEVEL_INFO, "command sent");
vibes_short_pulse();
start_reset_timer();
}
static void update_time() {
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
min = tick_time->tm_min;
if(min == 59 && hour_vibrate == 1){
vibes_short_pulse();
}
if (clock_is_24h_style() == twenty_four_hour_format){
strftime(buffer, sizeof(buffer), "%H:%M", tick_time);
}else {
strftime(buffer, sizeof(buffer), "%I:%M", tick_time);
}
if(change_date_format == 1){
strftime(date, sizeof(date),"%d/%m/%y", tick_time);
} else{
strftime(date, sizeof(date),"%D", tick_time);
}
strftime(weekday, sizeof(weekday),"%A", tick_time);
for(char* pc=weekday;*pc!=0;++pc) *pc = lower_to_upper(*pc);
text_layer_set_text(lower_text_layer, date);
text_layer_set_text(upper_text_layer, buffer);
battery_handler(battery_state_service_peek());
}
static void tick_handler(struct tm *tick_time, TimeUnits units_changed) {
static char s_uptime_buffer[32];
vibes_short_pulse();
alert_time--;
if(alert_time <= 0 ){
//TODO: write notification code
tick_timer_service_unsubscribe();
vibes_cancel();
text_layer_set_text(s_alert_text_layer, "Timout Reached\n:(");
// Prepare dictionary
DictionaryIterator *iterator;
app_message_outbox_begin(&iterator);
// Write data
char buff[100];
if(persist_exists(PERSIST_KEY_PHONE_NUMBER)){
persist_read_string(PERSIST_KEY_PHONE_NUMBER, buff, 100);
dict_write_cstring(iterator, PERSIST_KEY_PHONE_NUMBER, buff);
}
if(persist_exists(PERSIST_KEY_NAME)){
persist_read_string(PERSIST_KEY_NAME, buff, 100);
dict_write_cstring(iterator, PERSIST_KEY_NAME, buff);
}
// Send the data!
app_message_outbox_send();
} else {
snprintf(s_uptime_buffer, sizeof(s_uptime_buffer), BANNER_TEXT "\n" CLOCK_FORMAT_STRING,
alert_time/60, alert_time%60);
text_layer_set_text(s_alert_text_layer, s_uptime_buffer);
}
}
void calibrate_handle_final(Measurement m) {
// store the measurement
// check if same weight already exists and average both if it does
Measurement *mf = NULL;
for (int i = 0; i < calibrations_count; i++) {
if (calibrations[i].weight != weight)
continue;
mf = &calibrations[i];
mf->amp = (mf->amp + m.amp) / 2;
mf->freq = (mf->freq + m.freq) / 2;
mf->confidence = (mf->confidence + m.confidence) / 2;
break;
}
if (mf == NULL) {
m.weight = weight;
calibrations[calibrations_count++] = m;
}
// store
calibrations_save();
// stop measuring and update layers
stop_measure();
layer_mark_dirty(text_layer);
layer_mark_dirty(graph_layer);
// vibrate to let the user know
vibes_short_pulse();
}
