pebble_worker.h

#pragma once
 
#include <locale.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
//#include <time.h>
 
#include "pebble_warn_unsupported_functions.h"
#include "pebble_worker_sdk_version.h"
 
#ifndef __FILE_NAME__
#define __FILE_NAME__ __FILE__
#endif
 
#define ARRAY_LENGTH(array) (sizeof((array))/sizeof((array)[0]))
 
struct tm;
typedef struct tm tm;
 
#define IS_SIGNED(var) (__builtin_choose_expr( \
  __builtin_types_compatible_p(__typeof__(var), unsigned char), false, \
  __builtin_choose_expr( \
  __builtin_types_compatible_p(__typeof__(var), unsigned short), false, \
  __builtin_choose_expr( \
  __builtin_types_compatible_p(__typeof__(var), unsigned int), false, \
  __builtin_choose_expr( \
  __builtin_types_compatible_p(__typeof__(var), unsigned long), false, \
  __builtin_choose_expr( \
  __builtin_types_compatible_p(__typeof__(var), unsigned long long), false, true))))) \
)
 
 
 
typedef enum {
  WATCH_INFO_MODEL_UNKNOWN, 
  WATCH_INFO_MODEL_PEBBLE_ORIGINAL, 
  WATCH_INFO_MODEL_PEBBLE_STEEL, 
  WATCH_INFO_MODEL_PEBBLE_TIME, 
  WATCH_INFO_MODEL_PEBBLE_TIME_STEEL, 
  WATCH_INFO_MODEL_PEBBLE_TIME_ROUND_14, 
  WATCH_INFO_MODEL_PEBBLE_TIME_ROUND_20, 
  WATCH_INFO_MODEL_PEBBLE_2_HR, 
  WATCH_INFO_MODEL_PEBBLE_2_SE, 
  WATCH_INFO_MODEL_PEBBLE_TIME_2, 
 
  WATCH_INFO_MODEL__MAX
} WatchInfoModel;
 
typedef enum {
  WATCH_INFO_COLOR_UNKNOWN = 0, 
  WATCH_INFO_COLOR_BLACK = 1, 
  WATCH_INFO_COLOR_WHITE = 2, 
  WATCH_INFO_COLOR_RED = 3, 
  WATCH_INFO_COLOR_ORANGE = 4, 
  WATCH_INFO_COLOR_GRAY = 5, 
 
  WATCH_INFO_COLOR_STAINLESS_STEEL = 6, 
  WATCH_INFO_COLOR_MATTE_BLACK = 7, 
 
  WATCH_INFO_COLOR_BLUE = 8, 
  WATCH_INFO_COLOR_GREEN = 9, 
  WATCH_INFO_COLOR_PINK = 10, 
 
  WATCH_INFO_COLOR_TIME_WHITE = 11, 
  WATCH_INFO_COLOR_TIME_BLACK = 12, 
  WATCH_INFO_COLOR_TIME_RED = 13, 
 
  WATCH_INFO_COLOR_TIME_STEEL_SILVER = 14, 
  WATCH_INFO_COLOR_TIME_STEEL_BLACK = 15, 
  WATCH_INFO_COLOR_TIME_STEEL_GOLD = 16, 
 
  WATCH_INFO_COLOR_TIME_ROUND_SILVER_14 = 17, 
  WATCH_INFO_COLOR_TIME_ROUND_BLACK_14 = 18, 
  WATCH_INFO_COLOR_TIME_ROUND_SILVER_20 = 19, 
  WATCH_INFO_COLOR_TIME_ROUND_BLACK_20 = 20, 
  WATCH_INFO_COLOR_TIME_ROUND_ROSE_GOLD_14 = 21, 
 
  WATCH_INFO_COLOR_PEBBLE_2_HR_BLACK = 25, 
  WATCH_INFO_COLOR_PEBBLE_2_HR_LIME = 27, 
  WATCH_INFO_COLOR_PEBBLE_2_HR_FLAME = 28, 
  WATCH_INFO_COLOR_PEBBLE_2_HR_WHITE = 29, 
  WATCH_INFO_COLOR_PEBBLE_2_HR_AQUA = 30, 
 
  WATCH_INFO_COLOR_PEBBLE_2_SE_BLACK = 24, 
  WATCH_INFO_COLOR_PEBBLE_2_SE_WHITE = 26, 
 
  WATCH_INFO_COLOR_PEBBLE_TIME_2_BLACK = 31, 
  WATCH_INFO_COLOR_PEBBLE_TIME_2_SILVER = 32, 
  WATCH_INFO_COLOR_PEBBLE_TIME_2_GOLD = 33, 
 
  WATCH_INFO_COLOR__MAX
} WatchInfoColor;
 
typedef struct {
  uint8_t major; 
  uint8_t minor; 
  uint8_t patch; 
} WatchInfoVersion;
 
WatchInfoModel watch_info_get_model(void);
 
WatchInfoVersion watch_info_get_firmware_version(void);
 
WatchInfoColor watch_info_get_color(void);
 
 
 
#define TRIG_MAX_RATIO 0xffff
 
#define TRIG_MAX_ANGLE 0x10000
 
#define TRIGANGLE_TO_DEG(trig_angle) (((trig_angle) * 360) / TRIG_MAX_ANGLE)
 
#define DEG_TO_TRIGANGLE(angle) (((angle) * TRIG_MAX_ANGLE) / 360)
 
int32_t sin_lookup(int32_t angle);
 
int32_t cos_lookup(int32_t angle);
 
int32_t atan2_lookup(int16_t y, int16_t x);
 
 
 
typedef enum {
  TODAY = 0,  
  SUNDAY,     
  MONDAY,     
  TUESDAY,    
  WEDNESDAY,  
  THURSDAY,   
  FRIDAY,     
  SATURDAY,   
} WeekDay;
 
void clock_copy_time_string(char *buffer, uint8_t size);
 
bool clock_is_24h_style(void);
 
time_t clock_to_timestamp(WeekDay day, int hour, int minute);
 
bool clock_is_timezone_set(void);
 
#define TIMEZONE_NAME_LENGTH 32
 
void clock_get_timezone(char *timezone, const size_t buffer_size);
 
 
 
typedef enum PlatformType {
  PlatformTypeAplite,
  PlatformTypeBasalt,
  PlatformTypeChalk,
  PlatformTypeDiorite,
  PlatformTypeEmery,
} PlatformType;
 
#define PBL_PLATFORM_TYPE_CURRENT PlatformTypeBasalt
 
#define PBL_PLATFORM_SWITCH_DEFAULT(PLAT, DEFAULT, APLITE, BASALT, CHALK, DIORITE, EMERY) (\
  ((PLAT) == PlatformTypeEmery) ? (EMERY) : \
  ((PLAT) == PlatformTypeDiorite) ? (DIORITE) : \
  ((PLAT) == PlatformTypeChalk) ? (CHALK) : \
  ((PLAT) == PlatformTypeBasalt) ? (BASALT) : \
  ((PLAT) == PlatformTypeBasalt) ? (APLITE) : \
  (DEFAULT) \
)
 
#define PBL_PLATFORM_SWITCH(PLAT, APLITE, BASALT, CHALK, DIORITE, EMERY) \
  PBL_PLATFORM_SWITCH_DEFAULT(PLAT, APLITE, APLITE, BASALT, CHALK, DIORITE, EMERY)
 
 
 
 
typedef void (*ConnectionHandler)(bool connected);
 
typedef struct {
  ConnectionHandler pebble_app_connection_handler;
  ConnectionHandler pebblekit_connection_handler;
} ConnectionHandlers;
 
bool connection_service_peek_pebble_app_connection(void);
 
bool connection_service_peek_pebblekit_connection(void);
 
void connection_service_subscribe(ConnectionHandlers conn_handlers);
 
void connection_service_unsubscribe(void);
 
 
 
typedef struct {
  uint8_t charge_percent;
  bool is_charging;
  bool is_plugged;
} BatteryChargeState;
 
typedef void (*BatteryStateHandler)(BatteryChargeState charge);
 
void battery_state_service_subscribe(BatteryStateHandler handler);
 
void battery_state_service_unsubscribe(void);
 
BatteryChargeState battery_state_service_peek(void);
 
 
 
typedef struct __attribute__((__packed__)) AccelData {
  int16_t x;
  int16_t y;
  int16_t z;
 
  bool did_vibrate;
 
  uint64_t timestamp;
} AccelData;
 
typedef struct __attribute__((__packed__)) {
  int16_t x;
  int16_t y;
  int16_t z;
} AccelRawData;
 
typedef enum {
  ACCEL_AXIS_X = 0,
  ACCEL_AXIS_Y = 1,
  ACCEL_AXIS_Z = 2,
} AccelAxisType;
 
typedef void (*AccelDataHandler)(AccelData *data, uint32_t num_samples);
 
typedef void (*AccelRawDataHandler)(AccelRawData *data, uint32_t num_samples, uint64_t timestamp);
 
typedef void (*AccelTapHandler)(AccelAxisType axis, int32_t direction);
 
typedef enum {
  ACCEL_SAMPLING_10HZ = 10,
  ACCEL_SAMPLING_25HZ = 25,
  ACCEL_SAMPLING_50HZ = 50,
  ACCEL_SAMPLING_100HZ = 100,
} AccelSamplingRate;
 
int accel_service_peek(AccelData *data);
 
int accel_service_set_sampling_rate(AccelSamplingRate rate);
 
int accel_service_set_samples_per_update(uint32_t num_samples);
 
void accel_data_service_subscribe(uint32_t samples_per_update, AccelDataHandler handler);
 
void accel_data_service_unsubscribe(void);
 
void accel_tap_service_subscribe(AccelTapHandler handler);
 
void accel_tap_service_unsubscribe(void);
 
void accel_raw_data_service_subscribe(uint32_t samples_per_update, AccelRawDataHandler handler);
 
 
 
typedef enum {
  CompassStatusUnavailable = -1,
  CompassStatusDataInvalid = 0,
  CompassStatusCalibrating,
  CompassStatusCalibrated
} CompassStatus;
 
typedef int32_t CompassHeading;
 
typedef struct {
  CompassHeading magnetic_heading;
  CompassHeading true_heading;
  CompassStatus compass_status;
  bool is_declination_valid;
} CompassHeadingData;
 
typedef void (*CompassHeadingHandler)(CompassHeadingData heading);
 
int compass_service_set_heading_filter(CompassHeading filter);
 
void compass_service_subscribe(CompassHeadingHandler handler);
 
void compass_service_unsubscribe(void);
 
int compass_service_peek(CompassHeadingData *data);
 
 
 
typedef enum {
  SECOND_UNIT = 1 << 0,
  MINUTE_UNIT = 1 << 1,
  HOUR_UNIT = 1 << 2,
  DAY_UNIT = 1 << 3,
  MONTH_UNIT = 1 << 4,
  YEAR_UNIT = 1 << 5
} TimeUnits;
 
typedef void (*TickHandler)(struct tm *tick_time, TimeUnits units_changed);
 
void tick_timer_service_subscribe(TimeUnits tick_units, TickHandler handler);
 
void tick_timer_service_unsubscribe(void);
 
 
 
typedef enum {
  HealthMetricStepCount,
  HealthMetricActiveSeconds,
  HealthMetricWalkedDistanceMeters,
  HealthMetricSleepSeconds,
  HealthMetricSleepRestfulSeconds,
  HealthMetricRestingKCalories,
  HealthMetricActiveKCalories,
  HealthMetricHeartRateBPM,
  HealthMetricHeartRateRawBPM,
} HealthMetric;
 
typedef int32_t HealthValue;
 
typedef struct HealthMetricAlert HealthMetricAlert;
 
HealthValue health_service_sum(HealthMetric metric, time_t time_start, time_t time_end);
 
HealthValue health_service_sum_today(HealthMetric metric);
 
HealthValue health_service_peek_current_value(HealthMetric metric);
 
typedef enum {
  HealthServiceTimeScopeOnce,
  HealthServiceTimeScopeWeekly,
  HealthServiceTimeScopeDailyWeekdayOrWeekend,
  HealthServiceTimeScopeDaily,
} HealthServiceTimeScope;
 
HealthValue health_service_sum_averaged(HealthMetric metric, time_t time_start, time_t time_end,
                                        HealthServiceTimeScope scope);
 
typedef enum {
  HealthAggregationSum,
  HealthAggregationAvg,
  HealthAggregationMin,
  HealthAggregationMax
} HealthAggregation;
 
HealthValue health_service_aggregate_averaged(HealthMetric metric, time_t time_start,
                                              time_t time_end, HealthAggregation aggregation,
                                              HealthServiceTimeScope scope);
 
typedef uint32_t HealthActivityMask;
 
#define HealthActivityMaskAll ((HealthActivityOpenWorkout << 1) - 1)
 
typedef enum {
  HealthActivityNone = 0,
  HealthActivitySleep = 1 << 0,
  HealthActivityRestfulSleep = 1 << 1,
  HealthActivityWalk = 1 << 2,
  HealthActivityRun = 1 << 3,
  HealthActivityOpenWorkout = 1 << 4,
} HealthActivity;
 
HealthActivityMask   health_service_peek_current_activities(void);
 
typedef bool (*HealthActivityIteratorCB)(HealthActivity activity, time_t time_start,
                                         time_t time_end, void *context);
 
typedef enum {
  HealthIterationDirectionPast,
  HealthIterationDirectionFuture,
} HealthIterationDirection;
 
void health_service_activities_iterate(HealthActivityMask activity_mask, time_t time_start,
                                       time_t time_end, HealthIterationDirection direction,
                                       HealthActivityIteratorCB callback, void *context);
 
typedef enum {
  HealthServiceAccessibilityMaskAvailable = 1 << 0,
  HealthServiceAccessibilityMaskNoPermission = 1 << 1,
  HealthServiceAccessibilityMaskNotSupported = 1 << 2,
  HealthServiceAccessibilityMaskNotAvailable = 1 << 3,
} HealthServiceAccessibilityMask;
 
HealthServiceAccessibilityMask health_service_metric_accessible(
    HealthMetric metric, time_t time_start, time_t time_end);
 
HealthServiceAccessibilityMask health_service_metric_averaged_accessible(
    HealthMetric metric, time_t time_start, time_t time_end, HealthServiceTimeScope scope);
 
HealthServiceAccessibilityMask health_service_metric_aggregate_averaged_accessible(
    HealthMetric metric, time_t time_start, time_t time_end, HealthAggregation aggregation,
    HealthServiceTimeScope scope);
 
HealthServiceAccessibilityMask health_service_any_activity_accessible(
    HealthActivityMask activity_mask, time_t time_start, time_t time_end);
 
typedef enum {
  HealthEventSignificantUpdate = 0,
  HealthEventMovementUpdate = 1,
  HealthEventSleepUpdate = 2,
  HealthEventMetricAlert = 3,
  HealthEventHeartRateUpdate = 4,
} HealthEventType;
 
typedef void (*HealthEventHandler)(HealthEventType event, void *context);
 
bool health_service_events_subscribe(HealthEventHandler handler, void *context);
 
bool health_service_events_unsubscribe(void);
 
bool health_service_set_heart_rate_sample_period(uint16_t interval_sec);
 
uint16_t health_service_get_heart_rate_sample_period_expiration_sec(void);
 
HealthMetricAlert *health_service_register_metric_alert(HealthMetric metric, HealthValue threshold);
 
bool health_service_cancel_metric_alert(HealthMetricAlert *alert);
 
typedef enum AmbientLightLevel {
  AmbientLightLevelUnknown = 0,
  AmbientLightLevelVeryDark,
  AmbientLightLevelDark,
  AmbientLightLevelLight,
  AmbientLightLevelVeryLight,
} AmbientLightLevel;
 
typedef struct {
  uint8_t steps;              
  uint8_t orientation;        
  uint16_t vmc;               
  bool is_invalid: 1;         
  AmbientLightLevel light: 3; 
  uint8_t padding: 4;
  uint8_t heart_rate_bpm;     
  uint8_t reserved[6];        
} HealthMinuteData;
 
uint32_t health_service_get_minute_history(HealthMinuteData *minute_data, uint32_t max_records,
                                           time_t *time_start, time_t *time_end);
 
#define PBL_IF_HEALTH_ELSE(if_true, if_false) (if_true)
 
typedef enum {
  MeasurementSystemUnknown,
  MeasurementSystemMetric,
  MeasurementSystemImperial,
} MeasurementSystem;
 
MeasurementSystem health_service_get_measurement_system_for_display(HealthMetric metric);
 
 
 
 
typedef void *DataLoggingSessionRef;
 
typedef enum {
  DATA_LOGGING_BYTE_ARRAY = 0,
  DATA_LOGGING_UINT = 2,
  DATA_LOGGING_INT = 3,
} DataLoggingItemType;
 
typedef enum {
  DATA_LOGGING_SUCCESS = 0, 
  DATA_LOGGING_BUSY, 
  DATA_LOGGING_FULL, 
  DATA_LOGGING_NOT_FOUND, 
  DATA_LOGGING_CLOSED, 
  DATA_LOGGING_INVALID_PARAMS, 
  DATA_LOGGING_INTERNAL_ERR 
} DataLoggingResult;
 
DataLoggingSessionRef data_logging_create(uint32_t tag, DataLoggingItemType item_type,
                                          uint16_t item_length, bool resume);
 
void data_logging_finish(DataLoggingSessionRef logging_session);
 
DataLoggingResult data_logging_log(DataLoggingSessionRef logging_session, const void *data,
                                   uint32_t num_items);
 
 
 
 
typedef struct __attribute__((__packed__)) {
  uint8_t byte0;
  uint8_t byte1;
  uint8_t byte2;
  uint8_t byte3;
  uint8_t byte4;
  uint8_t byte5;
  uint8_t byte6;
  uint8_t byte7;
  uint8_t byte8;
  uint8_t byte9;
  uint8_t byte10;
  uint8_t byte11;
  uint8_t byte12;
  uint8_t byte13;
  uint8_t byte14;
  uint8_t byte15;
} Uuid;
 
#define UUID_SIZE 16
 
#define UuidMake(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) ((Uuid) {p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15})
 
#define UuidMakeFromBEBytes(b) ((Uuid) { b[0], b[1], b[2], b[3], \
                                         b[4], b[5], b[6], b[7], \
                                         b[8], b[9], b[10], b[11], \
                                         b[12], b[13], b[14], b[15] })
 
#define UuidMakeFromLEBytes(b) ((Uuid) { b[15], b[14], b[13], b[12], \
                                         b[11], b[10], b[9], b[8], \
                                         b[7], b[6], b[5], b[4], \
                                         b[3], b[2], b[1], b[0] })
 
bool uuid_equal(const Uuid *uu1, const Uuid *uu2);
 
void uuid_to_string(const Uuid *uuid, char *buffer);
 
#define UUID_STRING_BUFFER_LENGTH (32 + 4 + 2 + 1)
 
 
 
 
void app_log(uint8_t log_level, const char* src_filename, int src_line_number, const char* fmt,
             ...);
 
#define APP_LOG(level, fmt, args...)                                \
  app_log(level, __FILE_NAME__, __LINE__, fmt, ## args)
 
typedef enum {
  APP_LOG_LEVEL_ERROR = 1,
  APP_LOG_LEVEL_WARNING = 50,
  APP_LOG_LEVEL_INFO = 100,
  APP_LOG_LEVEL_DEBUG = 200,
  APP_LOG_LEVEL_DEBUG_VERBOSE = 255,
} AppLogLevel;
 
 
 
typedef enum {
  DICT_OK = 0,
  DICT_NOT_ENOUGH_STORAGE = 1 << 1,
  DICT_INVALID_ARGS = 1 << 2,
  DICT_INTERNAL_INCONSISTENCY = 1 << 3,
  DICT_MALLOC_FAILED = 1 << 4,
} DictionaryResult;
 
typedef enum {
  TUPLE_BYTE_ARRAY = 0,
  TUPLE_CSTRING = 1,
  TUPLE_UINT = 2,
  TUPLE_INT = 3,
} TupleType;
 
typedef struct __attribute__((__packed__)) {
  uint32_t key;
  TupleType type:8;
  uint16_t length;
  union {
    uint8_t data[0];
    char cstring[0];
    uint8_t uint8;
    uint16_t uint16;
    uint32_t uint32;
    int8_t int8;
    int16_t int16;
    int32_t int32;
  } value[];
} Tuple;
 
struct Dictionary;
typedef struct Dictionary Dictionary;
 
typedef struct {
  Dictionary *dictionary;  
  const void *end;  
  Tuple *cursor;
} DictionaryIterator;
 
uint32_t dict_calc_buffer_size(const uint8_t tuple_count, ...);
 
uint32_t dict_size(DictionaryIterator* iter);
 
DictionaryResult dict_write_begin(DictionaryIterator *iter, uint8_t * const buffer, const uint16_t size);
 
DictionaryResult dict_write_data(DictionaryIterator *iter, const uint32_t key, const uint8_t * const data, const uint16_t size);
 
DictionaryResult dict_write_cstring(DictionaryIterator *iter, const uint32_t key, const char * const cstring);
 
DictionaryResult dict_write_int(DictionaryIterator *iter, const uint32_t key, const void *integer, const uint8_t width_bytes, const bool is_signed);
 
DictionaryResult dict_write_uint8(DictionaryIterator *iter, const uint32_t key, const uint8_t value);
 
DictionaryResult dict_write_uint16(DictionaryIterator *iter, const uint32_t key, const uint16_t value);
 
DictionaryResult dict_write_uint32(DictionaryIterator *iter, const uint32_t key, const uint32_t value);
 
DictionaryResult dict_write_int8(DictionaryIterator *iter, const uint32_t key, const int8_t value);
 
DictionaryResult dict_write_int16(DictionaryIterator *iter, const uint32_t key, const int16_t value);
 
DictionaryResult dict_write_int32(DictionaryIterator *iter, const uint32_t key, const int32_t value);
 
uint32_t dict_write_end(DictionaryIterator *iter);
 
Tuple * dict_read_begin_from_buffer(DictionaryIterator *iter, const uint8_t * const buffer, const uint16_t size);
 
Tuple * dict_read_next(DictionaryIterator *iter);
 
Tuple * dict_read_first(DictionaryIterator *iter);
 
typedef struct Tuplet {
  TupleType type;
  uint32_t key;
  union {
    struct {
      const uint8_t *data;
      const uint16_t length;
    } bytes;
    struct {
      const char *data;
      const uint16_t length;
    } cstring;
    struct {
      uint32_t storage;
      const uint16_t width;
    } integer;
  }; 
} Tuplet;
 
#define TupletBytes(_key, _data, _length) \
((const Tuplet) { .type = TUPLE_BYTE_ARRAY, .key = _key, .bytes = { .data = _data, .length = _length }})
 
#define TupletCString(_key, _cstring) \
((const Tuplet) { .type = TUPLE_CSTRING, .key = _key, .cstring = { .data = _cstring, .length = _cstring ? strlen(_cstring) + 1 : 0 }})
 
#define TupletInteger(_key, _integer) \
((const Tuplet) { .type = IS_SIGNED(_integer) ? TUPLE_INT : TUPLE_UINT, .key = _key, .integer = { .storage = _integer, .width = sizeof(_integer) }})
 
typedef void (*DictionarySerializeCallback)(const uint8_t * const data, const uint16_t size, void *context);
 
DictionaryResult dict_serialize_tuplets(DictionarySerializeCallback callback, void *context, const Tuplet * const tuplets, const uint8_t tuplets_count);
 
DictionaryResult dict_serialize_tuplets_to_buffer(const Tuplet * const tuplets, const uint8_t tuplets_count, uint8_t *buffer, uint32_t *size_in_out);
 
DictionaryResult dict_serialize_tuplets_to_buffer_with_iter(DictionaryIterator *iter, const Tuplet * const tuplets, const uint8_t tuplets_count, uint8_t *buffer, uint32_t *size_in_out);
 
DictionaryResult dict_write_tuplet(DictionaryIterator *iter, const Tuplet * const tuplet);
 
uint32_t dict_calc_buffer_size_from_tuplets(const Tuplet * const tuplets, const uint8_t tuplets_count);
 
typedef void (*DictionaryKeyUpdatedCallback)(const uint32_t key, const Tuple *new_tuple, const Tuple *old_tuple, void *context);
 
DictionaryResult dict_merge(DictionaryIterator *dest, uint32_t *dest_max_size_in_out,
                             DictionaryIterator *source,
                             const bool update_existing_keys_only,
                             const DictionaryKeyUpdatedCallback key_callback, void *context);
 
Tuple *dict_find(const DictionaryIterator *iter, const uint32_t key);
 
 
 
void worker_event_loop(void);
 
void worker_launch_app(void);
 
 
 
typedef enum {
  APP_WORKER_RESULT_SUCCESS= 0,
  APP_WORKER_RESULT_NO_WORKER = 1,
  APP_WORKER_RESULT_DIFFERENT_APP = 2,
  APP_WORKER_RESULT_NOT_RUNNING = 3,
  APP_WORKER_RESULT_ALREADY_RUNNING = 4,
  APP_WORKER_RESULT_ASKING_CONFIRMATION = 5,
} AppWorkerResult;
 
typedef struct {
  uint16_t data0;
  uint16_t data1;
  uint16_t data2;
} AppWorkerMessage;
 
bool app_worker_is_running(void);
 
AppWorkerResult app_worker_launch(void);
 
AppWorkerResult app_worker_kill(void);
 
typedef void (*AppWorkerMessageHandler)(uint16_t type, AppWorkerMessage *data);
 
bool app_worker_message_subscribe(AppWorkerMessageHandler handler);
 
bool app_worker_message_unsubscribe(void);
 
void app_worker_send_message(uint8_t type, AppWorkerMessage *data);
 
 
 
void psleep(int millis);
 
struct AppTimer;
typedef struct AppTimer AppTimer;
 
typedef void (*AppTimerCallback)(void* data);
 
AppTimer* app_timer_register(uint32_t timeout_ms, AppTimerCallback callback, void* callback_data);
 
bool app_timer_reschedule(AppTimer *timer_handle, uint32_t new_timeout_ms);
 
void app_timer_cancel(AppTimer *timer_handle);
 
 
 
size_t heap_bytes_free(void);
 
size_t heap_bytes_used(void);
 
void memory_cache_flush(void *start, size_t size);
 
 
 
#define PERSIST_DATA_MAX_LENGTH 256
 
#define PERSIST_STRING_MAX_LENGTH PERSIST_DATA_MAX_LENGTH
 
typedef enum StatusCode {
  S_SUCCESS = 0,
 
  E_ERROR = -1,
 
  E_UNKNOWN = -2,
 
  E_INTERNAL = -3,
 
  E_INVALID_ARGUMENT = -4,
 
  E_OUT_OF_MEMORY = -5,
 
  E_OUT_OF_STORAGE = -6,
 
  E_OUT_OF_RESOURCES = -7,
 
  E_RANGE = -8,
 
  E_DOES_NOT_EXIST = -9,
 
  E_INVALID_OPERATION = -10,
 
  E_BUSY = -11,
 
  E_AGAIN = -12,
 
  S_TRUE = 1,
 
  S_FALSE = 0,
 
  S_NO_MORE_ITEMS = 2,
 
  S_NO_ACTION_REQUIRED = 3,
 
} StatusCode;
 
typedef int32_t status_t;
 
bool persist_exists(const uint32_t key);
 
int persist_get_size(const uint32_t key);
 
bool persist_read_bool(const uint32_t key);
 
int32_t persist_read_int(const uint32_t key);
 
int persist_read_data(const uint32_t key, void *buffer, const size_t buffer_size);
 
int persist_read_string(const uint32_t key, char *buffer, const size_t buffer_size);
 
status_t persist_write_bool(const uint32_t key, const bool value);
 
status_t persist_write_int(const uint32_t key, const int32_t value);
 
int persist_write_data(const uint32_t key, const void *data, const size_t size);
 
int persist_write_string(const uint32_t key, const char *cstring);
 
status_t persist_delete(const uint32_t key);
 
 
 
 
 
 
 
#define TZ_LEN 6
 
#define SECONDS_PER_MINUTE (60)
 
#define MINUTES_PER_HOUR (60)
 
#define SECONDS_PER_HOUR (SECONDS_PER_MINUTE * MINUTES_PER_HOUR)
 
#define HOURS_PER_DAY (24)
 
#define MINUTES_PER_DAY (HOURS_PER_DAY * MINUTES_PER_HOUR)
 
#define SECONDS_PER_DAY (MINUTES_PER_DAY * SECONDS_PER_MINUTE)
 
struct tm {
  int tm_sec;     
  int tm_min;     
  int tm_hour;    
  int tm_mday;    
  int tm_mon;     
  int tm_year;    
  int tm_wday;    
  int tm_yday;    
  int tm_isdst;   
  int tm_gmtoff;  
  char tm_zone[TZ_LEN]; 
};
 
int strftime(char* s, size_t maxsize, const char* format, const struct tm* tm_p);
 
struct tm *localtime(const time_t *timep);
 
struct tm *gmtime(const time_t *timep);
 
time_t mktime(struct tm *tb);
 
time_t time(time_t *tloc);
 
double difftime(time_t end, time_t beginning);
 
uint16_t time_ms(time_t *t_utc, uint16_t *out_ms);
 
time_t time_start_of_today(void);