mirror of
https://github.com/google/pebble.git
synced 2025-03-22 11:42:19 +00:00
2967 lines
120 KiB
C
2967 lines
120 KiB
C
|
/*
|
||
|
|
* Copyright 2024 Google LLC
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "applib/accel_service.h"
|
||
|
|
#include "applib/data_logging.h"
|
||
|
|
#include "applib/health_service.h"
|
||
|
|
#include "applib/health_service_private.h"
|
||
|
|
#include "drivers/rtc.h"
|
||
|
|
#include "drivers/vibe.h"
|
||
|
|
#include "kernel/events.h"
|
||
|
|
#include "services/common/hrm/hrm_manager_private.h"
|
||
|
|
#include "services/normal/activity/activity.h"
|
||
|
|
#include "services/normal/activity/activity_algorithm.h"
|
||
|
|
#include "services/normal/activity/activity_private.h"
|
||
|
|
#include "services/normal/activity/kraepelin/activity_algorithm_kraepelin.h"
|
||
|
|
#include "services/normal/data_logging/data_logging_service.h"
|
||
|
|
#include "services/normal/filesystem/pfs.h"
|
||
|
|
#include "services/normal/protobuf_log/protobuf_log.h"
|
||
|
|
#include "shell/prefs.h"
|
||
|
|
#include "system/logging.h"
|
||
|
|
#include "system/passert.h"
|
||
|
|
#include "util/math.h"
|
||
|
|
#include "util/size.h"
|
||
|
|
|
||
|
|
#include <sys/stat.h>
|
||
|
|
|
||
|
|
#include "clar.h"
|
||
|
|
|
||
|
|
#ifndef PATH_MAX
|
||
|
|
#define PATH_MAX 4096
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
// Stubs
|
||
|
|
#include "stubs_activity_insights.h"
|
||
|
|
#include "stubs_alarm.h"
|
||
|
|
#include "stubs_app_manager.h"
|
||
|
|
#include "stubs_analytics.h"
|
||
|
|
#include "stubs_app_install_manager.h"
|
||
|
|
#include "stubs_battery.h"
|
||
|
|
#include "stubs_freertos.h"
|
||
|
|
#include "stubs_health_db.h"
|
||
|
|
#include "stubs_hexdump.h"
|
||
|
|
#include "stubs_i18n.h"
|
||
|
|
#include "stubs_logging.h"
|
||
|
|
#include "stubs_mutex.h"
|
||
|
|
#include "stubs_passert.h"
|
||
|
|
#include "stubs_pebble_process_info.h"
|
||
|
|
#include "stubs_prompt.h"
|
||
|
|
#include "stubs_sleep.h"
|
||
|
|
#include "stubs_system_theme.h"
|
||
|
|
#include "stubs_task_watchdog.h"
|
||
|
|
#include "stubs_worker_manager.h"
|
||
|
|
#include "stubs_workout_service.h"
|
||
|
|
|
||
|
|
// Fakes
|
||
|
|
#include "fake_accel_service.h"
|
||
|
|
#include "fake_cron.h"
|
||
|
|
#include "fake_events.h"
|
||
|
|
#include "fake_new_timer.h"
|
||
|
|
#include "fake_pbl_std.h"
|
||
|
|
#include "fake_rtc.h"
|
||
|
|
#include "fake_spi_flash.h"
|
||
|
|
#include "fake_system_task.h"
|
||
|
|
|
||
|
|
|
||
|
|
// We start time out at 5pm on Jan 1, 2015 for all of these tests
|
||
|
|
static const struct tm s_init_time_tm = {
|
||
|
|
// Thursday, Jan 1, 2015, 5:pm
|
||
|
|
.tm_hour = 17,
|
||
|
|
.tm_mday = 1,
|
||
|
|
.tm_mon = 0,
|
||
|
|
.tm_year = 115
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
#define ACTIVITY_FIXTURE_PATH "activity"
|
||
|
|
|
||
|
|
// The expected resting kcalories is determined empirically from a known good commmit and
|
||
|
|
// is based on the current time of day and the user's weight, age etc.
|
||
|
|
const int s_exp_5pm_resting_kcalories = 1031;
|
||
|
|
const int s_exp_full_day_resting_kcalories = 1455;
|
||
|
|
|
||
|
|
// Stub for health tracking disabled UI
|
||
|
|
void health_tracking_ui_feature_show_disabled(void) { }
|
||
|
|
void health_tracking_ui_app_show_disabled(void) { }
|
||
|
|
|
||
|
|
// These are declared as T_STATIC in activity.c
|
||
|
|
void prv_hrm_subscription_cb(PebbleHRMEvent *hrm_event, void *context);
|
||
|
|
void prv_minute_system_task_cb(void *data);
|
||
|
|
|
||
|
|
bool mfg_info_is_hrm_present(void) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void hrm_manager_handle_prefs_changed(void) { }
|
||
|
|
|
||
|
|
#define ASSERT_EQUAL_I(i1,i2,file,line) \
|
||
|
|
clar__assert_equal_i((i1),(i2),file,line,#i1 " != " #i2, 1)
|
||
|
|
|
||
|
|
// ======================================================================================
|
||
|
|
// Misc stubs
|
||
|
|
static HealthServiceState s_health_service;
|
||
|
|
|
||
|
|
HealthServiceState *app_state_get_health_service_state(void) {
|
||
|
|
return &s_health_service;
|
||
|
|
}
|
||
|
|
|
||
|
|
HealthServiceState *worker_state_get_health_service_state(void) {
|
||
|
|
cl_fail("should never be called");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void event_service_client_subscribe(EventServiceInfo * service_info) {}
|
||
|
|
void event_service_client_unsubscribe(EventServiceInfo * service_info) {}
|
||
|
|
|
||
|
|
void sys_send_pebble_event_to_kernel(PebbleEvent* event) {}
|
||
|
|
|
||
|
|
|
||
|
|
static UnitsDistance s_units_distance_result;
|
||
|
|
|
||
|
|
UnitsDistance sys_shell_prefs_get_units_distance(void) {
|
||
|
|
return s_units_distance_result;
|
||
|
|
}
|
||
|
|
|
||
|
|
int32_t vibes_get_vibe_strength(void) {
|
||
|
|
return VIBE_STRENGTH_OFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRMSessionRef s_hrm_next_session_ref = 1;
|
||
|
|
static uint32_t s_hrm_manager_update_interval;
|
||
|
|
static int s_hrm_manager_num_update_interval_changes;
|
||
|
|
static uint16_t s_hrm_manager_expire_s;
|
||
|
|
HRMSessionRef hrm_manager_subscribe_with_callback(AppInstallId app_id, uint32_t update_interval_s,
|
||
|
|
uint16_t expire_s, HRMFeature features,
|
||
|
|
HRMSubscriberCallback callback, void *context) {
|
||
|
|
s_hrm_manager_update_interval = update_interval_s;
|
||
|
|
s_hrm_manager_expire_s = expire_s;
|
||
|
|
return s_hrm_next_session_ref++;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool sys_hrm_manager_unsubscribe(HRMSessionRef session) {
|
||
|
|
cl_assert(session < s_hrm_next_session_ref);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool sys_hrm_manager_set_update_interval(HRMSessionRef session, uint32_t update_interval_s,
|
||
|
|
uint16_t expire_s) {
|
||
|
|
cl_assert(session < s_hrm_next_session_ref);
|
||
|
|
s_hrm_manager_update_interval = update_interval_s;
|
||
|
|
s_hrm_manager_expire_s = expire_s;
|
||
|
|
s_hrm_manager_num_update_interval_changes++;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRMSessionRef sys_hrm_manager_app_subscribe(AppInstallId app_id, uint32_t update_interval_s,
|
||
|
|
uint16_t expire_s, HRMFeature features) {
|
||
|
|
return HRM_INVALID_SESSION_REF;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRMSessionRef sys_hrm_manager_get_app_subscription(AppInstallId app_id) {
|
||
|
|
return HRM_INVALID_SESSION_REF;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool sys_hrm_manager_get_subscription_info(HRMSessionRef session, AppInstallId *app_id,
|
||
|
|
uint32_t *update_interval_s, uint16_t *expire_s,
|
||
|
|
HRMFeature *features) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
AppInstallId app_get_app_id(void) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ======================================================================================
|
||
|
|
// Queue stubs, to support the semaphore that activity.c uses to block on a kernel BG callback
|
||
|
|
#define QUEUE_HANDLE ((QueueHandle_t)0x11)
|
||
|
|
int s_queue_value = 0;
|
||
|
|
|
||
|
|
signed portBASE_TYPE xQueueGenericReceive(QueueHandle_t xQueue, void * const pvBuffer,
|
||
|
|
TickType_t xTicksToWait, portBASE_TYPE xJustPeeking) {
|
||
|
|
while (s_queue_value <= 0) {
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
s_queue_value--;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
signed portBASE_TYPE xQueueGenericSend(QueueHandle_t xQueue, const void * const pvItemToQueue,
|
||
|
|
TickType_t xTicksToWait, portBASE_TYPE xCopyPosition) {
|
||
|
|
PBL_ASSERTN(xQueue == QUEUE_HANDLE);
|
||
|
|
s_queue_value++;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
QueueHandle_t xQueueGenericCreate(unsigned portBASE_TYPE uxQueueLength,
|
||
|
|
unsigned portBASE_TYPE uxItemSize, unsigned char ucQueueType) {
|
||
|
|
return QUEUE_HANDLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// =============================================================================================
|
||
|
|
// Data logging stubs
|
||
|
|
typedef enum {
|
||
|
|
DataLoggingSession_AccelSamples = 1,
|
||
|
|
DataLoggingSession_ActivitySessions = 2,
|
||
|
|
} DataLoggingSession_ID;
|
||
|
|
|
||
|
|
|
||
|
|
// Logged items
|
||
|
|
static bool s_dls_accel_samples_created;
|
||
|
|
static int s_num_dls_accel_records;
|
||
|
|
static ActivityRawSamplesRecord s_dls_accel_records[100];
|
||
|
|
|
||
|
|
static bool s_dls_activity_sessions_created;
|
||
|
|
static int s_num_dls_activity_records;
|
||
|
|
static ActivitySessionDataLoggingRecord s_dls_activity_records[100];
|
||
|
|
|
||
|
|
static void prv_reset_captured_dls_data(void) {
|
||
|
|
s_num_dls_accel_records = 0;
|
||
|
|
s_num_dls_activity_records = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
DataLoggingResult dls_log(DataLoggingSession *logging_session, const void *data,
|
||
|
|
uint32_t num_items) {
|
||
|
|
if (logging_session == (DataLoggingSession *)DataLoggingSession_AccelSamples) {
|
||
|
|
cl_assert(s_dls_accel_samples_created);
|
||
|
|
|
||
|
|
ActivityRawSamplesRecord *records = (ActivityRawSamplesRecord *)data;
|
||
|
|
for (int i = 0; i < num_items; i++) {
|
||
|
|
cl_assert(s_num_dls_accel_records < ARRAY_LENGTH(s_dls_accel_records));
|
||
|
|
s_dls_accel_records[s_num_dls_accel_records++] = records[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
} else if (logging_session == (DataLoggingSession *) DataLoggingSession_ActivitySessions) {
|
||
|
|
cl_assert(s_dls_activity_sessions_created);
|
||
|
|
|
||
|
|
ActivitySessionDataLoggingRecord *records = (ActivitySessionDataLoggingRecord *)data;
|
||
|
|
for (int i = 0; i < num_items; i++) {
|
||
|
|
if (s_num_dls_activity_records >= 100) {
|
||
|
|
cl_assert(false);
|
||
|
|
}
|
||
|
|
cl_assert(s_num_dls_activity_records < ARRAY_LENGTH(s_dls_activity_records));
|
||
|
|
s_dls_activity_records[s_num_dls_activity_records++] = records[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
return DATA_LOGGING_INVALID_PARAMS;
|
||
|
|
}
|
||
|
|
|
||
|
|
return DATA_LOGGING_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
DataLoggingSession *dls_create(uint32_t tag, DataLoggingItemType item_type, uint16_t item_size,
|
||
|
|
bool buffered, bool resume, const Uuid *uuid) {
|
||
|
|
if (tag == DlsSystemTagActivityAccelSamples) {
|
||
|
|
s_dls_accel_samples_created = true;
|
||
|
|
cl_assert_equal_i(item_size, sizeof(ActivityRawSamplesRecord));
|
||
|
|
return (DataLoggingSession *)DataLoggingSession_AccelSamples;
|
||
|
|
|
||
|
|
} else if (tag == DlsSystemTagActivitySession) {
|
||
|
|
s_dls_activity_sessions_created = true;
|
||
|
|
cl_assert_equal_i(item_size, sizeof(ActivitySessionDataLoggingRecord));
|
||
|
|
return (DataLoggingSession *) DataLoggingSession_ActivitySessions;
|
||
|
|
|
||
|
|
} else {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void dls_finish(DataLoggingSession *logging_session) {
|
||
|
|
if (logging_session == (DataLoggingSession *)DataLoggingSession_AccelSamples) {
|
||
|
|
s_dls_accel_samples_created = false;
|
||
|
|
} else if (logging_session == (DataLoggingSession *) DataLoggingSession_ActivitySessions) {
|
||
|
|
s_dls_activity_sessions_created = false;
|
||
|
|
} else {
|
||
|
|
cl_assert(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// =================================================================================
|
||
|
|
// Measurement logging stubs
|
||
|
|
ProtobufLogRef protobuf_log_hr_create(void) {
|
||
|
|
return (ProtobufLogRef)1;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool protobuf_log_session_delete(ProtobufLogRef session) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool protobuf_log_hr_add_sample(ProtobufLogRef ref, time_t now_utc, uint8_t bpm,
|
||
|
|
HRMQuality quality) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// =============================================================================================
|
||
|
|
// Assertion utilities
|
||
|
|
// --------------------------------------------------------------------------------------
|
||
|
|
static void prv_assert_equal_metric_history(ActivityMetric metric,
|
||
|
|
const uint32_t expected[ACTIVITY_HISTORY_DAYS],
|
||
|
|
char* file, int line) {
|
||
|
|
int32_t actual[ACTIVITY_HISTORY_DAYS];
|
||
|
|
activity_get_metric(metric, ACTIVITY_HISTORY_DAYS, actual);
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
ASSERT_EQUAL_I(actual[i], expected[i], file, line);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#define ASSERT_EQUAL_METRIC_HISTORY(metric, expected) \
|
||
|
|
prv_assert_equal_metric_history((metric), (expected), __FILE__, __LINE__)
|
||
|
|
|
||
|
|
|
||
|
|
static void prv_assert_dls_activity_record_present(ActivitySessionDataLoggingRecord *record,
|
||
|
|
char *file, int line) {
|
||
|
|
for (int i = 0; i < s_num_dls_activity_records; i++) {
|
||
|
|
if (!memcmp(record, &s_dls_activity_records[i], sizeof(*record))) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
printf("\nFound records:");
|
||
|
|
for (int i = 0; i < s_num_dls_activity_records; i++) {
|
||
|
|
printf("\ntype: %d, start_utc: %"PRIu32", elapsed: %"PRIu32", utc_to_local: %"PRIu32" ",
|
||
|
|
(int)s_dls_activity_records[i].activity, (uint32_t)s_dls_activity_records[i].start_utc,
|
||
|
|
s_dls_activity_records[i].elapsed_sec, s_dls_activity_records[i].utc_to_local);
|
||
|
|
}
|
||
|
|
printf("\nLooking for: type: %d, start_utc: %"PRIu32", elapsed: %"PRIu32", "
|
||
|
|
"utc_to_local: %"PRIu32" ", (int)record->activity, (uint32_t)record->start_utc,
|
||
|
|
record->elapsed_sec, record->utc_to_local);
|
||
|
|
clar__assert(false, file, line, "Missing activity record", "", true);
|
||
|
|
}
|
||
|
|
|
||
|
|
#define ASSERT_ACTIVITY_DLS_RECORD_PRESENT(record) \
|
||
|
|
prv_assert_dls_activity_record_present((record), __FILE__, __LINE__)
|
||
|
|
|
||
|
|
|
||
|
|
// Assert that given number of activity sessions are present
|
||
|
|
static void prv_assert_num_activities(uint32_t num_expected, char *file, int line) {
|
||
|
|
ActivitySession sessions[ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT];
|
||
|
|
uint32_t num_sessions = ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT;
|
||
|
|
activity_get_sessions(&num_sessions, sessions);
|
||
|
|
if (num_sessions != num_expected) {
|
||
|
|
printf("Expected %"PRIu32" activities, but found %"PRIu32".\n", num_expected, num_sessions);
|
||
|
|
}
|
||
|
|
clar__assert(num_sessions == num_expected, file, line, "wrong number of activities", "", true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Assert that a particular step activity session is present in the sessions list
|
||
|
|
static void prv_assert_step_activity_present(ActivitySession *exp_session, char *file, int line) {
|
||
|
|
ActivitySession sessions[ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT];
|
||
|
|
uint32_t num_sessions = ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT;
|
||
|
|
activity_get_sessions(&num_sessions, sessions);
|
||
|
|
for (int i = 0; i < num_sessions; i++) {
|
||
|
|
if (sessions[i].type == exp_session->type
|
||
|
|
&& sessions[i].start_utc == exp_session->start_utc
|
||
|
|
&& sessions[i].length_min == exp_session->length_min
|
||
|
|
&& sessions[i].step_data.active_kcalories == exp_session->step_data.active_kcalories
|
||
|
|
&& sessions[i].step_data.resting_kcalories == exp_session->step_data.resting_kcalories
|
||
|
|
&& sessions[i].step_data.distance_meters == exp_session->step_data.distance_meters
|
||
|
|
&& sessions[i].step_data.steps == exp_session->step_data.steps) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
printf("\nFound activities:");
|
||
|
|
for (int i = 0; i < num_sessions; i++) {
|
||
|
|
printf("\nFound: type: %d, start_utc: %d, len: %"PRIu16", steps: %"PRIu16", "
|
||
|
|
"rest_cal: %"PRIu32", active_cal: %"PRIu32", dist: %"PRIu32" ",
|
||
|
|
(int)sessions[i].type, (int)sessions[i].start_utc, sessions[i].length_min,
|
||
|
|
sessions[i].step_data.steps, sessions[i].step_data.resting_kcalories,
|
||
|
|
sessions[i].step_data.active_kcalories,
|
||
|
|
sessions[i].step_data.distance_meters);
|
||
|
|
}
|
||
|
|
printf("\nLooking for: type: %d, start_utc: %d, len: %"PRIu16", steps: %"PRIu16", "
|
||
|
|
"rest_cal: %"PRIu32", active_cal: %"PRIu32", dist: %"PRIu32" ",
|
||
|
|
(int)exp_session->type, (int)exp_session->start_utc,
|
||
|
|
exp_session->length_min, exp_session->step_data.steps,
|
||
|
|
exp_session->step_data.resting_kcalories,
|
||
|
|
exp_session->step_data.active_kcalories, exp_session->step_data.distance_meters);
|
||
|
|
clar__assert(false, file, line, "Missing activity record", "", true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Assert that a particular sleep activity session is present in the sessions list
|
||
|
|
static void prv_assert_sleep_activity_present(ActivitySession *exp_session, char *file, int line) {
|
||
|
|
ActivitySession sessions[ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT];
|
||
|
|
uint32_t num_sessions = ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT;
|
||
|
|
activity_get_sessions(&num_sessions, sessions);
|
||
|
|
for (int i = 0; i < num_sessions; i++) {
|
||
|
|
if (sessions[i].type == exp_session->type
|
||
|
|
&& sessions[i].start_utc == exp_session->start_utc
|
||
|
|
&& sessions[i].length_min == exp_session->length_min) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
printf("\nFound activities:");
|
||
|
|
for (int i = 0; i < num_sessions; i++) {
|
||
|
|
printf("\nFound: type: %d, start_utc: %d, len: %"PRIu16" ",
|
||
|
|
(int)sessions[i].type, (int)sessions[i].start_utc, sessions[i].length_min);
|
||
|
|
}
|
||
|
|
printf("\nLooking for: type: %d, start_utc: %d, len: %"PRIu16" ",
|
||
|
|
(int)exp_session->type, (int)exp_session->start_utc,
|
||
|
|
exp_session->length_min);
|
||
|
|
clar__assert(false, file, line, "Missing sleep activity record", "", true);
|
||
|
|
}
|
||
|
|
|
||
|
|
#define ASSERT_STEP_ACTIVITY_SESSION_PRESENT(session) \
|
||
|
|
prv_assert_step_activity_present((session), __FILE__, __LINE__)
|
||
|
|
|
||
|
|
#define ASSERT_SLEEP_ACTIVITY_SESSION_PRESENT(session) \
|
||
|
|
prv_assert_sleep_activity_present((session), __FILE__, __LINE__)
|
||
|
|
|
||
|
|
#define ASSERT_NUM_ACTIVITY_SESSIONS(num_sessions) \
|
||
|
|
prv_assert_num_activities((num_sessions), __FILE__, __LINE__)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// =============================================================================================
|
||
|
|
// Activity algorithm stub
|
||
|
|
// For each accel sample that is fed in, it updates the metrics as follows:
|
||
|
|
// x: increment step count by this much
|
||
|
|
// y: sleep state
|
||
|
|
//
|
||
|
|
|
||
|
|
#define ALGORITHM_SAMPLING_RATE ACCEL_SAMPLING_25HZ
|
||
|
|
#define TEST_ACTIVITY_MAX_SESSIONS 24
|
||
|
|
typedef struct {
|
||
|
|
// Captured sessions
|
||
|
|
ActivitySession sessions[TEST_ACTIVITY_MAX_SESSIONS];
|
||
|
|
int num_sessions_created;
|
||
|
|
time_t last_captured_utc;
|
||
|
|
|
||
|
|
int sleep_current_container_idx; // >=0 if we have a container in progress
|
||
|
|
ActivitySleepState sleep_state; // Our current sleep state
|
||
|
|
} AlgorithmStateMinuteData;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
uint16_t steps;
|
||
|
|
|
||
|
|
// Captured sessions
|
||
|
|
AlgorithmStateMinuteData minute_data;
|
||
|
|
|
||
|
|
// Rate info
|
||
|
|
uint16_t rate_last_steps;
|
||
|
|
time_t rate_last_update_time;
|
||
|
|
uint16_t rate_steps;
|
||
|
|
uint32_t rate_elapsed_ms;
|
||
|
|
|
||
|
|
time_t last_sleep_utc;
|
||
|
|
|
||
|
|
uint8_t orientation;
|
||
|
|
|
||
|
|
} AlgorithmState;
|
||
|
|
static AlgorithmState s_test_alg_state;
|
||
|
|
|
||
|
|
|
||
|
|
bool activity_algorithm_init(AccelSamplingRate *sampling_rate) {
|
||
|
|
*sampling_rate = ALGORITHM_SAMPLING_RATE;
|
||
|
|
AlgorithmStateMinuteData minute_data = s_test_alg_state.minute_data;
|
||
|
|
// Preserve the minute data from the last boot
|
||
|
|
s_test_alg_state = (AlgorithmState) {
|
||
|
|
.minute_data = minute_data,
|
||
|
|
.rate_last_update_time = rtc_get_time(),
|
||
|
|
};
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call from unit tests to clear out the "minute data" that might have been left over
|
||
|
|
// from last time
|
||
|
|
static void prv_activity_algorithm_erase_minute_data(void) {
|
||
|
|
s_test_alg_state.minute_data = (AlgorithmStateMinuteData){ };
|
||
|
|
s_test_alg_state.minute_data.sleep_current_container_idx = -1;
|
||
|
|
s_test_alg_state.minute_data.sleep_state = ActivitySleepStateAwake;
|
||
|
|
}
|
||
|
|
|
||
|
|
void activity_algorithm_early_deinit(void) {
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_deinit(void) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void activity_algorithm_handle_accel(AccelRawData *data, uint32_t num_samples, uint64_t timestamp) {
|
||
|
|
// For testing purposes, we'll use the x movment as the steps and y as the sleep state
|
||
|
|
ActivitySleepState prior_state = s_test_alg_state.minute_data.sleep_state;
|
||
|
|
time_t now_secs = rtc_get_time();
|
||
|
|
s_test_alg_state.minute_data.last_captured_utc = now_secs;
|
||
|
|
|
||
|
|
for (int i = 0; i < num_samples; i++) {
|
||
|
|
s_test_alg_state.steps += data[i].x;
|
||
|
|
s_test_alg_state.minute_data.sleep_state = data[i].y;
|
||
|
|
|
||
|
|
// Update the length of the current sleep container if we have one
|
||
|
|
if (s_test_alg_state.minute_data.sleep_current_container_idx >= 0) {
|
||
|
|
cl_assert(prior_state != ActivitySleepStateAwake);
|
||
|
|
ActivitySession *session = &s_test_alg_state.minute_data.sessions
|
||
|
|
[s_test_alg_state.minute_data.sleep_current_container_idx];
|
||
|
|
session->length_min = ROUND(now_secs - session->start_utc, SECONDS_PER_MINUTE);
|
||
|
|
// Inform the activity service of the new state
|
||
|
|
activity_sessions_prv_add_activity_session(session);
|
||
|
|
}
|
||
|
|
// If we were in restful sleep, update that session as well
|
||
|
|
if (prior_state == ActivitySleepStateRestfulSleep) {
|
||
|
|
cl_assert(s_test_alg_state.minute_data.num_sessions_created > 0);
|
||
|
|
ActivitySession *session = &s_test_alg_state.minute_data.sessions
|
||
|
|
[s_test_alg_state.minute_data.num_sessions_created - 1];
|
||
|
|
session->length_min = ROUND(now_secs - session->start_utc, SECONDS_PER_MINUTE);
|
||
|
|
// Inform the activity service of the new state
|
||
|
|
activity_sessions_prv_add_activity_session(session);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (s_test_alg_state.minute_data.sleep_state == prior_state) {
|
||
|
|
// No change in state, continue
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (s_test_alg_state.minute_data.sleep_state) {
|
||
|
|
// We are waking --------------------
|
||
|
|
case ActivitySleepStateAwake:
|
||
|
|
// End the container
|
||
|
|
s_test_alg_state.minute_data.sleep_current_container_idx = -1;
|
||
|
|
|
||
|
|
// Send all stored sleep sessions to the activity service now that sleep is over
|
||
|
|
for (int i = 0; i < s_test_alg_state.minute_data.num_sessions_created; i++) {
|
||
|
|
s_test_alg_state.minute_data.sessions[i].ongoing = false;
|
||
|
|
activity_sessions_prv_add_activity_session(&s_test_alg_state.minute_data.sessions[i]);
|
||
|
|
}
|
||
|
|
s_test_alg_state.minute_data.num_sessions_created = 0;
|
||
|
|
break;
|
||
|
|
|
||
|
|
// We are entering light sleep ------------------
|
||
|
|
case ActivitySleepStateLightSleep:
|
||
|
|
// Start a light sleep session if we were awake before. If we were in restful sleep,
|
||
|
|
// we should already have one
|
||
|
|
if (prior_state == ActivitySleepStateAwake) {
|
||
|
|
cl_assert(s_test_alg_state.minute_data.num_sessions_created < TEST_ACTIVITY_MAX_SESSIONS);
|
||
|
|
cl_assert(s_test_alg_state.minute_data.sleep_current_container_idx < 0);
|
||
|
|
s_test_alg_state.minute_data.sleep_current_container_idx =
|
||
|
|
s_test_alg_state.minute_data.num_sessions_created;
|
||
|
|
s_test_alg_state.minute_data.sessions[s_test_alg_state.minute_data.num_sessions_created++]
|
||
|
|
= (ActivitySession) {
|
||
|
|
.type = ActivitySessionType_Sleep,
|
||
|
|
.start_utc = now_secs,
|
||
|
|
.length_min = 0,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
// We were in restful sleep before, we should already have a container
|
||
|
|
cl_assert(s_test_alg_state.minute_data.sleep_current_container_idx >= 0);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
// We are entering restful sleep ------------------
|
||
|
|
case ActivitySleepStateRestfulSleep:
|
||
|
|
// Start a container session if we don't have already
|
||
|
|
if (s_test_alg_state.minute_data.sleep_current_container_idx < 0) {
|
||
|
|
cl_assert(s_test_alg_state.minute_data.num_sessions_created < TEST_ACTIVITY_MAX_SESSIONS);
|
||
|
|
s_test_alg_state.minute_data.sleep_current_container_idx =
|
||
|
|
s_test_alg_state.minute_data.num_sessions_created;
|
||
|
|
s_test_alg_state.minute_data.sessions[s_test_alg_state.minute_data.num_sessions_created++]
|
||
|
|
= (ActivitySession) {
|
||
|
|
.type = ActivitySessionType_Sleep,
|
||
|
|
.start_utc = now_secs,
|
||
|
|
.length_min = 0,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start a restful sleep session
|
||
|
|
cl_assert(s_test_alg_state.minute_data.num_sessions_created < TEST_ACTIVITY_MAX_SESSIONS);
|
||
|
|
s_test_alg_state.minute_data.sessions[s_test_alg_state.minute_data.num_sessions_created++]
|
||
|
|
= (ActivitySession) {
|
||
|
|
.type = ActivitySessionType_RestfulSleep,
|
||
|
|
.start_utc = now_secs,
|
||
|
|
.length_min = 0,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ActivitySleepStateUnknown:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
prior_state = s_test_alg_state.minute_data.sleep_state;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update the rate info
|
||
|
|
// The actual implementation only sends a rate update once every epoch (5 seconds), so
|
||
|
|
// emulate that
|
||
|
|
if ((now_secs - s_test_alg_state.rate_last_update_time) >= 5) {
|
||
|
|
s_test_alg_state.rate_steps = s_test_alg_state.steps - s_test_alg_state.rate_last_steps;
|
||
|
|
s_test_alg_state.rate_elapsed_ms = (now_secs - s_test_alg_state.rate_last_update_time)
|
||
|
|
* MS_PER_SECOND;
|
||
|
|
|
||
|
|
s_test_alg_state.rate_last_update_time = now_secs;
|
||
|
|
s_test_alg_state.rate_last_steps = s_test_alg_state.steps;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_set_user(uint32_t height_mm, uint32_t weight_g, ActivityGender gender,
|
||
|
|
uint32_t age_years) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_get_steps(uint16_t *steps) {
|
||
|
|
*steps = s_test_alg_state.steps;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_get_step_rate(uint16_t *steps, uint32_t *elapsed_ms, time_t *end_sec) {
|
||
|
|
*steps = s_test_alg_state.rate_steps;
|
||
|
|
*elapsed_ms = s_test_alg_state.rate_elapsed_ms;
|
||
|
|
*end_sec = s_test_alg_state.rate_last_update_time;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_metrics_changed_notification(void) {
|
||
|
|
s_test_alg_state.steps = 0;
|
||
|
|
s_test_alg_state.rate_last_steps = 0;
|
||
|
|
s_test_alg_state.rate_last_update_time = rtc_get_time();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_get_sleep_sessions(time_t sleep_earliest_end_utc,
|
||
|
|
time_t *last_processed_utc) {
|
||
|
|
*last_processed_utc = s_test_alg_state.minute_data.last_captured_utc;
|
||
|
|
for (uint32_t i = 0; i < s_test_alg_state.minute_data.num_sessions_created; i++) {
|
||
|
|
ActivitySession *session = &s_test_alg_state.minute_data.sessions[i];
|
||
|
|
int start_minute = time_util_get_minute_of_day(session->start_utc);
|
||
|
|
ACTIVITY_LOG_DEBUG("Found session %d: start_min: %d, len_min: %"PRIu16" ", session->type,
|
||
|
|
start_minute, session->length_min);
|
||
|
|
if (!activity_sessions_prv_is_sleep_activity(session->type)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (s_test_alg_state.minute_data.sessions[i].start_utc
|
||
|
|
+ (s_test_alg_state.minute_data.sessions[i].length_min * SECONDS_PER_MINUTE)
|
||
|
|
< sleep_earliest_end_utc) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
ACTIVITY_LOG_DEBUG("Returning session %d: start_min: %d, len_min: %"PRIu16" ", session->type,
|
||
|
|
start_minute, session->length_min);
|
||
|
|
activity_sessions_prv_add_activity_session(&s_test_alg_state.minute_data.sessions[i]);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void activity_algorithm_post_process_sleep_sessions(uint16_t num_input_sessions,
|
||
|
|
ActivitySession *sessions) {
|
||
|
|
}
|
||
|
|
|
||
|
|
void activity_algorithm_minute_handler(time_t utc_sec, AlgMinuteRecord *record_out) {
|
||
|
|
s_test_alg_state.last_sleep_utc = utc_sec;
|
||
|
|
|
||
|
|
record_out->data.base.orientation = s_test_alg_state.orientation;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_dump_minute_data_to_log(void) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_minute_file_info(bool compact_first, uint32_t *num_records,
|
||
|
|
uint32_t *data_bytes, uint32_t *minutes) {
|
||
|
|
*num_records = 0;
|
||
|
|
*data_bytes = 0;
|
||
|
|
*minutes = 0;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_test_fill_minute_file(void) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We simulate the activity_algorithm_get_minute_history() call to return data that reflects
|
||
|
|
// that we record chunks of ALG_MINUTES_PER_RECORD minutes at a time. If we don't ask on a
|
||
|
|
// ALG_MINUTES_PER_RECORD minute boundary, we will have up to ALG_MINUTES_PER_RECORD minutes
|
||
|
|
// of data still unavailable before the current time. The data that we do return, we will set
|
||
|
|
// the number of steps equal to (% 255) of the timestamp of that minute.
|
||
|
|
bool activity_algorithm_get_minute_history(HealthMinuteData *minute_data, uint32_t *num_records,
|
||
|
|
time_t *utc_start) {
|
||
|
|
// Get the current time
|
||
|
|
time_t now = rtc_get_time();
|
||
|
|
|
||
|
|
// Get the minute index
|
||
|
|
uint32_t minute_idx = now / SECONDS_PER_MINUTE;
|
||
|
|
|
||
|
|
// Compute the timestamp of the end of the last record we would have available
|
||
|
|
uint32_t last_minute_avail = minute_idx - (minute_idx % ALG_MINUTES_PER_FILE_RECORD);
|
||
|
|
time_t last_second_available = last_minute_avail * SECONDS_PER_MINUTE;
|
||
|
|
|
||
|
|
// Return the data now
|
||
|
|
uint32_t num_records_requested = *num_records;
|
||
|
|
|
||
|
|
// Start on next minute boundary
|
||
|
|
*utc_start = ((*utc_start + SECONDS_PER_MINUTE - 1) / SECONDS_PER_MINUTE) * SECONDS_PER_MINUTE;
|
||
|
|
|
||
|
|
int num_records_returned;
|
||
|
|
time_t record_start_time = *utc_start;
|
||
|
|
for (num_records_returned = 0; num_records_returned < num_records_requested;
|
||
|
|
num_records_returned++, record_start_time += SECONDS_PER_MINUTE) {
|
||
|
|
if (record_start_time + SECONDS_PER_MINUTE > last_second_available) {
|
||
|
|
// This record not available yet.
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
minute_data[num_records_returned] = (HealthMinuteData) {
|
||
|
|
.steps = record_start_time % 255,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
*num_records = num_records_returned;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
time_t activity_algorithm_get_last_sleep_utc(void) {
|
||
|
|
return s_test_alg_state.last_sleep_utc;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool activity_algorithm_test_send_fake_minute_data_dls_record(void) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// =========================================================================================
|
||
|
|
// Tests
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Feed in X seconds of data with the given statistics.
|
||
|
|
// The fake algorithm we plug in assumes that each accel sample contains the following:
|
||
|
|
// .x : the number of steps to increment by (either 0 or 1)
|
||
|
|
// .y : the current sleep state
|
||
|
|
// .z : 0
|
||
|
|
static void prv_feed_cannned_accel_data(uint32_t num_sec, uint32_t steps_per_minute,
|
||
|
|
ActivitySleepState sleep_state) {
|
||
|
|
uint32_t num_steps = (steps_per_minute * num_sec + 30) / 60;
|
||
|
|
uint32_t num_samples = num_sec * ALGORITHM_SAMPLING_RATE;
|
||
|
|
uint32_t samples_per_step = 0;
|
||
|
|
if (num_steps > 0) {
|
||
|
|
samples_per_step = num_samples / num_steps;
|
||
|
|
}
|
||
|
|
int need_step_ctr = samples_per_step;
|
||
|
|
|
||
|
|
time_t utc_secs;
|
||
|
|
uint16_t ms;
|
||
|
|
rtc_get_time_ms(&utc_secs, &ms);
|
||
|
|
uint64_t start_ms = utc_secs * 1000 + ms;
|
||
|
|
uint64_t ms_per_sample = 1000 / ALGORITHM_SAMPLING_RATE;
|
||
|
|
|
||
|
|
for (int i = 0; i < num_samples; ) {
|
||
|
|
AccelData accel_data[ALGORITHM_SAMPLING_RATE];
|
||
|
|
|
||
|
|
for (int j = 0; j < ALGORITHM_SAMPLING_RATE; j++, i++) {
|
||
|
|
need_step_ctr -= 1;
|
||
|
|
accel_data[j] = (AccelData) {
|
||
|
|
.x = (num_steps > 0) && (need_step_ctr <= 0),
|
||
|
|
.y = sleep_state,
|
||
|
|
.z = 0,
|
||
|
|
.timestamp = start_ms,
|
||
|
|
};
|
||
|
|
start_ms += ms_per_sample;
|
||
|
|
if (need_step_ctr <= 0) {
|
||
|
|
need_step_ctr = samples_per_step;
|
||
|
|
if (num_steps > 0) {
|
||
|
|
num_steps--;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fake_accel_service_invoke_callbacks(accel_data, ALGORITHM_SAMPLING_RATE);
|
||
|
|
|
||
|
|
// Advance time
|
||
|
|
fake_rtc_increment_time(1);
|
||
|
|
fake_rtc_increment_ticks(configTICK_RATE_HZ);
|
||
|
|
|
||
|
|
// Is it time to call the minute callback?
|
||
|
|
utc_secs += 1;
|
||
|
|
if ((utc_secs % 60) == 0) {
|
||
|
|
fake_cron_job_fire();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
PBL_ASSERTN(num_steps == 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Feed in X seconds of raw data
|
||
|
|
static void prv_feed_raw_accel_data(AccelRawData *samples, uint32_t num_samples) {
|
||
|
|
time_t utc_secs;
|
||
|
|
uint16_t ms;
|
||
|
|
rtc_get_time_ms(&utc_secs, &ms);
|
||
|
|
uint64_t start_ms = utc_secs * 1000 + ms;
|
||
|
|
|
||
|
|
for (int i = 0; i < num_samples; ) {
|
||
|
|
AccelData accel_data[ALGORITHM_SAMPLING_RATE];
|
||
|
|
|
||
|
|
int j;
|
||
|
|
for (j = 0; j < ALGORITHM_SAMPLING_RATE && i < num_samples; j++, i++) {
|
||
|
|
accel_data[j] = (AccelData) {
|
||
|
|
.x = samples[i].x,
|
||
|
|
.y = samples[i].y,
|
||
|
|
.z = samples[i].z,
|
||
|
|
.did_vibrate = false,
|
||
|
|
.timestamp = start_ms
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fake_accel_service_invoke_callbacks(accel_data, j);
|
||
|
|
|
||
|
|
// Advance time
|
||
|
|
fake_rtc_increment_time(1);
|
||
|
|
fake_rtc_increment_ticks(configTICK_RATE_HZ);
|
||
|
|
|
||
|
|
// Is it time to call the minute callback?
|
||
|
|
utc_secs += 1;
|
||
|
|
if ((utc_secs % 60) == 0) {
|
||
|
|
fake_cron_job_fire();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// --------------------------------------------------------------------------------
|
||
|
|
// Fast forward time, one minute at a time, calling all minute callbacks along the way.
|
||
|
|
// This does not feed in any accel data
|
||
|
|
static void prv_advance_by_days(uint32_t num_days) {
|
||
|
|
for (int i = 0; i < num_days; i++) {
|
||
|
|
// Advance time
|
||
|
|
fake_rtc_increment_time(SECONDS_PER_DAY);
|
||
|
|
fake_rtc_increment_ticks(configTICK_RATE_HZ * SECONDS_PER_DAY);
|
||
|
|
|
||
|
|
fake_cron_job_fire();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Uncompress data stored in the raw accel DLS records
|
||
|
|
static void prv_uncompress_captured_data(AccelRawData *data, uint32_t num_samples) {
|
||
|
|
for (int i = 0; i < s_num_dls_accel_records; i++) {
|
||
|
|
ActivityRawSamplesRecord *record = &s_dls_accel_records[i];
|
||
|
|
|
||
|
|
// Verify the header info
|
||
|
|
cl_assert_equal_i(record->version, ACTIVITY_RAW_SAMPLES_VERSION);
|
||
|
|
cl_assert_equal_i(record->len, sizeof(ActivityRawSamplesRecord));
|
||
|
|
if (i == 0) {
|
||
|
|
cl_assert(record->flags & ACTIVITY_RAW_SAMPLE_FLAG_FIRST_RECORD);
|
||
|
|
} else {
|
||
|
|
cl_assert(!(record->flags & ACTIVITY_RAW_SAMPLE_FLAG_FIRST_RECORD));
|
||
|
|
}
|
||
|
|
if (i == s_num_dls_accel_records - 1) {
|
||
|
|
cl_assert(record->flags & ACTIVITY_RAW_SAMPLE_FLAG_LAST_RECORD);
|
||
|
|
} else {
|
||
|
|
cl_assert(!(record->flags & ACTIVITY_RAW_SAMPLE_FLAG_LAST_RECORD));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Uncompress the entries into samples
|
||
|
|
uint32_t num_samples_seen = 0;
|
||
|
|
for (int j = 0; j < record->num_entries; j++) {
|
||
|
|
uint32_t encoded = record->entries[j];
|
||
|
|
uint32_t run_size = ACTIVITY_RAW_SAMPLE_GET_RUN_SIZE(encoded);
|
||
|
|
AccelRawData sample = (AccelRawData) {
|
||
|
|
.x = ACTIVITY_RAW_SAMPLE_GET_X(encoded),
|
||
|
|
.y = ACTIVITY_RAW_SAMPLE_GET_Y(encoded),
|
||
|
|
.z = ACTIVITY_RAW_SAMPLE_GET_Z(encoded),
|
||
|
|
};
|
||
|
|
while (run_size--) {
|
||
|
|
cl_assert(num_samples > 0);
|
||
|
|
*data++ = sample;
|
||
|
|
num_samples--;
|
||
|
|
num_samples_seen++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cl_assert_equal_i(num_samples_seen, record->num_samples);
|
||
|
|
}
|
||
|
|
cl_assert_equal_i(num_samples, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Init and enable the activity service
|
||
|
|
static void prv_activity_init_and_set_enabled(bool enable) {
|
||
|
|
activity_init();
|
||
|
|
activity_set_enabled(enable);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------------------------
|
||
|
|
// Fetch sleep sessions using the health_service API
|
||
|
|
static uint32_t s_health_sessions_count;
|
||
|
|
static uint32_t s_health_sessions_max;
|
||
|
|
static ActivitySession *s_health_sessions;
|
||
|
|
static time_t s_health_sessions_sleep_time;
|
||
|
|
static time_t s_health_sessions_awake_time;
|
||
|
|
|
||
|
|
static bool prv_activity_iterate_cb(HealthActivity activity, time_t time_start, time_t time_end,
|
||
|
|
void *context) {
|
||
|
|
if (s_health_sessions_count >= s_health_sessions_max) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update bed and awake time if appropriate
|
||
|
|
if (activity == HealthActivitySleep) {
|
||
|
|
if (s_health_sessions_sleep_time == 0) {
|
||
|
|
s_health_sessions_sleep_time = time_start;
|
||
|
|
}
|
||
|
|
if ((s_health_sessions_awake_time == 0) || (time_end > s_health_sessions_awake_time)) {
|
||
|
|
s_health_sessions_awake_time = time_end;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
char time_start_text[64];
|
||
|
|
struct tm *local_tm = localtime(&time_start);
|
||
|
|
strftime(time_start_text, sizeof(time_start_text), "%F %r", local_tm);
|
||
|
|
|
||
|
|
char time_end_text[64];
|
||
|
|
local_tm = localtime(&time_end);
|
||
|
|
strftime(time_end_text, sizeof(time_end_text), "%F %r", local_tm);
|
||
|
|
|
||
|
|
PBL_LOG(LOG_LEVEL_DEBUG, "Got activity: %d %s to %s (%d min)", (int)activity, time_start_text,
|
||
|
|
time_end_text, (int)((time_end - time_start) / SECONDS_PER_MINUTE));
|
||
|
|
|
||
|
|
|
||
|
|
// Save the session info
|
||
|
|
ActivitySessionType session_type = ActivitySessionType_Sleep;
|
||
|
|
if (activity == HealthActivitySleep) {
|
||
|
|
session_type = ActivitySessionType_Sleep;
|
||
|
|
} else if (activity == HealthActivityRestfulSleep) {
|
||
|
|
session_type = ActivitySessionType_RestfulSleep;
|
||
|
|
} else {
|
||
|
|
cl_assert(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
s_health_sessions[s_health_sessions_count] = (ActivitySession) {
|
||
|
|
.type = session_type,
|
||
|
|
.start_utc = time_start,
|
||
|
|
.length_min = ROUND(time_end - time_start, SECONDS_PER_MINUTE),
|
||
|
|
};
|
||
|
|
s_health_sessions_count += 1;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void prv_sleep_sessions_using_health_service(uint32_t *session_entries,
|
||
|
|
ActivitySession *sessions,
|
||
|
|
HealthIterationDirection direction) {
|
||
|
|
time_t now = rtc_get_time();
|
||
|
|
s_health_sessions_count = 0;
|
||
|
|
s_health_sessions_max = *session_entries;
|
||
|
|
s_health_sessions = sessions;
|
||
|
|
s_health_sessions_awake_time = 0;
|
||
|
|
s_health_sessions_sleep_time = 0;
|
||
|
|
health_service_activities_iterate(HealthActivityMaskAll, now - (2 * SECONDS_PER_DAY), now,
|
||
|
|
direction, prv_activity_iterate_cb,
|
||
|
|
NULL);
|
||
|
|
PBL_LOG(LOG_LEVEL_DEBUG, "Found %"PRIu32" activities", s_health_sessions_count);
|
||
|
|
*session_entries = s_health_sessions_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void prv_assert_equal_activity_and_health_sleep_sessions(int exp_num_sessions) {
|
||
|
|
// Get the sleep sessions and make sure we get the expected ones
|
||
|
|
stub_pebble_tasks_set_current(PebbleTask_App);
|
||
|
|
uint32_t session_entries = 24;
|
||
|
|
ActivitySession sessions[session_entries];
|
||
|
|
activity_get_sessions(&session_entries, sessions);
|
||
|
|
cl_assert_equal_i(session_entries, exp_num_sessions);
|
||
|
|
|
||
|
|
// Get the sleep sessions using the health API
|
||
|
|
uint32_t health_session_entries = 24;
|
||
|
|
ActivitySession health_sessions[session_entries];
|
||
|
|
prv_sleep_sessions_using_health_service(&health_session_entries, health_sessions,
|
||
|
|
HealthIterationDirectionFuture);
|
||
|
|
cl_assert_equal_i(health_session_entries, exp_num_sessions);
|
||
|
|
|
||
|
|
for (int i = 0; i < exp_num_sessions; i++) {
|
||
|
|
cl_assert_equal_i(sessions[i].type, health_sessions[i].type);
|
||
|
|
cl_assert_equal_i(sessions[i].start_utc, health_sessions[i].start_utc);
|
||
|
|
cl_assert_equal_i(sessions[i].length_min, health_sessions[i].length_min);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// =============================================================================================
|
||
|
|
// Start of unit tests
|
||
|
|
void test_activity__initialize(void) {
|
||
|
|
TimezoneInfo tz_info = {
|
||
|
|
.tm_zone = "UTC",
|
||
|
|
.tm_gmtoff = 0,
|
||
|
|
};
|
||
|
|
time_util_update_timezone(&tz_info);
|
||
|
|
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
fake_rtc_init(100 /*initial_ticks*/, utc_sec);
|
||
|
|
fake_spi_flash_init(0, 0x1000000);
|
||
|
|
pfs_init(false);
|
||
|
|
pfs_format(false);
|
||
|
|
|
||
|
|
prv_activity_algorithm_erase_minute_data();
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
|
||
|
|
// Set default user settings
|
||
|
|
activity_prefs_set_height_mm(ACTIVITY_DEFAULT_HEIGHT_MM);
|
||
|
|
activity_prefs_set_weight_dag(ACTIVITY_DEFAULT_WEIGHT_DAG);
|
||
|
|
activity_prefs_set_gender(ACTIVITY_DEFAULT_GENDER);
|
||
|
|
activity_prefs_set_age_years(ACTIVITY_DEFAULT_AGE_YEARS);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
void test_activity__cleanup(void) {
|
||
|
|
activity_stop_tracking();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we correctly initialize the history upon startup based on stored settings
|
||
|
|
void test_activity__init_history(void) {
|
||
|
|
uint32_t exp_resting_kcalories[ACTIVITY_HISTORY_DAYS];
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
if (i == 0) {
|
||
|
|
exp_resting_kcalories[i] = s_exp_5pm_resting_kcalories;
|
||
|
|
} else {
|
||
|
|
exp_resting_kcalories[i] = s_exp_full_day_resting_kcalories;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Should start out with 0 in the history
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricDistanceMeters,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricActiveKCalories,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricRestingKCalories, exp_resting_kcalories);
|
||
|
|
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 1 min, 1 minute of deep and 1 minute of light sleep
|
||
|
|
prv_feed_cannned_accel_data(60, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateLightSleep);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
// Put in a stepping activity
|
||
|
|
time_t day_start = time_util_get_midnight_of(rtc_get_time());
|
||
|
|
ActivitySession walk_activity = {
|
||
|
|
.start_utc = day_start + 12 * SECONDS_PER_HOUR,
|
||
|
|
.length_min = 120,
|
||
|
|
.type = ActivitySessionType_Walk,
|
||
|
|
.step_data = {
|
||
|
|
.steps = 100,
|
||
|
|
.active_kcalories = 200,
|
||
|
|
.resting_kcalories = 300,
|
||
|
|
.distance_meters = 400,
|
||
|
|
},
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&walk_activity);
|
||
|
|
|
||
|
|
// Capture the resting kcalories now, It is time dependent and we're not sure exactly which time
|
||
|
|
// of day it will be saved to storage
|
||
|
|
int32_t min_resting_kcalories;
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 1, &min_resting_kcalories);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep and periodic update logic to run.
|
||
|
|
uint32_t wait_min = MAX(ACTIVITY_SESSION_UPDATE_MIN, ACTIVITY_SETTINGS_UPDATE_MIN);
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * wait_min, 0, ActivitySleepStateAwake);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){100, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){2 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){1 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
// Check that we have the expected # of activities
|
||
|
|
ASSERT_NUM_ACTIVITY_SESSIONS(3); // 2 sleep sessions + 1 activity sessions
|
||
|
|
ASSERT_STEP_ACTIVITY_SESSION_PRESENT(&walk_activity);
|
||
|
|
|
||
|
|
// The expected resting calories
|
||
|
|
int minutes_today = 17 * MINUTES_PER_HOUR + 3 + wait_min;
|
||
|
|
const int exp_resting_kcalories_now = ROUND(s_exp_full_day_resting_kcalories * minutes_today,
|
||
|
|
MINUTES_PER_DAY);
|
||
|
|
exp_resting_kcalories[0] = exp_resting_kcalories_now;
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricRestingKCalories, exp_resting_kcalories);
|
||
|
|
|
||
|
|
// See what distance we walked
|
||
|
|
int32_t exp_distance;
|
||
|
|
activity_get_metric(ActivityMetricDistanceMeters, 1, &exp_distance);
|
||
|
|
cl_assert(exp_distance > 0);
|
||
|
|
|
||
|
|
// Read the active calories
|
||
|
|
int32_t exp_active_kcalories;
|
||
|
|
activity_get_metric(ActivityMetricActiveKCalories, 1, &exp_active_kcalories);
|
||
|
|
cl_assert(exp_active_kcalories > 0);
|
||
|
|
|
||
|
|
|
||
|
|
// If we init again, we should start out with the same metrics because we
|
||
|
|
// would have retrieved them from settings
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){100, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricDistanceMeters,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){exp_distance, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricActiveKCalories,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){exp_active_kcalories, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){2 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){1 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
// The actual resting calories must be in the range from min_resting_kcalories to
|
||
|
|
// exp_resting_kcalories_now because we don't know at exactly which time settings were saved to
|
||
|
|
// storage
|
||
|
|
int32_t actual_resting_kcalories[ACTIVITY_HISTORY_DAYS];
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, ACTIVITY_HISTORY_DAYS,
|
||
|
|
actual_resting_kcalories);
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
if (i == 0) {
|
||
|
|
cl_assert(actual_resting_kcalories[i] >= min_resting_kcalories
|
||
|
|
&& actual_resting_kcalories[i] <= exp_resting_kcalories_now);
|
||
|
|
} else {
|
||
|
|
cl_assert_equal_i(actual_resting_kcalories[i], exp_resting_kcalories[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure all of our activities persisted
|
||
|
|
ASSERT_NUM_ACTIVITY_SESSIONS(3); // 2 sleep sessions + 1 activity sessions
|
||
|
|
ASSERT_STEP_ACTIVITY_SESSION_PRESENT(&walk_activity);
|
||
|
|
|
||
|
|
|
||
|
|
// Pretend that 24 hours has elapsed since we saved prefs. This should put both the step and
|
||
|
|
// sleep history 1 day behind
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_tm.tm_mday += 1;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 100, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricDistanceMeters,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, exp_distance, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricActiveKCalories,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, exp_active_kcalories, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 2 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 1 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, ACTIVITY_HISTORY_DAYS,
|
||
|
|
actual_resting_kcalories);
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
if (i == 0) {
|
||
|
|
cl_assert_equal_i(actual_resting_kcalories[i], s_exp_5pm_resting_kcalories);
|
||
|
|
} else if (i == 1) {
|
||
|
|
cl_assert(actual_resting_kcalories[i] >= min_resting_kcalories
|
||
|
|
&& actual_resting_kcalories[i] <= exp_resting_kcalories_now);
|
||
|
|
} else {
|
||
|
|
cl_assert_equal_i(actual_resting_kcalories[i], exp_resting_kcalories[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we correctly initialize the setting upon startup based on the stored settings file
|
||
|
|
void test_activity__settings(void) {
|
||
|
|
// Should start out with defaults
|
||
|
|
uint16_t height_mm;
|
||
|
|
uint16_t weight_dag;
|
||
|
|
ActivityGender gender;
|
||
|
|
uint8_t age_years;
|
||
|
|
|
||
|
|
height_mm = activity_prefs_get_height_mm();
|
||
|
|
cl_assert_equal_i(height_mm, ACTIVITY_DEFAULT_HEIGHT_MM);
|
||
|
|
weight_dag = activity_prefs_get_weight_dag();
|
||
|
|
cl_assert_equal_i(weight_dag, ACTIVITY_DEFAULT_WEIGHT_DAG);
|
||
|
|
gender = activity_prefs_get_gender();
|
||
|
|
cl_assert_equal_i(gender, ACTIVITY_DEFAULT_GENDER);
|
||
|
|
age_years = activity_prefs_get_age_years();
|
||
|
|
cl_assert_equal_i(age_years, ACTIVITY_DEFAULT_AGE_YEARS);
|
||
|
|
|
||
|
|
// Set the settings, re-init, and make sure they stick
|
||
|
|
height_mm += 10;
|
||
|
|
weight_dag += 11;
|
||
|
|
gender = ActivityGenderOther;
|
||
|
|
age_years += 10;
|
||
|
|
activity_prefs_set_height_mm(height_mm);
|
||
|
|
activity_prefs_set_weight_dag(weight_dag);
|
||
|
|
activity_prefs_set_gender(gender);
|
||
|
|
activity_prefs_set_age_years(age_years);
|
||
|
|
|
||
|
|
// Re-init
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
|
||
|
|
// Check settings
|
||
|
|
uint32_t value;
|
||
|
|
value = activity_prefs_get_height_mm();
|
||
|
|
cl_assert_equal_i(height_mm, value);
|
||
|
|
value = activity_prefs_get_weight_dag();
|
||
|
|
cl_assert_equal_i(weight_dag, value);
|
||
|
|
value = activity_prefs_get_gender();
|
||
|
|
cl_assert_equal_i(gender, value);
|
||
|
|
value = activity_prefs_get_age_years();
|
||
|
|
cl_assert_equal_i(age_years, value);
|
||
|
|
|
||
|
|
// Reset settings
|
||
|
|
activity_prefs_set_height_mm(ACTIVITY_DEFAULT_HEIGHT_MM);
|
||
|
|
activity_prefs_set_weight_dag(ACTIVITY_DEFAULT_WEIGHT_DAG);
|
||
|
|
activity_prefs_set_gender(ACTIVITY_DEFAULT_GENDER);
|
||
|
|
activity_prefs_set_age_years(ACTIVITY_DEFAULT_AGE_YEARS);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that our periodic minute callback correctly detects the midnight rollover
|
||
|
|
void test_activity__day_rollover(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 1 min, 1 minute of deep and 1 minute of light sleep
|
||
|
|
prv_feed_cannned_accel_data(60, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateLightSleep);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep logic to run.
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * ACTIVITY_SESSION_UPDATE_MIN, 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){100, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){2 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){1 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
// Expected resting calories
|
||
|
|
uint32_t exp_resting_kcalories[ACTIVITY_HISTORY_DAYS];
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
if (i == 0) {
|
||
|
|
// All tests start at 5pm, we we just entered 3 minutes of data.
|
||
|
|
uint32_t minutes_today = 17 * MINUTES_PER_HOUR + 3 + ACTIVITY_SESSION_UPDATE_MIN;
|
||
|
|
exp_resting_kcalories[i] = ROUND(s_exp_full_day_resting_kcalories * minutes_today,
|
||
|
|
MINUTES_PER_DAY);
|
||
|
|
} else {
|
||
|
|
exp_resting_kcalories[i] = s_exp_full_day_resting_kcalories;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricRestingKCalories, exp_resting_kcalories);
|
||
|
|
|
||
|
|
// Put in 2 activities, one of which should drop off on a new day because it's old and the
|
||
|
|
// other which drop off because it is in the future (invalid)
|
||
|
|
time_t day_start = time_util_get_midnight_of(rtc_get_time());
|
||
|
|
ActivitySession old_activity = {
|
||
|
|
.start_utc = day_start + 12 * SECONDS_PER_HOUR,
|
||
|
|
.length_min = 120,
|
||
|
|
.type = ActivitySessionType_Walk,
|
||
|
|
.step_data = {
|
||
|
|
.steps = 100,
|
||
|
|
.active_kcalories = 200,
|
||
|
|
.resting_kcalories = 300,
|
||
|
|
.distance_meters = 400,
|
||
|
|
},
|
||
|
|
};
|
||
|
|
ActivitySession new_activity = {
|
||
|
|
.start_utc = day_start + 23 * SECONDS_PER_HOUR,
|
||
|
|
.length_min = 120,
|
||
|
|
.type = ActivitySessionType_Run,
|
||
|
|
.step_data = {
|
||
|
|
.steps = 1000,
|
||
|
|
.active_kcalories = 300,
|
||
|
|
.resting_kcalories = 400,
|
||
|
|
.distance_meters = 500,
|
||
|
|
},
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&old_activity);
|
||
|
|
activity_sessions_prv_add_activity_session(&new_activity);
|
||
|
|
ASSERT_NUM_ACTIVITY_SESSIONS(4); // 2 sleep sessions + 2 activity sessions
|
||
|
|
ASSERT_STEP_ACTIVITY_SESSION_PRESENT(&old_activity);
|
||
|
|
ASSERT_STEP_ACTIVITY_SESSION_PRESENT(&new_activity);
|
||
|
|
|
||
|
|
// Wait long enough for our midnight rollover to occur. We init time at 5pm, so we need to wait
|
||
|
|
// for at least 7 hours.
|
||
|
|
const int minutes_till_midnight = (7 * MINUTES_PER_HOUR) - ACTIVITY_SESSION_UPDATE_MIN - 3;
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * (minutes_till_midnight + 1), 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 100, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 2 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 1 * SECONDS_PER_MINUTE, 0, 0, 0, 0, 0}));
|
||
|
|
for (int i = 0; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
if (i == 0) {
|
||
|
|
exp_resting_kcalories[i] = 1;
|
||
|
|
} else if (i == 1) {
|
||
|
|
exp_resting_kcalories[i] = ROUND(s_exp_full_day_resting_kcalories * (MINUTES_PER_DAY - 1),
|
||
|
|
MINUTES_PER_DAY);
|
||
|
|
} else {
|
||
|
|
exp_resting_kcalories[i] = s_exp_full_day_resting_kcalories;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricRestingKCalories, exp_resting_kcalories);
|
||
|
|
|
||
|
|
// Verify that the expired and invalid activity session have been removed
|
||
|
|
ASSERT_NUM_ACTIVITY_SESSIONS(0);
|
||
|
|
|
||
|
|
// Verify that we have the right history capacity
|
||
|
|
uint32_t exp_history[ACTIVITY_HISTORY_DAYS];
|
||
|
|
for (int i = 1; i < ACTIVITY_HISTORY_DAYS; i++) {
|
||
|
|
memset(exp_history, 0, sizeof(exp_history));
|
||
|
|
exp_history[i] = 100;
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount, exp_history);
|
||
|
|
|
||
|
|
prv_advance_by_days(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Derived metrics like distance, calories, and walking minutes that are based on steps
|
||
|
|
void test_activity__step_derived_metrics(void) {
|
||
|
|
int32_t value;
|
||
|
|
|
||
|
|
// All tests start at 5pm, which is 1020 minutes into the day
|
||
|
|
const int k_minute_start = 1020;
|
||
|
|
|
||
|
|
// Set the user's dimensions
|
||
|
|
const int k_height_mm = 1630;
|
||
|
|
activity_prefs_set_height_mm(k_height_mm);
|
||
|
|
activity_prefs_set_weight_dag(6800);
|
||
|
|
activity_prefs_set_gender(ActivityGenderFemale);
|
||
|
|
activity_prefs_set_age_years(30);
|
||
|
|
|
||
|
|
// The health_service calls expect to be in the app or worker task
|
||
|
|
stub_pebble_tasks_set_current(PebbleTask_App);
|
||
|
|
|
||
|
|
// Advance to a new day to give a chance for the new resting metabolism to be incorporated
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_tm.tm_mday += 1;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// All tests start at 5pm, which is 1020 minutes into a 1440 minute day. The BMR for
|
||
|
|
// the above user is 1388 kcalories per day, so we expect to get:
|
||
|
|
// 1388 * 1020/1440 = 1023 kcalories
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 1, &value);
|
||
|
|
const int k_bmr_cal = 1388 * ACTIVITY_CALORIES_PER_KCAL;
|
||
|
|
cl_assert_equal_i(value, ROUND(k_bmr_cal * k_minute_start / MINUTES_PER_DAY,
|
||
|
|
ACTIVITY_CALORIES_PER_KCAL));
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricRestingKCalories), value);
|
||
|
|
|
||
|
|
// Feed in 100 steps/minute over 1 hour (walking rate)
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_HOUR, 100, ActivitySleepStateAwake);
|
||
|
|
const int k_exp_steps = 100 * MINUTES_PER_HOUR;
|
||
|
|
|
||
|
|
// Test the derived metrics
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, &value);
|
||
|
|
cl_assert_equal_i(value, k_exp_steps);
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricStepCount), k_exp_steps);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricActiveSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, SECONDS_PER_HOUR);
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricActiveSeconds), SECONDS_PER_HOUR);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricActiveKCalories, 1, &value);
|
||
|
|
// The following determined from a known good commit
|
||
|
|
int32_t exp_active_kcalories = 152;
|
||
|
|
cl_assert_equal_i(value, exp_active_kcalories);
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricActiveKCalories), exp_active_kcalories);
|
||
|
|
|
||
|
|
// We now expect to get the following resting calories since we are now 1025 minutes into the day:
|
||
|
|
const int exp_resting_calories = k_bmr_cal * (k_minute_start + MINUTES_PER_HOUR)
|
||
|
|
/ MINUTES_PER_DAY;
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ROUND(exp_resting_calories, ACTIVITY_CALORIES_PER_KCAL));
|
||
|
|
|
||
|
|
|
||
|
|
// Test that ActivityMetricStepMinutes responds correctly
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_MINUTE, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_MINUTE, 10, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_MINUTE, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_MINUTE, 10, ActivitySleepStateAwake);
|
||
|
|
activity_get_metric(ActivityMetricActiveSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, SECONDS_PER_HOUR + (2 * SECONDS_PER_MINUTE));
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricActiveSeconds),
|
||
|
|
SECONDS_PER_HOUR + (2 * SECONDS_PER_MINUTE));
|
||
|
|
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------------
|
||
|
|
// Reset and try another case. Faster pace and taller person
|
||
|
|
activity_stop_tracking();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
const int k_height_mm_2 = 1830;
|
||
|
|
activity_prefs_set_height_mm(k_height_mm_2);
|
||
|
|
activity_prefs_set_weight_dag(9100);
|
||
|
|
activity_prefs_set_gender(ActivityGenderMale);
|
||
|
|
activity_prefs_set_age_years(40);
|
||
|
|
|
||
|
|
// Another day
|
||
|
|
utc_sec += SECONDS_PER_DAY;
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// All tests start at 5pm, which is 1020 minutes into a 1440 minute day. The BMR for
|
||
|
|
// the above user is 1859 kcalories per day, so we expect to get:
|
||
|
|
// 1859 * 1020/1440 = 1328 kcalories
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 1, &value);
|
||
|
|
const int k_bmr_cal_2 = 1859 * ACTIVITY_CALORIES_PER_KCAL;
|
||
|
|
cl_assert_equal_i(value, ROUND(k_bmr_cal_2 * k_minute_start / MINUTES_PER_DAY,
|
||
|
|
ACTIVITY_CALORIES_PER_KCAL));
|
||
|
|
|
||
|
|
// Feed in 125 steps/minute over 60 minutes
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 125, ActivitySleepStateAwake);
|
||
|
|
const int k_exp_steps_2 = 125 * MINUTES_PER_HOUR;
|
||
|
|
|
||
|
|
// Test the derived metrics
|
||
|
|
activity_get_metric(ActivityMetricActiveSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, SECONDS_PER_HOUR);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, &value);
|
||
|
|
cl_assert_equal_i(value, k_exp_steps_2);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricActiveKCalories, 1, &value);
|
||
|
|
// The following determined from a known good commit
|
||
|
|
int32_t exp_active_kcalories_2 = 486;
|
||
|
|
cl_assert_equal_i(value, exp_active_kcalories_2);
|
||
|
|
|
||
|
|
// We now expect to get the following resting calories
|
||
|
|
const int exp_resting_calories_2 = k_bmr_cal_2 * (k_minute_start + MINUTES_PER_HOUR)
|
||
|
|
/ MINUTES_PER_DAY;
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ROUND(exp_resting_calories_2, ACTIVITY_CALORIES_PER_KCAL));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test derived metrics based on sleep data
|
||
|
|
void test_activity__sleep_derived_metrics(void) {
|
||
|
|
int32_t value;
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// All of our tests start at 5pm. Let's enter a sleep cycle where the user gets into bed
|
||
|
|
// at 10pm, takes 30 minutes to fall asleep, and wakes up at 6am.
|
||
|
|
|
||
|
|
// Light walking, 50 steps/minute, until 10pm
|
||
|
|
prv_feed_cannned_accel_data(5 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Falling asleep for 30 minutes
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 5, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Starting at 10:30pm: 2 Cycles of light (60 min), deep (50 min), awake (10 min)
|
||
|
|
for (int i = 0; i < 2; i++) {
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
activity_get_metric(ActivityMetricSleepState, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(50 * SECONDS_PER_MINUTE, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
activity_get_metric(ActivityMetricSleepState, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(10 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 30 minute "morning walk" 4 hours later at 2:30am
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 50, ActivitySleepStateAwake);
|
||
|
|
activity_get_metric(ActivityMetricSleepState, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ActivitySleepStateAwake);
|
||
|
|
cl_assert_equal_i(health_service_peek_current_activities(), HealthActivityNone);
|
||
|
|
|
||
|
|
int exp_value = 22 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE; // 10:30pm in minutes
|
||
|
|
activity_get_metric(ActivityMetricSleepEnterAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, exp_value);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepStateSeconds, 1, &value);
|
||
|
|
// Ideally it would show 40 minutes, but we only sample once every ACTIVITY_SESSION_UPDATE_MIN minutes
|
||
|
|
cl_assert(value <= 40 * SECONDS_PER_MINUTE
|
||
|
|
&& value >= (40 - ACTIVITY_SESSION_UPDATE_MIN) * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
// Verify the root metrics. Since we also verify these using the health_service api, set
|
||
|
|
// the task to the app task now
|
||
|
|
stub_pebble_tasks_set_current(PebbleTask_App);
|
||
|
|
activity_get_metric(ActivityMetricSleepTotalSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 220 * SECONDS_PER_MINUTE);
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricSleepSeconds), 220 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepRestfulSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 100 * SECONDS_PER_MINUTE);
|
||
|
|
cl_assert_equal_i(health_service_sum_today(HealthMetricSleepRestfulSeconds),
|
||
|
|
100 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepExitAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 2 * SECONDS_PER_HOUR + 20 * SECONDS_PER_MINUTE
|
||
|
|
/* 2:20am in minutes */);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that sleep sessions get registered in the correct day
|
||
|
|
void test_activity__sleep_history(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// All of our tests start at 5pm. Let's enter a sleep cycle where the user has a sleep session
|
||
|
|
// before the cut-off for the new day
|
||
|
|
// Light walking, 50 steps/minute, until 6pm
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// 2.5 hours of sleep, put's us at 8:30pm. The cut-off for the next day is
|
||
|
|
// ACTIVITY_LAST_SLEEP_MINUTE_OF_DAY, currently set for 9pm so this session should be
|
||
|
|
// registered for today
|
||
|
|
prv_feed_cannned_accel_data(150 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Awake for 30 minutes which puts us at 9pm.
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Another 2 hour sleep session starting at 9pm. This will leave us at 11pm. Since this
|
||
|
|
// session ends after the the cutoff, it should be registered for the next day
|
||
|
|
prv_feed_cannned_accel_data(120 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Awake for 2 hours which puts us at 1am
|
||
|
|
prv_feed_cannned_accel_data(120 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Now if we get sleep history, we should have 2.5 hours yesterday, and 2 hours today
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){120 * SECONDS_PER_MINUTE,
|
||
|
|
150 * SECONDS_PER_MINUTE}));
|
||
|
|
|
||
|
|
// Another 2 hour sleep session starting at 1am. This will leave us at 3am.
|
||
|
|
prv_feed_cannned_accel_data(120 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Awake for 1 hour which puts us at 4am
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){240 * SECONDS_PER_MINUTE,
|
||
|
|
150 * SECONDS_PER_MINUTE}));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test raw sample capturing
|
||
|
|
void test_activity__raw_sample_collection(void) {
|
||
|
|
bool enabled;
|
||
|
|
uint32_t session_id;
|
||
|
|
uint32_t num_samples;
|
||
|
|
uint32_t seconds;
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Feed in some raw samples where every sample is unique
|
||
|
|
{
|
||
|
|
prv_reset_captured_dls_data();
|
||
|
|
activity_raw_sample_collection(true, false, &enabled, &session_id, &num_samples, &seconds);
|
||
|
|
cl_assert(enabled);
|
||
|
|
cl_assert_equal_i(num_samples, 0);
|
||
|
|
|
||
|
|
// Feed in 510 values to test entire dynamic range
|
||
|
|
const int k_raw_samples = 510;
|
||
|
|
AccelRawData raw_data[k_raw_samples];
|
||
|
|
for (int i = 0; i < k_raw_samples; i++) {
|
||
|
|
// We store multiples of 8 because the compression algorithm divides by 8.
|
||
|
|
raw_data[i].x = i * 8;
|
||
|
|
raw_data[i].y = -i * 8;
|
||
|
|
raw_data[i].z = (i + 1) * 8;
|
||
|
|
}
|
||
|
|
prv_feed_raw_accel_data(raw_data, k_raw_samples);
|
||
|
|
|
||
|
|
// Stop collection
|
||
|
|
activity_raw_sample_collection(false, true, &enabled, &session_id, &num_samples, &seconds);
|
||
|
|
cl_assert(!enabled);
|
||
|
|
cl_assert_equal_i(num_samples, k_raw_samples);
|
||
|
|
cl_assert_equal_i(seconds,
|
||
|
|
(k_raw_samples + ALGORITHM_SAMPLING_RATE - 1) / ALGORITHM_SAMPLING_RATE);
|
||
|
|
|
||
|
|
// Verify the collected data
|
||
|
|
AccelRawData captured_data[k_raw_samples];
|
||
|
|
prv_uncompress_captured_data(captured_data, k_raw_samples);
|
||
|
|
cl_assert_equal_m(raw_data, captured_data, k_raw_samples * sizeof(AccelRawData));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Feed in some raw samples with some runs
|
||
|
|
{
|
||
|
|
prv_reset_captured_dls_data();
|
||
|
|
activity_raw_sample_collection(true, false, &enabled, &session_id, &num_samples, &seconds);
|
||
|
|
cl_assert(enabled);
|
||
|
|
cl_assert_equal_i(num_samples, 0);
|
||
|
|
|
||
|
|
// Feed in 510 values to test entire dynamic range
|
||
|
|
const int k_raw_samples = 510;
|
||
|
|
AccelRawData raw_data[k_raw_samples];
|
||
|
|
int value = 0;
|
||
|
|
for (int i = 0; i < k_raw_samples; i++) {
|
||
|
|
// We store multiples of 8 because the compression algorithm divides by 8.
|
||
|
|
raw_data[i].x = value * 8;
|
||
|
|
raw_data[i].y = -value * 8;
|
||
|
|
raw_data[i].z = (value + 1) * 8;
|
||
|
|
if ((i % 7) == 0) {
|
||
|
|
value += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
prv_feed_raw_accel_data(raw_data, k_raw_samples);
|
||
|
|
|
||
|
|
// Stop collection
|
||
|
|
activity_raw_sample_collection(false, true, &enabled, &session_id, &num_samples, &seconds);
|
||
|
|
cl_assert(!enabled);
|
||
|
|
cl_assert_equal_i(num_samples, k_raw_samples);
|
||
|
|
cl_assert_equal_i(seconds,
|
||
|
|
(k_raw_samples + ALGORITHM_SAMPLING_RATE - 1) / ALGORITHM_SAMPLING_RATE);
|
||
|
|
|
||
|
|
// Verify the collected data
|
||
|
|
AccelRawData captured_data[k_raw_samples];
|
||
|
|
prv_uncompress_captured_data(captured_data, k_raw_samples);
|
||
|
|
cl_assert_equal_m(raw_data, captured_data, k_raw_samples * sizeof(AccelRawData));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test getting the sleep sessions
|
||
|
|
void test_activity__get_sleep_sessions(void) {
|
||
|
|
int32_t value;
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Light walking, 50 steps/minute, until 10pm
|
||
|
|
prv_feed_cannned_accel_data(5 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Falling asleep for 30 minutes
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 5, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Starting at 10:30pm: 2 Cycles of light (60 min), deep (50 min), awake (10 min)
|
||
|
|
for (int i = 0; i < 2; i++) {
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(50 * SECONDS_PER_MINUTE, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(10 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 30 minute "morning walk" 4 hours later at 2:30am
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 50, ActivitySleepStateAwake);
|
||
|
|
activity_get_metric(ActivityMetricSleepState, 1, &value);
|
||
|
|
cl_assert_equal_i(value, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Assert that we got the same sleep sessions using the activity service as we do using
|
||
|
|
// the health API
|
||
|
|
prv_assert_equal_activity_and_health_sleep_sessions(4);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test getting the minute history
|
||
|
|
void test_activity__get_minute_history(void) {
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
const uint32_t exp_num_records = 10;
|
||
|
|
HealthMinuteData minutes[exp_num_records];
|
||
|
|
|
||
|
|
// The last ALG_MINUTES_PER_RECORD of minutes may not be available yet, so start
|
||
|
|
// well enough before that
|
||
|
|
time_t utc_start = rtc_get_time() - ((ALG_MINUTES_PER_FILE_RECORD * 2) * SECONDS_PER_MINUTE);
|
||
|
|
const time_t exp_utc_start = utc_start;
|
||
|
|
|
||
|
|
stub_pebble_tasks_set_current(PebbleTask_App);
|
||
|
|
uint32_t num_records = exp_num_records;
|
||
|
|
activity_get_minute_history(minutes, &num_records, &utc_start);
|
||
|
|
cl_assert_equal_i(num_records, exp_num_records);
|
||
|
|
cl_assert_equal_i(utc_start, exp_utc_start);
|
||
|
|
cl_assert_equal_i(minutes[0].steps, exp_utc_start % 255);
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Once a minute, retrieve the last ALG_MINUTES_PER_RECORD minutes of data. We should
|
||
|
|
// get 1 fewer record each time because we know that the activity algorithm code only
|
||
|
|
// writes a new minute data record once every ALG_MINUTES_PER_RECORD minutes.
|
||
|
|
|
||
|
|
// Start on a ALG_MINUTES_PER_RECORD minute boundary so that we know we have
|
||
|
|
// ALG_MINUTES_PER_RECORD records available up to the current time
|
||
|
|
struct tm start_tm = {
|
||
|
|
// Jan 1, 2015, 5am
|
||
|
|
.tm_hour = 5,
|
||
|
|
.tm_mday = 1,
|
||
|
|
.tm_mon = 0,
|
||
|
|
.tm_year = 115
|
||
|
|
};
|
||
|
|
time_t utc_sec = mktime(&start_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
time_t oldest_to_fetch = rtc_get_time() - (ALG_MINUTES_PER_FILE_RECORD * SECONDS_PER_MINUTE);
|
||
|
|
for (int i = 0; i < ALG_MINUTES_PER_FILE_RECORD; i++) {
|
||
|
|
|
||
|
|
// Ask for the last ALG_MINUTES_PER_RECORD minutes of data
|
||
|
|
num_records = ALG_MINUTES_PER_FILE_RECORD;
|
||
|
|
time_t start_time = oldest_to_fetch + (i * SECONDS_PER_MINUTE);
|
||
|
|
time_t end_time = utc_sec;
|
||
|
|
HealthMinuteData received_records[ALG_MINUTES_PER_FILE_RECORD];
|
||
|
|
num_records = health_service_get_minute_history(received_records, num_records, &start_time,
|
||
|
|
&end_time);
|
||
|
|
|
||
|
|
cl_assert_equal_i(num_records, ALG_MINUTES_PER_FILE_RECORD - i);
|
||
|
|
cl_assert_equal_i(start_time, oldest_to_fetch + (i * SECONDS_PER_MINUTE));
|
||
|
|
|
||
|
|
printf("\nReceived %d minute records", (int)num_records);
|
||
|
|
for (int j = 0; j < num_records; j++) {
|
||
|
|
printf("\nRecord:%d, steps: %d", j, (int)received_records[j].steps);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify the contents of the records
|
||
|
|
for (int j = 0; j < num_records; j++) {
|
||
|
|
cl_assert_equal_i(received_records[j].steps,
|
||
|
|
(start_time + (j * SECONDS_PER_MINUTE)) % 255);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Advance another minute.
|
||
|
|
rtc_set_time(utc_sec + (i * SECONDS_PER_MINUTE));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Return the index of the step averages slot that contains the given minute
|
||
|
|
static uint16_t prv_step_avg_slot(int hour, int min) {
|
||
|
|
int minutes = hour * MINUTES_PER_HOUR + min;
|
||
|
|
return minutes / (MINUTES_PER_DAY / ACTIVITY_NUM_METRIC_AVERAGES);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Used by the test_activity__step_averages() method to figure out what steps/min we should
|
||
|
|
// feed in for the given 15-minute time slot
|
||
|
|
int prv_expected_steps_per_min(int slot, int multiplier) {
|
||
|
|
if (multiplier == 1) {
|
||
|
|
// The slot % 50 was chosen so that the total # of steps per day does not exceeed 2^16
|
||
|
|
return ((slot % 50) + 1);
|
||
|
|
} else if (multiplier == 2) {
|
||
|
|
// The slot % 30 was chosen so that the total # of steps per day does not exceeed 2^16
|
||
|
|
return 2 * ((slot % 30) + 1);
|
||
|
|
} else {
|
||
|
|
cl_assert(false);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ------------------------------------------------------------------------------------
|
||
|
|
// Verify that the settings are what we expected from prv_save_known_settings()
|
||
|
|
void prv_assert_known_settings(void) {
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){300, 200, 100, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepTotalSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS])
|
||
|
|
{6 * SECONDS_PER_MINUTE, 4 * SECONDS_PER_MINUTE,
|
||
|
|
2 * SECONDS_PER_MINUTE, 0, 0, 0, 0}));
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricSleepRestfulSeconds,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS])
|
||
|
|
{3 * SECONDS_PER_MINUTE, 2 * SECONDS_PER_MINUTE,
|
||
|
|
1 * SECONDS_PER_MINUTE, 0, 0, 0, 0}));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// --------------------------------------------------------------------------------------
|
||
|
|
// Save the current settings file format with known data to the local file system so that it can
|
||
|
|
// be checked in and used for migration tests.
|
||
|
|
static void prv_save_known_settings_file(const char *filename) {
|
||
|
|
|
||
|
|
// Let's include 3 days of history by start at s_init_time_tm - 3 days
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
utc_sec -= 2 * SECONDS_PER_DAY;
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 1 min, 1 minute of deep and 1 minute of light sleep
|
||
|
|
prv_feed_cannned_accel_data(60, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
prv_feed_cannned_accel_data(60, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep logic to run.
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * ACTIVITY_SESSION_UPDATE_MIN, 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Advance to next day
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_HOUR * 24, 0, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 2 min, 2 minute of deep and 2 minute of light sleep
|
||
|
|
prv_feed_cannned_accel_data(120, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(120, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
prv_feed_cannned_accel_data(120, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep logic to run.
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * ACTIVITY_SESSION_UPDATE_MIN, 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Advance to next day
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_HOUR * 24, 0, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 3 min, 3 minute of deep and 3 minute of light sleep
|
||
|
|
prv_feed_cannned_accel_data(180, 100, ActivitySleepStateAwake);
|
||
|
|
prv_feed_cannned_accel_data(180, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
prv_feed_cannned_accel_data(180, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep logic to run.
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * ACTIVITY_SESSION_UPDATE_MIN, 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Make sure they are what we expected
|
||
|
|
prv_assert_known_settings();
|
||
|
|
|
||
|
|
|
||
|
|
// Extract activity settings file from PFS and save to the local file system
|
||
|
|
char out_path[strlen(CLAR_FIXTURE_PATH) + strlen(ACTIVITY_FIXTURE_PATH) + strlen(filename) + 3];
|
||
|
|
sprintf(out_path, "%s/%s/%s", CLAR_FIXTURE_PATH, ACTIVITY_FIXTURE_PATH, filename);
|
||
|
|
|
||
|
|
// Open and read the settings file from PFS
|
||
|
|
int fd = pfs_open(ACTIVITY_SETTINGS_FILE_NAME, OP_FLAG_READ, FILE_TYPE_STATIC,
|
||
|
|
ACTIVITY_SETTINGS_FILE_LEN);
|
||
|
|
cl_assert(fd >= S_SUCCESS);
|
||
|
|
size_t size = pfs_get_file_size(fd);
|
||
|
|
uint8_t *buf = malloc(size);
|
||
|
|
cl_assert(buf != NULL);
|
||
|
|
cl_assert(pfs_read(fd, buf, size) == size);
|
||
|
|
pfs_close(fd);
|
||
|
|
|
||
|
|
// Save it to the local file system
|
||
|
|
FILE *file = fopen(out_path, "wb");
|
||
|
|
cl_assert(file != NULL);
|
||
|
|
cl_assert_equal_i(fwrite(buf, size, 1, file), 1);
|
||
|
|
fclose(file);
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
printf("\nSaved current settings file to %s", out_path);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Create the settings file in PFS from a file saved in the local file system
|
||
|
|
static void prv_load_settings_file_onto_pfs(const char *filename, const char *pfs_name) {
|
||
|
|
char in_path[strlen(CLAR_FIXTURE_PATH) + strlen(ACTIVITY_FIXTURE_PATH) + strlen(filename) + 3];
|
||
|
|
sprintf(in_path, "%s/%s/%s", CLAR_FIXTURE_PATH, ACTIVITY_FIXTURE_PATH, filename);
|
||
|
|
|
||
|
|
// check that file exists and fits in buffer
|
||
|
|
struct stat st;
|
||
|
|
cl_assert(stat(in_path, &st) == 0);
|
||
|
|
|
||
|
|
FILE *file = fopen(in_path, "r");
|
||
|
|
cl_assert(file);
|
||
|
|
|
||
|
|
uint8_t buf[st.st_size];
|
||
|
|
// copy file to fake flash storage
|
||
|
|
cl_assert(fread(buf, 1, st.st_size, file) > 0);
|
||
|
|
|
||
|
|
pfs_remove(pfs_name);
|
||
|
|
int fd = pfs_open(pfs_name, OP_FLAG_WRITE, FILE_TYPE_STATIC, st.st_size);
|
||
|
|
cl_assert(fd >= 0);
|
||
|
|
int bytes_written = pfs_write(fd, buf, st.st_size);
|
||
|
|
cl_assert(st.st_size == bytes_written);
|
||
|
|
pfs_close(fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we correctly migrate older versions of activity settings files
|
||
|
|
void test_activity__migrate_settings(void) {
|
||
|
|
|
||
|
|
// Uncomment this call to prv_save_known_settings_file() in order to save the current version
|
||
|
|
// of settings to the fixture directory. After doing this, you will need to git add it and modify
|
||
|
|
// this migration test to read it in and verify its contents after migration.
|
||
|
|
// prv_save_known_settings_file("activity_settings.v1");
|
||
|
|
|
||
|
|
// Load the v1 settings format.
|
||
|
|
prv_load_settings_file_onto_pfs("activity_settings.v1", ACTIVITY_SETTINGS_FILE_NAME);
|
||
|
|
|
||
|
|
// Make sure it got migrated correctly.
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
prv_assert_known_settings();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------
|
||
|
|
// fake_event callback used to look for sleep events generated by the health_events test
|
||
|
|
static PebbleEvent s_captured_sleep_event = { };
|
||
|
|
static int s_num_captured_sleep_events = 0;
|
||
|
|
static void prv_fake_sleep_event_cb(PebbleEvent *event) {
|
||
|
|
if ((event->type == PEBBLE_HEALTH_SERVICE_EVENT)
|
||
|
|
&& (event->health_event.type == HealthEventSleepUpdate)) {
|
||
|
|
s_captured_sleep_event = *event;
|
||
|
|
s_num_captured_sleep_events++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------
|
||
|
|
// fake_event callback used to look for history update events generated by the health_events test
|
||
|
|
static PebbleEvent s_captured_history_event = { };
|
||
|
|
static int s_num_captured_history_events = 0;
|
||
|
|
static void prv_fake_history_event_cb(PebbleEvent *event) {
|
||
|
|
if ((event->type == PEBBLE_HEALTH_SERVICE_EVENT)
|
||
|
|
&& (event->health_event.type == HealthEventSignificantUpdate)) {
|
||
|
|
s_captured_history_event = *event;
|
||
|
|
s_num_captured_history_events++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we generate health events at the appropriate time
|
||
|
|
void test_activity__health_events(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// -----------------------------------
|
||
|
|
// Test that we receive step update events
|
||
|
|
fake_event_reset_count();
|
||
|
|
// Feed in 100 steps/minute over 1 minute. We should get some step update events
|
||
|
|
prv_feed_cannned_accel_data(1 * SECONDS_PER_MINUTE, 100, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
uint32_t event_count = fake_event_get_count();
|
||
|
|
// Our fake algorithm generates a step update once a second
|
||
|
|
cl_assert_equal_i(event_count, 1 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
PebbleEvent event = fake_event_get_last();
|
||
|
|
cl_assert_equal_i(event.type, PEBBLE_HEALTH_SERVICE_EVENT);
|
||
|
|
cl_assert_equal_i(event.health_event.type, HealthEventMovementUpdate);
|
||
|
|
|
||
|
|
// -----------------------------------
|
||
|
|
// Test that we receive sleep update events
|
||
|
|
prv_reset_captured_dls_data();
|
||
|
|
|
||
|
|
// Falling asleep for 30 minutes
|
||
|
|
prv_feed_cannned_accel_data(30 * SECONDS_PER_MINUTE, 5, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Starting at 10:31pm: 1 Cycle of light (60 min), deep (50 min)
|
||
|
|
fake_event_reset_count();
|
||
|
|
fake_event_set_callback(prv_fake_sleep_event_cb);
|
||
|
|
s_captured_sleep_event = (PebbleEvent) { };
|
||
|
|
s_num_captured_sleep_events = 0;
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
prv_feed_cannned_accel_data(50 * SECONDS_PER_MINUTE, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(15 * SECONDS_PER_MINUTE, 0, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(60 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
prv_feed_cannned_accel_data(50 * SECONDS_PER_MINUTE, 0, ActivitySleepStateRestfulSleep);
|
||
|
|
|
||
|
|
// Wait long enough for our recompute sleep logic to run.
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_MINUTE * ACTIVITY_SESSION_UPDATE_MIN, 60,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// See if we got the expected sleep events
|
||
|
|
cl_assert(s_num_captured_sleep_events > 0);
|
||
|
|
|
||
|
|
event = s_captured_sleep_event;
|
||
|
|
cl_assert_equal_i(event.type, PEBBLE_HEALTH_SERVICE_EVENT);
|
||
|
|
cl_assert_equal_i(event.health_event.type, HealthEventSleepUpdate);
|
||
|
|
|
||
|
|
// -----------------------------------
|
||
|
|
// Test that we receive history update events
|
||
|
|
fake_event_reset_count();
|
||
|
|
fake_event_set_callback(prv_fake_history_event_cb);
|
||
|
|
s_captured_history_event = (PebbleEvent) { };
|
||
|
|
s_num_captured_history_events = 0;
|
||
|
|
|
||
|
|
// Get the current day_id
|
||
|
|
int32_t actual;
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, &actual);
|
||
|
|
|
||
|
|
// Wait long enough for a midnight rollover. All tests start at 5pm, so if we wait
|
||
|
|
// 7 hours, we should get a midnight rollover
|
||
|
|
prv_feed_cannned_accel_data(7 * SECONDS_PER_HOUR, 0, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// See if we got the expected history events
|
||
|
|
cl_assert_equal_i(s_num_captured_history_events, 1);
|
||
|
|
|
||
|
|
event = s_captured_history_event;
|
||
|
|
cl_assert_equal_i(event.type, PEBBLE_HEALTH_SERVICE_EVENT);
|
||
|
|
cl_assert_equal_i(event.health_event.type, HealthEventSignificantUpdate);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test derived sleep metrics after the watch goes through a timezone change.
|
||
|
|
void test_activity__sleep_after_timezone_change(void) {
|
||
|
|
int32_t value;
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------
|
||
|
|
// Let's start out in EST time when tracking starts. All of our tests start at 5pm UTC, which is
|
||
|
|
// 12pm EST. Let's start out in this time zone then switch back to PST right before we fall
|
||
|
|
// asleep. This replicates the conditions that resulted in PBL-24823
|
||
|
|
TimezoneInfo tz_info = {
|
||
|
|
.tm_zone = "EST",
|
||
|
|
.tm_gmtoff = -5 * SECONDS_PER_HOUR,
|
||
|
|
};
|
||
|
|
time_util_update_timezone(&tz_info);
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Advance to 6pm EST
|
||
|
|
prv_feed_cannned_accel_data(6 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// switch into PST (which would be 3pm)
|
||
|
|
tz_info = (TimezoneInfo) {
|
||
|
|
.tm_zone = "PST",
|
||
|
|
.tm_gmtoff = -8 * SECONDS_PER_HOUR,
|
||
|
|
};
|
||
|
|
time_util_update_timezone(&tz_info);
|
||
|
|
|
||
|
|
// Walk some more until 11pm PST
|
||
|
|
prv_feed_cannned_accel_data(8 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Starting at 11pm: 2 Cycles of 3 hrs each light (165 min), awake (15 min)
|
||
|
|
for (int i = 0; i < 2; i++) {
|
||
|
|
prv_feed_cannned_accel_data(165 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(15 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
}
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepEnterAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 23 * SECONDS_PER_HOUR /* 11pm */);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepTotalSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 330 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepExitAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 4 * SECONDS_PER_HOUR + 45 * SECONDS_PER_MINUTE /* 4:45am */);
|
||
|
|
|
||
|
|
// Assert that we got the same sleep sessions using the activity service as we do using
|
||
|
|
// the health API
|
||
|
|
prv_assert_equal_activity_and_health_sleep_sessions(2);
|
||
|
|
|
||
|
|
// ----------------------------------------------------------------------------
|
||
|
|
// The previous test left us at 5am PST. Let's try going the other way and switch from PST to
|
||
|
|
// EST right before we fall asleep
|
||
|
|
// Advance to 11pm PST
|
||
|
|
prv_feed_cannned_accel_data(18 * SECONDS_PER_HOUR, 50, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// It is now 11pm PST. Switch to EST, which would be 2am
|
||
|
|
tz_info = (TimezoneInfo) {
|
||
|
|
.tm_zone = "EST",
|
||
|
|
.tm_gmtoff = -5 * SECONDS_PER_HOUR,
|
||
|
|
};
|
||
|
|
time_util_update_timezone(&tz_info);
|
||
|
|
|
||
|
|
// Starting at 2am EST: 2 Cycles of 3 hrs each light (165 min), awake (15 min)
|
||
|
|
for (int i = 0; i < 2; i++) {
|
||
|
|
prv_feed_cannned_accel_data(165 * SECONDS_PER_MINUTE, 0, ActivitySleepStateLightSleep);
|
||
|
|
|
||
|
|
prv_feed_cannned_accel_data(15 * SECONDS_PER_MINUTE, 20, ActivitySleepStateAwake);
|
||
|
|
}
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepEnterAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 2 * SECONDS_PER_HOUR /* 2am */);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepTotalSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 330 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricSleepExitAtSeconds, 1, &value);
|
||
|
|
cl_assert_equal_i(value, 7 * SECONDS_PER_HOUR + 45 * SECONDS_PER_MINUTE /* 7:45am */);
|
||
|
|
|
||
|
|
// Assert that we got the same sleep sessions using the activity service as we do using
|
||
|
|
// the health API
|
||
|
|
prv_assert_equal_activity_and_health_sleep_sessions(2);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that the health service correctly interpolates when asked for a metric over partial days
|
||
|
|
void test_activity__health_service_interpolation(void) {
|
||
|
|
// Let's start out in PST time when tracking starts. All of our tests start at 5pm UTC, which is
|
||
|
|
// 9am PST.
|
||
|
|
TimezoneInfo tz_info = {
|
||
|
|
.tm_zone = "PST",
|
||
|
|
.tm_gmtoff = -8 * SECONDS_PER_HOUR,
|
||
|
|
};
|
||
|
|
time_util_update_timezone(&tz_info);
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 10 minutes, for a total of 1000 steps for today
|
||
|
|
prv_feed_cannned_accel_data(10 * SECONDS_PER_MINUTE, 100, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
// Wait long enough until we start the next day (15 hours)
|
||
|
|
prv_feed_cannned_accel_data(SECONDS_PER_HOUR * 15, 0,
|
||
|
|
ActivitySleepStateAwake);
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){0, 1000, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
|
||
|
|
// Feed in 100 steps/min over 20 minutes, for a total of 2000 steps for today
|
||
|
|
prv_feed_cannned_accel_data(20 * SECONDS_PER_MINUTE, 100, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
ASSERT_EQUAL_METRIC_HISTORY(ActivityMetricStepCount,
|
||
|
|
((const uint32_t [ACTIVITY_HISTORY_DAYS]){2000, 1000, 0, 0, 0, 0, 0}));
|
||
|
|
|
||
|
|
|
||
|
|
// If we ask for the sum of the latter half of yesterday, we should get 500
|
||
|
|
HealthValue steps = health_service_sum(
|
||
|
|
HealthMetricStepCount, time_start_of_today() - (12 * SECONDS_PER_HOUR),
|
||
|
|
time_start_of_today());
|
||
|
|
cl_assert_equal_i(steps, 500);
|
||
|
|
|
||
|
|
// If we ask for the sum from latter half of yesterday till now, we should get 2500
|
||
|
|
steps = health_service_sum(
|
||
|
|
HealthMetricStepCount, time_start_of_today() - (12 * SECONDS_PER_HOUR), rtc_get_time());
|
||
|
|
cl_assert_equal_i(steps, 2500);
|
||
|
|
|
||
|
|
// If we ask for the sum from latter half of yesterday till half of today, we should get 1500
|
||
|
|
time_t elapsed_today = rtc_get_time() - time_start_of_today();
|
||
|
|
steps = health_service_sum(
|
||
|
|
HealthMetricStepCount, time_start_of_today() - (12 * SECONDS_PER_HOUR),
|
||
|
|
time_start_of_today() + (elapsed_today / 2));
|
||
|
|
cl_assert_equal_i(steps, 1500);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test distance using various speeds and user dimensions
|
||
|
|
typedef struct {
|
||
|
|
int height_in;
|
||
|
|
int gender;
|
||
|
|
int steps;
|
||
|
|
float seconds;
|
||
|
|
int exp_distance_m; // expected distance
|
||
|
|
} DistanceTestParams;
|
||
|
|
|
||
|
|
void test_activity__distance(void) {
|
||
|
|
int32_t value;
|
||
|
|
|
||
|
|
// The health_service calls expect to be in the app or worker task
|
||
|
|
stub_pebble_tasks_set_current(PebbleTask_App);
|
||
|
|
|
||
|
|
DistanceTestParams tests[] = {
|
||
|
|
{69, ActivityGenderMale, 19177, 6360, 23352},
|
||
|
|
{69, ActivityGenderMale, 10351, 3600, 11764},
|
||
|
|
{69, ActivityGenderMale, 3003, 1560, 2398},
|
||
|
|
{69, ActivityGenderMale, 3423, 2100, 2881},
|
||
|
|
{65, ActivityGenderFemale, 6940, 3120, 8047},
|
||
|
|
{65, ActivityGenderFemale, 4577, 2460, 3508},
|
||
|
|
{63, ActivityGenderFemale, 4738, 1860, 4989},
|
||
|
|
{63, ActivityGenderFemale, 4799, 1860, 5134},
|
||
|
|
{63, ActivityGenderFemale, 2896, 1500, 2334},
|
||
|
|
{71, ActivityGenderMale, 7529, 4020, 5568},
|
||
|
|
{67, ActivityGenderMale, 6592, 3960, 6067},
|
||
|
|
{73, ActivityGenderMale, 4467, 1740, 5118},
|
||
|
|
{73, ActivityGenderMale, 4080, 1800, 5102},
|
||
|
|
{73, ActivityGenderMale, 2890, 1680, 2382},
|
||
|
|
{73, ActivityGenderMale, 4143, 2400, 3251},
|
||
|
|
{64, ActivityGenderMale, 4373, 1823, 4168},
|
||
|
|
{64, ActivityGenderMale, 642, 384, 483},
|
||
|
|
{64, ActivityGenderMale, 4455, 1819, 4072},
|
||
|
|
{64, ActivityGenderMale, 2008, 1229, 1448},
|
||
|
|
{64, ActivityGenderMale, 2217, 1302, 1674},
|
||
|
|
{64, ActivityGenderMale, 4568, 1820, 4152},
|
||
|
|
};
|
||
|
|
|
||
|
|
// Init the time
|
||
|
|
struct tm time_tm = s_init_time_tm;
|
||
|
|
time_tm.tm_mday += 1;
|
||
|
|
time_t utc_sec = mktime(&time_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
int act_distance[ARRAY_LENGTH(tests)];
|
||
|
|
const int k_elapsed_sec = 2 * SECONDS_PER_MINUTE;
|
||
|
|
|
||
|
|
// Evaluate each test case
|
||
|
|
for (int i = 0; i < ARRAY_LENGTH(tests); i++) {
|
||
|
|
DistanceTestParams *params = &tests[i];
|
||
|
|
|
||
|
|
// Advance to new day to reset the distance
|
||
|
|
utc_sec += SECONDS_PER_DAY;
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
prv_activity_init_and_set_enabled(true);
|
||
|
|
|
||
|
|
// Set the user's dimensions
|
||
|
|
activity_prefs_set_height_mm((int)(params->height_in * 25.4));
|
||
|
|
activity_prefs_set_gender(params->gender);
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Feed in the test cadence for 2 minutes. Compute the expected distance in 2 minutes
|
||
|
|
// as well
|
||
|
|
int steps_per_minute = (int)((float)params->steps / params->seconds * SECONDS_PER_MINUTE);
|
||
|
|
int exp_distance_m = ROUND(params->exp_distance_m * k_elapsed_sec, params->seconds);
|
||
|
|
|
||
|
|
// Feed in the test cadence for the given amount of time
|
||
|
|
prv_feed_cannned_accel_data(k_elapsed_sec, steps_per_minute, ActivitySleepStateAwake);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, &value);
|
||
|
|
cl_assert_near(value, ROUND(steps_per_minute * k_elapsed_sec, SECONDS_PER_MINUTE), 5);
|
||
|
|
|
||
|
|
activity_get_metric(ActivityMetricDistanceMeters, 1, &value);
|
||
|
|
act_distance[i] = value;
|
||
|
|
float err = abs(exp_distance_m - value);
|
||
|
|
float pct_err = err * 100.0 / exp_distance_m;
|
||
|
|
printf("\nTest %d: height:%d, steps:%d, seconds:%.1f, exp_distance:%d, exp_distance_2min:%d, "
|
||
|
|
"act_distance_2min:%"PRIu32", pct_err: %.2f%% \n", i, params->height_in, params->steps,
|
||
|
|
params->seconds, params->exp_distance_m, exp_distance_m, value, pct_err);
|
||
|
|
|
||
|
|
// Check the percent error
|
||
|
|
cl_assert(pct_err < 25);
|
||
|
|
cl_assert_equal_i(value, health_service_sum_today(HealthMetricWalkedDistanceMeters));
|
||
|
|
|
||
|
|
activity_stop_tracking();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Print summary of results
|
||
|
|
printf("\ntest height steps seconds cadence exp_dist exp_dist_2min act_dist_2min %%err");
|
||
|
|
printf("\n------------------------------------------------------------------------------------");
|
||
|
|
float pct_err_sum = 0;
|
||
|
|
for (int i = 0; i < ARRAY_LENGTH(tests); i++) {
|
||
|
|
DistanceTestParams *params = &tests[i];
|
||
|
|
|
||
|
|
int steps_per_minute = (int)((float)params->steps / params->seconds * SECONDS_PER_MINUTE);
|
||
|
|
int exp_distance_m = ROUND(params->exp_distance_m * k_elapsed_sec, params->seconds);
|
||
|
|
float err = act_distance[i] - exp_distance_m;
|
||
|
|
float pct_err = err * 100.0 / exp_distance_m;
|
||
|
|
printf("\n%4d %5d %4d %7.2f %7d %7d %13d %13d %+.2f",
|
||
|
|
i, params->height_in, params->steps, params->seconds, steps_per_minute,
|
||
|
|
params->exp_distance_m, exp_distance_m, act_distance[i], pct_err);
|
||
|
|
pct_err_sum += pct_err >= 0 ? pct_err : -pct_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
printf("\n--------------------------");
|
||
|
|
float avg_pct_err = pct_err_sum / ARRAY_LENGTH(tests);
|
||
|
|
printf("\nAVERAGE PCT ERROR: %.2f", avg_pct_err);
|
||
|
|
|
||
|
|
// Check the overall percent error
|
||
|
|
cl_assert(avg_pct_err < 10);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// --------------------------------------------------------------------------------------------
|
||
|
|
// Advance through time simulating the heart rate manager calls
|
||
|
|
static int s_num_hrm_callbacks;
|
||
|
|
static void prv_advance_time_hr(uint32_t num_sec, uint8_t bpm, HRMQuality quality,
|
||
|
|
bool force_continuous) {
|
||
|
|
// Call the minute handler, which computes the minute stats and saves them to data logging
|
||
|
|
// as well as the sleep PFS file.
|
||
|
|
for (int i = 0; i < num_sec; i++) {
|
||
|
|
fake_rtc_set_ticks(rtc_get_ticks() + configTICK_RATE_HZ);
|
||
|
|
rtc_set_time(rtc_get_time() + 1);
|
||
|
|
|
||
|
|
if ((s_hrm_manager_update_interval == 1) || force_continuous) {
|
||
|
|
PebbleHRMEvent hrm_event = {
|
||
|
|
.event_type = HRMEvent_BPM,
|
||
|
|
.bpm.bpm = bpm,
|
||
|
|
.bpm.quality = quality,
|
||
|
|
};
|
||
|
|
prv_hrm_subscription_cb(&hrm_event, NULL);
|
||
|
|
s_num_hrm_callbacks++;
|
||
|
|
}
|
||
|
|
if ((rtc_get_time() % SECONDS_PER_MINUTE) == 0) {
|
||
|
|
prv_minute_system_task_cb(NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we subscribe to the HR events at the expected times
|
||
|
|
void test_activity__hrm_sampling_period(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
s_test_alg_state.orientation = 0x11; // Not flat
|
||
|
|
|
||
|
|
prv_advance_time_hr(ACTIVITY_DEFAULT_HR_PERIOD_SEC, 100 /*bpm*/, HRMQuality_Good, false /*force_continuous*/);
|
||
|
|
|
||
|
|
// Should be 1 second sampling when we start up
|
||
|
|
cl_assert_equal_i(s_hrm_manager_update_interval, 1);
|
||
|
|
|
||
|
|
// The last update time should be 0
|
||
|
|
int32_t last_update_utc;
|
||
|
|
activity_get_metric(ActivityMetricHeartRateRawUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert_equal_i(last_update_utc, 0);
|
||
|
|
|
||
|
|
// Simulate callbacks one second away from turning down the sampling rate
|
||
|
|
// Use Acceptable because of the short circuiting in `prv_heart_rate_subscription_update`
|
||
|
|
prv_advance_time_hr(ACTIVITY_DEFAULT_HR_ON_TIME_SEC - 1, 100 /*bpm*/,
|
||
|
|
HRMQuality_Acceptable, false /*force_continuous*/);
|
||
|
|
|
||
|
|
// The last update time should be within a second
|
||
|
|
activity_get_metric(ActivityMetricHeartRateRawUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert(last_update_utc >= rtc_get_time() - 1);
|
||
|
|
cl_assert(last_update_utc <= rtc_get_time());
|
||
|
|
|
||
|
|
// Should still be sampling every 1 second
|
||
|
|
cl_assert_equal_i(s_hrm_manager_update_interval, 1);
|
||
|
|
|
||
|
|
// Tick one more second, should trigger slow sampling
|
||
|
|
prv_advance_time_hr(1, 100 /*bpm*/, HRMQuality_Good, false /*force_continuous*/);
|
||
|
|
// Should be back to no sampling by now (very large sampling period)
|
||
|
|
cl_assert(s_hrm_manager_update_interval > SECONDS_PER_HOUR);
|
||
|
|
|
||
|
|
// Advance to our next sampling period, but the watch is flat so we shouldn't start sampling
|
||
|
|
s_test_alg_state.orientation = 0x00; // Flat
|
||
|
|
prv_advance_time_hr(ACTIVITY_DEFAULT_HR_PERIOD_SEC, 100 /*bpm*/, HRMQuality_Good, false /*force_continuous*/);
|
||
|
|
cl_assert(s_hrm_manager_update_interval > SECONDS_PER_HOUR);
|
||
|
|
|
||
|
|
// Advance to our next sampling period, the watch is no longer flat so we should be sampling
|
||
|
|
s_test_alg_state.orientation = 0x22; // Not flat
|
||
|
|
prv_advance_time_hr(ACTIVITY_DEFAULT_HR_PERIOD_SEC, 100 /*bpm*/, HRMQuality_Good, false /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_hrm_manager_update_interval, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that average heart rate is reported correctly
|
||
|
|
void test_activity__hrm_median(void) {
|
||
|
|
int32_t median, total_weight;
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// Reset the median
|
||
|
|
activity_metrics_prv_reset_hr_stats();
|
||
|
|
|
||
|
|
// Our previous median should be since we have no data
|
||
|
|
int32_t last_median;
|
||
|
|
int32_t last_update_utc;
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredBPM, 1, &last_median);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert_equal_i(last_median, 0);
|
||
|
|
cl_assert_equal_i(last_update_utc, 0);
|
||
|
|
|
||
|
|
// Simulate some HRM callbacks with no heart rate, should get 0 median
|
||
|
|
prv_advance_time_hr(10 /*sec*/, 0 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
activity_metrics_prv_get_median_hr_bpm(&median, &total_weight);
|
||
|
|
cl_assert_equal_i(median, 0);
|
||
|
|
cl_assert_equal_i(total_weight, 0);
|
||
|
|
|
||
|
|
// Our previous median should be since we have no data (valid data)
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredBPM, 1, &last_median);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert_equal_i(last_median, 0);
|
||
|
|
cl_assert_equal_i(last_update_utc, 0);
|
||
|
|
|
||
|
|
// Simulate some HRM callbacks with non-zero heart rate
|
||
|
|
prv_advance_time_hr(3 /*sec*/, 50 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
prv_advance_time_hr(3 /*sec*/, 100 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 51 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
prv_advance_time_hr(8 /*sec*/, 120 /*hr*/, HRMQuality_Worst, true /*force_continuous*/);
|
||
|
|
prv_minute_system_task_cb(NULL);
|
||
|
|
activity_metrics_prv_get_median_hr_bpm(&median, &total_weight);
|
||
|
|
cl_assert_equal_i(median, 51);
|
||
|
|
|
||
|
|
// The last median should be stored and accessable via the LastStableBPM metric
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredBPM, 1, &last_median);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert_equal_i(last_median, 51);
|
||
|
|
cl_assert(last_update_utc >= rtc_get_time() - 1);
|
||
|
|
cl_assert(last_update_utc <= rtc_get_time());
|
||
|
|
|
||
|
|
// Reset the stats, the median should be 0
|
||
|
|
activity_metrics_prv_reset_hr_stats();
|
||
|
|
activity_metrics_prv_get_median_hr_bpm(&median, &total_weight);
|
||
|
|
cl_assert_equal_i(median, 0);
|
||
|
|
|
||
|
|
// But the last stable BPM shouldn't get wiped
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredBPM, 1, &last_median);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateFilteredUpdatedTimeUTC, 1, &last_update_utc);
|
||
|
|
cl_assert_equal_i(last_median, 51);
|
||
|
|
cl_assert(last_update_utc >= rtc_get_time() - 1);
|
||
|
|
cl_assert(last_update_utc <= rtc_get_time());
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t s_num_hr_events;
|
||
|
|
static PebbleHealthEvent s_last_hr_event;
|
||
|
|
static void prv_fake_hr_event_handler(PebbleEvent *e) {
|
||
|
|
s_num_hr_events++;
|
||
|
|
s_last_hr_event = e->health_event;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that some HRM events aren't passed on from activity service
|
||
|
|
void test_activity__hrm_ignore(void) {
|
||
|
|
int32_t median, total_weight;
|
||
|
|
|
||
|
|
s_num_hr_events = 0;
|
||
|
|
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
fake_event_reset_count();
|
||
|
|
fake_event_set_callback(prv_fake_hr_event_handler);
|
||
|
|
|
||
|
|
// Should not fire off an event. Bad HR reading
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 0 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 0);
|
||
|
|
|
||
|
|
// Should fire off an event. Good HR and Good quality
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 120 /*hr*/, HRMQuality_Good, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 1);
|
||
|
|
|
||
|
|
// Should fire off an event. OffWrist, tell clients
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 120 /*hr*/, HRMQuality_OffWrist, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 2);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.current_bpm, 0);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.quality, HRMQuality_OffWrist);
|
||
|
|
|
||
|
|
// Should fire off an event. OffWrist, tell clients
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 0 /*hr*/, HRMQuality_OffWrist, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 3);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.current_bpm, 0);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.quality, HRMQuality_OffWrist);
|
||
|
|
|
||
|
|
// Should fire off an event. Good HR and Good Quality
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 120 /*hr*/, HRMQuality_Excellent, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 4);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.current_bpm, 120);
|
||
|
|
cl_assert_equal_i(s_last_hr_event.data.heart_rate_update.quality, HRMQuality_Excellent);
|
||
|
|
|
||
|
|
// Should not fire off an event. Bad HR reading
|
||
|
|
prv_advance_time_hr(1 /*sec*/, 20 /*hr*/, HRMQuality_Excellent, true /*force_continuous*/);
|
||
|
|
cl_assert_equal_i(s_num_hr_events, 4);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Today is Thursday
|
||
|
|
void test_activity__prv_set_metric(void) {
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
int32_t metric_values[ACTIVITY_HISTORY_DAYS] = {0};
|
||
|
|
|
||
|
|
// Set today's value
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Thursday, 1111);
|
||
|
|
|
||
|
|
// Set yesterday's value
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Wednesday, 2222);
|
||
|
|
|
||
|
|
// Set last friday value
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Friday, 3333);
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 7, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 1111);
|
||
|
|
cl_assert_equal_i(metric_values[1], 2222);
|
||
|
|
cl_assert_equal_i(metric_values[2], 0000);
|
||
|
|
cl_assert_equal_i(metric_values[3], 0000);
|
||
|
|
cl_assert_equal_i(metric_values[4], 0000);
|
||
|
|
cl_assert_equal_i(metric_values[5], 0000);
|
||
|
|
cl_assert_equal_i(metric_values[6], 3333);
|
||
|
|
|
||
|
|
// Set the current value to something larger
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Thursday, 4444);
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 4444);
|
||
|
|
|
||
|
|
// Set the current value to something smaller (will be ignored)
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Thursday, 1);
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 4444);
|
||
|
|
|
||
|
|
// Verify some other metrics work
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricActiveSeconds, Thursday, 60);
|
||
|
|
activity_get_metric(ActivityMetricActiveSeconds, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 60);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricDistanceMeters, Thursday, 66);
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricDistanceMeters, Wednesday, 22);
|
||
|
|
activity_get_metric(ActivityMetricDistanceMeters, 2, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 66);
|
||
|
|
cl_assert_equal_i(metric_values[1], 22);
|
||
|
|
cl_assert_equal_i(activity_metrics_prv_get_distance_mm(), 66 * MM_PER_METER);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricActiveKCalories, Thursday, 22);
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricActiveKCalories, Wednesday, 33);
|
||
|
|
activity_get_metric(ActivityMetricActiveKCalories, 2, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 22);
|
||
|
|
cl_assert_equal_i(metric_values[1], 33);
|
||
|
|
cl_assert_equal_i(activity_metrics_prv_get_active_calories(), 22 * ACTIVITY_CALORIES_PER_KCAL);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricRestingKCalories, Thursday, 2000);
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricRestingKCalories, Wednesday, 44);
|
||
|
|
activity_get_metric(ActivityMetricRestingKCalories, 2, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 2000);
|
||
|
|
cl_assert_equal_i(metric_values[1], 44);
|
||
|
|
cl_assert_equal_i(activity_metrics_prv_get_resting_calories(), 2000 * ACTIVITY_CALORIES_PER_KCAL);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricSleepTotalSeconds, Thursday, 60);
|
||
|
|
activity_get_metric(ActivityMetricSleepTotalSeconds, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 60);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricSleepRestfulSeconds, Wednesday, 60);
|
||
|
|
activity_get_metric(ActivityMetricSleepRestfulSeconds, 2, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[1], 60);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricSleepEnterAtSeconds, Thursday, 60);
|
||
|
|
activity_get_metric(ActivityMetricSleepEnterAtSeconds, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 60);
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricSleepExitAtSeconds, Wednesday, 60);
|
||
|
|
activity_get_metric(ActivityMetricSleepExitAtSeconds, 2, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[1], 60);
|
||
|
|
|
||
|
|
activity_stop_tracking();
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
activity_metrics_prv_set_metric(ActivityMetricStepCount, Thursday, 5555);
|
||
|
|
activity_get_metric(ActivityMetricStepCount, 1, metric_values);
|
||
|
|
cl_assert_equal_i(metric_values[0], 4444);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test that we report the that a run session is ongoing.
|
||
|
|
void test_activity__activity_sessions_run_ongoing_then_end(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// No sessions active, ensure that asking if a run is ongoing returns false
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Run));
|
||
|
|
cl_assert_equal_i(0, health_service_peek_current_activities());
|
||
|
|
|
||
|
|
// Start on known boundary
|
||
|
|
struct tm start_tm = {
|
||
|
|
// Jan 1, 2015, 5am
|
||
|
|
.tm_hour = 5,
|
||
|
|
.tm_mday = 1,
|
||
|
|
.tm_mon = 0,
|
||
|
|
.tm_year = 115
|
||
|
|
};
|
||
|
|
time_t utc_sec = mktime(&start_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
// Add a run session
|
||
|
|
const time_t time_elapsed = (20 * SECONDS_PER_MINUTE);
|
||
|
|
ActivitySession run_activity = {
|
||
|
|
.start_utc = utc_sec - time_elapsed,
|
||
|
|
.length_min = time_elapsed,
|
||
|
|
.type = ActivitySessionType_Run,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&run_activity);
|
||
|
|
|
||
|
|
// Run session active, ensure that asking if a run is ongoing returns true
|
||
|
|
cl_assert_equal_b(true, activity_sessions_is_session_type_ongoing(ActivitySessionType_Run));
|
||
|
|
cl_assert_equal_i(HealthActivityRun, health_service_peek_current_activities());
|
||
|
|
|
||
|
|
// Finish the run session
|
||
|
|
utc_sec += (10 * SECONDS_PER_MINUTE);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
run_activity.ongoing = false;
|
||
|
|
|
||
|
|
// Update session
|
||
|
|
activity_sessions_prv_add_activity_session(&run_activity);
|
||
|
|
|
||
|
|
// Run session ended, ensure that asking if a run is ongoing returns false
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Run));
|
||
|
|
cl_assert_equal_i(0, health_service_peek_current_activities());
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we report the that a Sleep session is ongoing.
|
||
|
|
void test_activity__activity_sessions_sleep_ongoing_then_delete(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// No sessions active, ensure that asking if a sleep session is ongoing returns false
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Sleep));
|
||
|
|
cl_assert_equal_i(0, health_service_peek_current_activities());
|
||
|
|
|
||
|
|
// Start on known boundary
|
||
|
|
struct tm start_tm = {
|
||
|
|
// Jan 1, 2015, 5am
|
||
|
|
.tm_hour = 5,
|
||
|
|
.tm_mday = 1,
|
||
|
|
.tm_mon = 0,
|
||
|
|
.tm_year = 115
|
||
|
|
};
|
||
|
|
time_t utc_sec = mktime(&start_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
// Add a Sleep session
|
||
|
|
const time_t time_elapsed = (120 * SECONDS_PER_MINUTE);
|
||
|
|
ActivitySession sleep_session = {
|
||
|
|
.start_utc = utc_sec - time_elapsed,
|
||
|
|
.length_min = time_elapsed,
|
||
|
|
.type = ActivitySessionType_Sleep,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&sleep_session);
|
||
|
|
|
||
|
|
// Flip the switch to say we are in light sleep.
|
||
|
|
activity_private_state()->sleep_data.cur_state = ActivitySleepStateLightSleep;
|
||
|
|
|
||
|
|
// Sleep session active, ensure that asking if a Sleep is ongoing returns true
|
||
|
|
cl_assert_equal_b(true, activity_sessions_is_session_type_ongoing(ActivitySessionType_Sleep));
|
||
|
|
cl_assert_equal_i(HealthActivitySleep, health_service_peek_current_activities());
|
||
|
|
|
||
|
|
// Delete session
|
||
|
|
activity_sessions_prv_delete_activity_session(&sleep_session);
|
||
|
|
|
||
|
|
// Flip the switch to say we are in an awake state.
|
||
|
|
activity_private_state()->sleep_data.cur_state = ActivitySleepStateAwake;
|
||
|
|
|
||
|
|
// Sleep session ended, ensure that asking if a Sleep is ongoing returns false
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Sleep));
|
||
|
|
cl_assert_equal_i(0, health_service_peek_current_activities());
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we report the that multiple sessions are ongoing.
|
||
|
|
void test_activity__activity_sessions_ongoing_multiple(void) {
|
||
|
|
// Start activity tracking. This method assumes it can be called from any task, so we must
|
||
|
|
// invoke system callbacks to handle its KernelBG callback.
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
|
||
|
|
// No sessions active, ensure that asking for run,walk,sleep returns false
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Run));
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Walk));
|
||
|
|
cl_assert_equal_b(false, activity_sessions_is_session_type_ongoing(ActivitySessionType_Sleep));
|
||
|
|
cl_assert_equal_i(0, health_service_peek_current_activities());
|
||
|
|
|
||
|
|
// Start on known boundary
|
||
|
|
struct tm start_tm = {
|
||
|
|
// Jan 1, 2015, 5am
|
||
|
|
.tm_hour = 5,
|
||
|
|
.tm_mday = 1,
|
||
|
|
.tm_mon = 0,
|
||
|
|
.tm_year = 115
|
||
|
|
};
|
||
|
|
time_t utc_sec = mktime(&start_tm);
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
|
||
|
|
const time_t time_elapsed = (20 * SECONDS_PER_MINUTE);
|
||
|
|
|
||
|
|
// Add a run session
|
||
|
|
ActivitySession run_activity = {
|
||
|
|
.start_utc = utc_sec - time_elapsed,
|
||
|
|
.length_min = time_elapsed,
|
||
|
|
.type = ActivitySessionType_Run,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&run_activity);
|
||
|
|
|
||
|
|
// Add a walk session
|
||
|
|
ActivitySession walk_activity = {
|
||
|
|
.start_utc = utc_sec - time_elapsed,
|
||
|
|
.length_min = time_elapsed,
|
||
|
|
.type = ActivitySessionType_Walk,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&walk_activity);
|
||
|
|
|
||
|
|
// Add a sleep session
|
||
|
|
ActivitySession sleep_activity = {
|
||
|
|
.start_utc = utc_sec - time_elapsed,
|
||
|
|
.length_min = time_elapsed,
|
||
|
|
.type = ActivitySessionType_Sleep,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
activity_sessions_prv_add_activity_session(&sleep_activity);
|
||
|
|
|
||
|
|
// Flip the switch to say we are in light sleep.
|
||
|
|
activity_private_state()->sleep_data.cur_state = ActivitySleepStateLightSleep;
|
||
|
|
|
||
|
|
// Run,Walk,Sleep sessions active, ensure that asking if they are ongoing, it returns true
|
||
|
|
cl_assert_equal_b(true, activity_sessions_is_session_type_ongoing(ActivitySessionType_Run));
|
||
|
|
cl_assert_equal_b(true, activity_sessions_is_session_type_ongoing(ActivitySessionType_Walk));
|
||
|
|
cl_assert_equal_b(true, activity_sessions_is_session_type_ongoing(ActivitySessionType_Sleep));
|
||
|
|
cl_assert_equal_i(HealthActivityRun | HealthActivityWalk | HealthActivitySleep , health_service_peek_current_activities());
|
||
|
|
}
|
||
|
|
|
||
|
|
static void prv_set_median_hr_for_minutes(int bpm, int num_minutes) {
|
||
|
|
const int num_samples = 15;
|
||
|
|
activity_private_state()->hr.num_samples = num_samples;
|
||
|
|
memset(activity_private_state()->hr.samples, bpm, num_samples);
|
||
|
|
memset(activity_private_state()->hr.weights, 100, num_samples);
|
||
|
|
|
||
|
|
for (int i = 0; i < num_minutes; i++) {
|
||
|
|
prv_minute_system_task_cb(NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool prv_is_hr_elevated(void) {
|
||
|
|
return activity_private_state()->hr.metrics.is_hr_elevated;
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_activity__update_time_in_hr_zones(void) {
|
||
|
|
int32_t zone1_minutes, zone2_minutes, zone3_minutes;
|
||
|
|
|
||
|
|
activity_start_tracking(false /*test_mode*/);
|
||
|
|
fake_system_task_callbacks_invoke_pending();
|
||
|
|
activity_metrics_prv_reset_hr_stats();
|
||
|
|
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), false);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 0);
|
||
|
|
|
||
|
|
// Add some "regular" heart rates. This shouldn't affect our zone counts
|
||
|
|
prv_set_median_hr_for_minutes(70 /* BPM */, 3 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), false);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 0);
|
||
|
|
|
||
|
|
// Add some "very elevated" heart rates.
|
||
|
|
// The zone should wait 1 minute, move up 1 zone per minute, stop at the top
|
||
|
|
prv_set_median_hr_for_minutes(185 /* BPM */, 5 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), true);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 1);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 1);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 2);
|
||
|
|
|
||
|
|
// Add some "regular" heart rates.
|
||
|
|
// The zone should move down 1 zone per minute
|
||
|
|
prv_set_median_hr_for_minutes(70 /* BPM */, 4 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), false);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 2);
|
||
|
|
|
||
|
|
// Add some more "regular" heart rates.
|
||
|
|
// This shouldn't affect our zone counts
|
||
|
|
prv_set_median_hr_for_minutes(70 /* BPM */, 3 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), false);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 2);
|
||
|
|
|
||
|
|
// Add a "blip" which shouldn't affect our zone counts.
|
||
|
|
// This shouldn't affect our zone counts
|
||
|
|
prv_set_median_hr_for_minutes(180 /* BPM */, 1 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), true);
|
||
|
|
prv_set_median_hr_for_minutes(70 /* BPM */, 1 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), false);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 2);
|
||
|
|
|
||
|
|
// Ad some "Semi-active" heart rates
|
||
|
|
prv_set_median_hr_for_minutes(130 /* BPM */, 3 /* minutes */);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), true);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 4);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 2);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 2);
|
||
|
|
|
||
|
|
// Advance to a new day. The HR zone stats should get reset
|
||
|
|
time_t utc_sec = rtc_get_time();
|
||
|
|
utc_sec += SECONDS_PER_DAY;
|
||
|
|
rtc_set_time(utc_sec);
|
||
|
|
prv_minute_system_task_cb(NULL);
|
||
|
|
cl_assert_equal_b(prv_is_hr_elevated(), true); // stays elevated
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone1Minutes, 1, &zone1_minutes);
|
||
|
|
cl_assert_equal_i(zone1_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone2Minutes, 1, &zone2_minutes);
|
||
|
|
cl_assert_equal_i(zone2_minutes, 0);
|
||
|
|
activity_get_metric(ActivityMetricHeartRateZone3Minutes, 1, &zone3_minutes);
|
||
|
|
cl_assert_equal_i(zone3_minutes, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------------------
|
||
|
|
// Test that we can add / delete an activity session
|
||
|
|
void test_activity__activity_sessions_add_delete_sessions(void) {
|
||
|
|
ActivitySession empty_session = {};
|
||
|
|
|
||
|
|
ActivitySession walk_activity = {
|
||
|
|
.start_utc = 1,
|
||
|
|
.length_min = 5,
|
||
|
|
.type = ActivitySessionType_Walk,
|
||
|
|
.ongoing = true,
|
||
|
|
};
|
||
|
|
|
||
|
|
// Add then delete
|
||
|
|
activity_sessions_prv_add_activity_session(&walk_activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, 1);
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &walk_activity,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
|
||
|
|
activity_sessions_prv_delete_activity_session(&walk_activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, 0);
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &empty_session,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
|
||
|
|
|
||
|
|
// Add lots of sessions then delete from the front
|
||
|
|
for (int i = 0; i < ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT; i++) {
|
||
|
|
ActivitySession activity = walk_activity;
|
||
|
|
activity.start_utc = i;
|
||
|
|
activity_sessions_prv_add_activity_session(&activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, i + 1);
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[i], &activity,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT; i++) {
|
||
|
|
ActivitySession activity = walk_activity;
|
||
|
|
activity.start_utc = i;
|
||
|
|
|
||
|
|
ActivitySession next_activity = activity;
|
||
|
|
next_activity.start_utc = i + 1;
|
||
|
|
|
||
|
|
activity_sessions_prv_delete_activity_session(&activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count,
|
||
|
|
ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT - 1 - i);
|
||
|
|
if (activity_private_state()->activity_sessions_count) {
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &next_activity,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &empty_session,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
|
||
|
|
|
||
|
|
// Add lots of sessions then delete from the back
|
||
|
|
for (int i = 0; i < ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT; i++) {
|
||
|
|
ActivitySession activity = walk_activity;
|
||
|
|
activity.start_utc = i;
|
||
|
|
activity_sessions_prv_add_activity_session(&activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, i + 1);
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[i], &activity,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = ACTIVITY_MAX_ACTIVITY_SESSIONS_COUNT - 1; i >= 0; i--) {
|
||
|
|
ActivitySession activity = walk_activity;
|
||
|
|
activity.start_utc = i;
|
||
|
|
|
||
|
|
ActivitySession next_activity = activity;
|
||
|
|
next_activity.start_utc = i - 1;
|
||
|
|
|
||
|
|
activity_sessions_prv_delete_activity_session(&activity);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, i);
|
||
|
|
if (activity_private_state()->activity_sessions_count) {
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[i], &empty_session,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &empty_session,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
|
||
|
|
|
||
|
|
// Add 3 sessions and delete from the middle
|
||
|
|
ActivitySession a1 = walk_activity;
|
||
|
|
a1.start_utc = 1;
|
||
|
|
ActivitySession a2 = walk_activity;
|
||
|
|
a2.start_utc = 2;
|
||
|
|
ActivitySession a3 = walk_activity;
|
||
|
|
a3.start_utc = 3;
|
||
|
|
activity_sessions_prv_add_activity_session(&a1);
|
||
|
|
activity_sessions_prv_add_activity_session(&a2);
|
||
|
|
activity_sessions_prv_add_activity_session(&a3);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, 3);
|
||
|
|
|
||
|
|
activity_sessions_prv_delete_activity_session(&a2);
|
||
|
|
cl_assert_equal_i(activity_private_state()->activity_sessions_count, 2);
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[0], &a1,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
cl_assert_equal_m(&activity_private_state()->activity_sessions[1], &a3,
|
||
|
|
sizeof(ActivitySession));
|
||
|
|
|
||
|
|
}
|