pebble.h

#pragma once
 
#include "pebble_fonts.h"
//#include "message_keys.auto.h"
//#include "src/resource_ids.auto.h"
 
#define PBL_APP_INFO(...) _Pragma("message \"\n\n \
  *** PBL_APP_INFO has been replaced with appinfo.json\n \
  Try updating your project with `pebble convert-project`\n \
  Visit our developer guides to learn more about appinfo.json:\n \
  http://developer.getpebble.com/guides/pebble-apps/\n \""); \
  _Pragma("GCC error \"PBL_APP_INFO has been replaced with appinfo.json\"");
 
#define PBL_APP_INFO_SIMPLE PBL_APP_INFO
// #define _REENT_ONLY
 
#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_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 {
  BUTTON_ID_BACK = 0,
  BUTTON_ID_UP,
  BUTTON_ID_SELECT,
  BUTTON_ID_DOWN,
  NUM_BUTTONS
} ButtonId;
 
 
 
 
 
 
 
const char *i18n_get_system_locale(void);
 
 
 
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 void (*AppFocusHandler)(bool in_focus);
 
typedef struct {
  AppFocusHandler will_focus;
  AppFocusHandler did_focus;
} AppFocusHandlers;
 
void app_focus_service_subscribe_handlers(AppFocusHandlers handlers);
 
void app_focus_service_subscribe(AppFocusHandler handler);
 
void app_focus_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);
 
 
 
typedef struct DictationSession DictationSession;
 
typedef enum {
  DictationSessionStatusSuccess,
 
  DictationSessionStatusFailureTranscriptionRejected,
 
  DictationSessionStatusFailureTranscriptionRejectedWithError,
 
  DictationSessionStatusFailureSystemAborted,
 
  DictationSessionStatusFailureNoSpeechDetected,
 
  DictationSessionStatusFailureConnectivityError,
 
  DictationSessionStatusFailureDisabled,
 
  DictationSessionStatusFailureInternalError,
 
  DictationSessionStatusFailureRecognizerError,
} DictationSessionStatus;
 
typedef void (*DictationSessionStatusCallback)(DictationSession *session,
                                               DictationSessionStatus status, char *transcription,
                                               void *context);
 
DictationSession *dictation_session_create(uint32_t buffer_size,
                                           DictationSessionStatusCallback callback,
                                           void *callback_context);
 
void dictation_session_destroy(DictationSession *session);
 
DictationSessionStatus dictation_session_start(DictationSession *session);
 
DictationSessionStatus dictation_session_stop(DictationSession *session);
 
void dictation_session_enable_confirmation(DictationSession *session, bool is_enabled);
 
void dictation_session_enable_error_dialogs(DictationSession *session, bool is_enabled);
 
#define PBL_IF_MICROPHONE_ELSE(if_true, if_false) (if_true)
 
 
 
typedef enum {
  APP_MSG_OK = 0,
 
  APP_MSG_SEND_TIMEOUT = 1 << 1,
 
  APP_MSG_SEND_REJECTED = 1 << 2,
 
  APP_MSG_NOT_CONNECTED = 1 << 3,
 
  APP_MSG_APP_NOT_RUNNING = 1 << 4,
 
  APP_MSG_INVALID_ARGS = 1 << 5,
 
  APP_MSG_BUSY = 1 << 6,
 
  APP_MSG_BUFFER_OVERFLOW = 1 << 7,
 
  APP_MSG_ALREADY_RELEASED = 1 << 9,
 
  APP_MSG_CALLBACK_ALREADY_REGISTERED = 1 << 10,
 
  APP_MSG_CALLBACK_NOT_REGISTERED = 1 << 11,
 
  APP_MSG_OUT_OF_MEMORY = 1 << 12,
 
  APP_MSG_CLOSED = 1 << 13,
 
  APP_MSG_INTERNAL_ERROR = 1 << 14,
 
  APP_MSG_INVALID_STATE = 1 << 15,
} AppMessageResult;
 
AppMessageResult app_message_open(const uint32_t size_inbound, const uint32_t size_outbound);
 
void app_message_deregister_callbacks(void);
 
typedef void (*AppMessageInboxReceived)(DictionaryIterator *iterator, void *context);
 
typedef void (*AppMessageInboxDropped)(AppMessageResult reason, void *context);
 
typedef void (*AppMessageOutboxSent)(DictionaryIterator *iterator, void *context);
 
typedef void (*AppMessageOutboxFailed)(DictionaryIterator *iterator, AppMessageResult reason, void *context);
 
void *app_message_get_context(void);
 
void *app_message_set_context(void *context);
 
AppMessageInboxReceived app_message_register_inbox_received(AppMessageInboxReceived received_callback);
 
AppMessageInboxDropped app_message_register_inbox_dropped(AppMessageInboxDropped dropped_callback);
 
AppMessageOutboxSent app_message_register_outbox_sent(AppMessageOutboxSent sent_callback);
 
AppMessageOutboxFailed app_message_register_outbox_failed(AppMessageOutboxFailed failed_callback);
 
uint32_t app_message_inbox_size_maximum(void);
 
uint32_t app_message_outbox_size_maximum(void);
 
AppMessageResult app_message_outbox_begin(DictionaryIterator **iterator);
 
AppMessageResult app_message_outbox_send(void);
 
#define APP_MESSAGE_INBOX_SIZE_MINIMUM 124
 
#define APP_MESSAGE_OUTBOX_SIZE_MINIMUM 636
 
 
 
typedef void (*AppSyncTupleChangedCallback)(const uint32_t key, const Tuple *new_tuple,
                                            const Tuple *old_tuple, void *context);
 
typedef void (*AppSyncErrorCallback)(DictionaryResult dict_error,
                                     AppMessageResult app_message_error, void *context);
 
typedef struct AppSync {
  DictionaryIterator current_iter;
  union {
    Dictionary *current;
    uint8_t *buffer;
  };
  uint16_t buffer_size;
  struct {
    AppSyncTupleChangedCallback value_changed;
    AppSyncErrorCallback error;
    void *context;
  } callback;
} AppSync;
 
void app_sync_init(struct AppSync *s, uint8_t *buffer, const uint16_t buffer_size,
                   const Tuplet * const keys_and_initial_values, const uint8_t count,
                   AppSyncTupleChangedCallback tuple_changed_callback,
                   AppSyncErrorCallback error_callback, void *context);
 
void app_sync_deinit(struct AppSync *s);
 
AppMessageResult app_sync_set(struct AppSync *s, const Tuplet * const keys_and_values_to_update,
                              const uint8_t count);
 
const Tuple * app_sync_get(const struct AppSync *s, const uint32_t key);
 
 
 
 
 
 
 
 
 
typedef void * ResHandle;
 
#define RESOURCE_ID_FONT_FALLBACK RESOURCE_ID_GOTHIC_14
 
ResHandle resource_get_handle(uint32_t resource_id);
 
size_t resource_size(ResHandle h);
 
size_t resource_load(ResHandle h, uint8_t *buffer, size_t max_length);
 
size_t resource_load_byte_range(
    ResHandle h, uint32_t start_offset, uint8_t *buffer, size_t num_bytes);
 
 
 
void app_event_loop(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);
 
 
 
typedef enum {
  SNIFF_INTERVAL_NORMAL = 0,
  SNIFF_INTERVAL_REDUCED = 1,
} SniffInterval;
 
void app_comm_set_sniff_interval(const SniffInterval interval);
 
SniffInterval app_comm_get_sniff_interval(void);
 
 
 
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);
 
 
 
typedef int32_t WakeupId;
 
typedef void (*WakeupHandler)(WakeupId wakeup_id, int32_t cookie);
 
void wakeup_service_subscribe(WakeupHandler handler);
 
WakeupId wakeup_schedule(time_t timestamp, int32_t cookie, bool notify_if_missed);
 
void wakeup_cancel(WakeupId wakeup_id);
 
void wakeup_cancel_all(void);
 
bool wakeup_get_launch_event(WakeupId *wakeup_id, int32_t *cookie);
 
bool wakeup_query(WakeupId wakeup_id, time_t *timestamp);
 
 
 
typedef enum {
  APP_LAUNCH_SYSTEM = 0,  
  APP_LAUNCH_USER,        
  APP_LAUNCH_PHONE,       
  APP_LAUNCH_WAKEUP,      
  APP_LAUNCH_WORKER,      
  APP_LAUNCH_QUICK_LAUNCH, 
  APP_LAUNCH_TIMELINE_ACTION,  
  APP_LAUNCH_SMARTSTRAP,  
} AppLaunchReason;
 
AppLaunchReason launch_reason(void);
 
uint32_t launch_get_args(void);
 
 
 
typedef enum AppExitReason {
  APP_EXIT_NOT_SPECIFIED = 0,                    
  APP_EXIT_ACTION_PERFORMED_SUCCESSFULLY,        
 
  NUM_EXIT_REASONS                               
} AppExitReason;
 
void exit_reason_set(AppExitReason exit_reason);
 
 
 
typedef uint32_t PublishedId;
 
#define APP_GLANCE_SLICE_NO_EXPIRATION ((time_t)0)
 
#define APP_GLANCE_SLICE_DEFAULT_ICON ((PublishedId)0)
 
typedef struct AppGlanceSlice {
  struct {
    PublishedId icon;
    const char *subtitle_template_string;
  } layout;
  time_t expiration_time;
} AppGlanceSlice;
 
typedef enum AppGlanceResult {
  APP_GLANCE_RESULT_SUCCESS = 0,
  APP_GLANCE_RESULT_INVALID_TEMPLATE_STRING = 1 << 0,
  APP_GLANCE_RESULT_TEMPLATE_STRING_TOO_LONG = 1 << 1,
  APP_GLANCE_RESULT_INVALID_ICON = 1 << 2,
  APP_GLANCE_RESULT_SLICE_CAPACITY_EXCEEDED = 1 << 3,
  APP_GLANCE_RESULT_EXPIRES_IN_THE_PAST = 1 << 4,
  APP_GLANCE_RESULT_INVALID_SESSION = 1 << 5,
} AppGlanceResult;
 
struct AppGlanceReloadSession;
typedef struct AppGlanceReloadSession AppGlanceReloadSession;
 
AppGlanceResult app_glance_add_slice(AppGlanceReloadSession *session, AppGlanceSlice slice);
 
typedef void (*AppGlanceReloadCallback)(AppGlanceReloadSession *session, size_t limit,
                                        void *context);
 
void app_glance_reload(AppGlanceReloadCallback callback, void *context);
 
 
 
 
 
typedef union GColor8 {
  uint8_t argb;
  struct {
    uint8_t b:2; 
    uint8_t g:2; 
    uint8_t r:2; 
    uint8_t a:2; 
  };
} GColor8;
 
typedef GColor8 GColor;
 
#include "gcolor_definitions.h"
 
bool gcolor_equal(GColor8 x, GColor8 y);
 
GColor8 gcolor_legible_over(GColor8 background_color);
 
#define COLOR_FALLBACK(color, bw) (color)
 
#define PBL_IF_RECT_ELSE(if_true, if_false) (if_true)
 
#define PBL_IF_ROUND_ELSE(if_true, if_false) (if_false)
 
#define PBL_IF_BW_ELSE(if_true, if_false) (if_false)
 
#define PBL_IF_COLOR_ELSE(if_true, if_false) (if_true)
 
typedef struct GPoint {
  int16_t x;
  int16_t y;
} GPoint;
 
#define GPoint(x, y) ((GPoint){(x), (y)})
 
#define GPointZero GPoint(0, 0)
 
bool gpoint_equal(const GPoint * const point_a, const GPoint * const point_b);
 
typedef struct GSize {
  int16_t w;
  int16_t h;
} GSize;
 
#define GSize(w, h) ((GSize){(w), (h)})
 
#define GSizeZero GSize(0, 0)
 
bool gsize_equal(const GSize *size_a, const GSize *size_b);
 
typedef struct GRect {
  GPoint origin;
  GSize size;
} GRect;
 
#define GRect(x, y, w, h) ((GRect){{(x), (y)}, {(w), (h)}})
 
#define GRectZero GRect(0, 0, 0, 0)
 
bool grect_equal(const GRect* const rect_a, const GRect* const rect_b);
 
bool grect_is_empty(const GRect* const rect);
 
void grect_standardize(GRect *rect);
 
void grect_clip(GRect * const rect_to_clip, const GRect * const rect_clipper);
 
bool grect_contains_point(const GRect *rect, const GPoint *point);
 
GPoint grect_center_point(const GRect *rect);
 
GRect grect_crop(GRect rect, const int32_t crop_size_px);
 
#define PLAY_COUNT_INFINITE UINT32_MAX
 
#define PLAY_DURATION_INFINITE UINT32_MAX
 
typedef enum GBitmapFormat {
  GBitmapFormat1Bit = 0, //<! 1-bit black and white. 0 = black, 1 = white.
  GBitmapFormat8Bit,      //<! 6-bit color + 2 bit alpha channel. See \ref GColor8 for pixel format.
  GBitmapFormat1BitPalette,
  GBitmapFormat2BitPalette,
  GBitmapFormat4BitPalette,
  GBitmapFormat8BitCircular,
} GBitmapFormat;
 
struct GBitmap;
typedef struct GBitmap GBitmap;
 
struct GBitmapSequence;
typedef struct GBitmapSequence GBitmapSequence;
 
uint16_t gbitmap_get_bytes_per_row(const GBitmap *bitmap);
 
GBitmapFormat gbitmap_get_format(const GBitmap *bitmap);
 
uint8_t* gbitmap_get_data(const GBitmap *bitmap);
 
void gbitmap_set_data(GBitmap *bitmap, uint8_t *data, GBitmapFormat format,
                     uint16_t row_size_bytes, bool free_on_destroy);
 
GRect gbitmap_get_bounds(const GBitmap *bitmap);
 
void gbitmap_set_bounds(GBitmap *bitmap, GRect bounds);
 
GColor* gbitmap_get_palette(const GBitmap *bitmap);
 
void gbitmap_set_palette(GBitmap *bitmap, GColor *palette, bool free_on_destroy);
 
GBitmap* gbitmap_create_with_resource(uint32_t resource_id);
 
GBitmap* gbitmap_create_with_data(const uint8_t *data);
 
GBitmap* gbitmap_create_as_sub_bitmap(const GBitmap *base_bitmap, GRect sub_rect);
 
GBitmap* gbitmap_create_from_png_data(const uint8_t *png_data, size_t png_data_size);
 
GBitmap* gbitmap_create_blank(GSize size, GBitmapFormat format);
 
GBitmap* gbitmap_create_blank_with_palette(GSize size, GBitmapFormat format,
                                           GColor *palette, bool free_on_destroy);
 
GBitmap* gbitmap_create_palettized_from_1bit(const GBitmap *src_bitmap);
 
void gbitmap_destroy(GBitmap* bitmap);
 
GBitmapSequence *gbitmap_sequence_create_with_resource(uint32_t resource_id);
 
bool gbitmap_sequence_update_bitmap_next_frame(GBitmapSequence *bitmap_sequence,
    GBitmap *bitmap, uint32_t *delay_ms);
 
bool gbitmap_sequence_update_bitmap_by_elapsed(GBitmapSequence *bitmap_sequence,
    GBitmap *bitmap, uint32_t elapsed_ms);
 
void gbitmap_sequence_destroy(GBitmapSequence *bitmap_sequence);
 
bool gbitmap_sequence_restart(GBitmapSequence *bitmap_sequence);
 
int32_t gbitmap_sequence_get_current_frame_idx(GBitmapSequence *bitmap_sequence);
 
uint32_t gbitmap_sequence_get_total_num_frames(GBitmapSequence *bitmap_sequence);
 
uint32_t gbitmap_sequence_get_play_count(GBitmapSequence *bitmap_sequence);
 
void gbitmap_sequence_set_play_count(GBitmapSequence *bitmap_sequence, uint32_t play_count);
 
GSize gbitmap_sequence_get_bitmap_size(GBitmapSequence *bitmap_sequence);
 
typedef struct {
    uint8_t *data;
    int16_t min_x;
    int16_t max_x;
} GBitmapDataRowInfo;
 
GBitmapDataRowInfo gbitmap_get_data_row_info(const GBitmap *bitmap, uint16_t y);
 
typedef enum GAlign {
  GAlignCenter,
  GAlignTopLeft,
  GAlignTopRight,
  GAlignTop,
  GAlignLeft,
  GAlignBottom,
  GAlignRight,
  GAlignBottomRight,
  GAlignBottomLeft
} GAlign;
 
void grect_align(GRect *rect, const GRect *inside_rect, const GAlign alignment, const bool clip);
 
typedef enum {
  GCompOpAssign,
  GCompOpAssignInverted,
  GCompOpOr,
  GCompOpAnd,
  GCompOpClear,
  GCompOpSet,
} GCompOp;
 
struct GContext;
typedef struct GContext GContext;
 
typedef struct {
  int16_t top;
  int16_t right;
  int16_t bottom;
  int16_t left;
} GEdgeInsets;
 
#define GEdgeInsets4(t, r, b, l) \
  ((GEdgeInsets){.top = t, .right = r, .bottom = b, .left = l})
 
#define GEdgeInsets3(t, rl, b) \
  ((GEdgeInsets){.top = t, .right = rl, .bottom = b, .left = rl})
 
#define GEdgeInsets2(tb, rl) \
  ((GEdgeInsets){.top = tb, .right = rl, .bottom = tb, .left = rl})
 
#define GEdgeInsets1(trbl) \
  ((GEdgeInsets){.top = trbl, .right = trbl, .bottom = trbl, .left = trbl})
 
#define GEdgeInsetsN(_1, _2, _3, _4, NAME, ...) NAME
 
#define GEdgeInsets(...) \
  GEdgeInsetsN(__VA_ARGS__, GEdgeInsets4, GEdgeInsets3, GEdgeInsets2, GEdgeInsets1)(__VA_ARGS__)
 
GRect grect_inset(GRect rect, GEdgeInsets insets);
 
 
 
void graphics_context_set_stroke_color(GContext* ctx, GColor color);
 
void graphics_context_set_fill_color(GContext* ctx, GColor color);
 
void graphics_context_set_text_color(GContext* ctx, GColor color);
 
void graphics_context_set_compositing_mode(GContext* ctx, GCompOp mode);
 
void graphics_context_set_antialiased(GContext* ctx, bool enable);
 
void graphics_context_set_stroke_width(GContext* ctx, uint8_t stroke_width);
 
 
 
typedef enum {
  GCornerNone = 0,
  GCornerTopLeft = 1 << 0,
  GCornerTopRight = 1 << 1,
  GCornerBottomLeft = 1 << 2,
  GCornerBottomRight = 1 << 3,
  GCornersAll = GCornerTopLeft | GCornerTopRight | GCornerBottomLeft | GCornerBottomRight,
  GCornersTop = GCornerTopLeft | GCornerTopRight,
  GCornersBottom = GCornerBottomLeft | GCornerBottomRight,
  GCornersLeft = GCornerTopLeft | GCornerBottomLeft,
  GCornersRight = GCornerTopRight | GCornerBottomRight,
} GCornerMask;
 
void graphics_draw_pixel(GContext* ctx, GPoint point);
 
void graphics_draw_line(GContext* ctx, GPoint p0, GPoint p1);
 
void graphics_draw_rect(GContext *ctx, GRect rect);
 
void graphics_fill_rect(GContext *ctx, GRect rect, uint16_t corner_radius,
                                       GCornerMask corner_mask);
 
void graphics_draw_circle(GContext* ctx, GPoint p, uint16_t radius);
 
void graphics_fill_circle(GContext* ctx, GPoint p, uint16_t radius);
 
void graphics_draw_round_rect(GContext *ctx, GRect rect, uint16_t radius);
 
void graphics_draw_bitmap_in_rect(GContext *ctx, const GBitmap *bitmap, GRect rect);
 
GBitmap* graphics_capture_frame_buffer(GContext* ctx);
 
GBitmap *graphics_capture_frame_buffer_format(GContext *ctx, GBitmapFormat format);
 
bool graphics_release_frame_buffer(GContext* ctx, GBitmap* buffer);
 
bool graphics_frame_buffer_is_captured(GContext* ctx);
 
void graphics_draw_rotated_bitmap(GContext* ctx, GBitmap *src, GPoint src_ic, int rotation,
                                  GPoint dest_ic);
 
typedef enum {
  GOvalScaleModeFitCircle,
  GOvalScaleModeFillCircle,
} GOvalScaleMode;
 
void graphics_draw_arc(GContext *ctx, GRect rect, GOvalScaleMode scale_mode,
                       int32_t angle_start, int32_t angle_end);
 
void graphics_fill_radial(GContext *ctx, GRect rect, GOvalScaleMode scale_mode,
                          uint16_t inset_thickness,
                          int32_t angle_start, int32_t angle_end);
 
GPoint gpoint_from_polar(GRect rect, GOvalScaleMode scale_mode, int32_t angle);
 
GRect grect_centered_from_polar(GRect rect, GOvalScaleMode scale_mode, int32_t angle, GSize size);
 
 
 
typedef struct GDrawCommand GDrawCommand;
 
typedef struct GDrawCommandFrame GDrawCommandFrame;
 
typedef struct GDrawCommandImage GDrawCommandImage;
 
typedef struct GDrawCommandList GDrawCommandList;
 
typedef bool (*GDrawCommandListIteratorCb)(GDrawCommand *command, uint32_t index, void *context);
 
typedef struct GDrawCommandSequence GDrawCommandSequence;
 
typedef enum {
  GDrawCommandTypeInvalid = 0,  
  GDrawCommandTypePath,         
  GDrawCommandTypeCircle,       
  GDrawCommandTypePrecisePath,  
} GDrawCommandType;
 
void gdraw_command_draw(GContext *ctx, GDrawCommand *command);
 
GDrawCommandType gdraw_command_get_type(GDrawCommand *command);
 
void gdraw_command_set_fill_color(GDrawCommand *command, GColor fill_color);
 
GColor gdraw_command_get_fill_color(GDrawCommand *command);
 
void gdraw_command_set_stroke_color(GDrawCommand *command, GColor stroke_color);
 
GColor gdraw_command_get_stroke_color(GDrawCommand *command);
 
void gdraw_command_set_stroke_width(GDrawCommand *command, uint8_t stroke_width);
 
uint8_t gdraw_command_get_stroke_width(GDrawCommand *command);
 
uint16_t gdraw_command_get_num_points(GDrawCommand *command);
 
void gdraw_command_set_point(GDrawCommand *command, uint16_t point_idx, GPoint point);
 
GPoint gdraw_command_get_point(GDrawCommand *command, uint16_t point_idx);
 
void gdraw_command_set_radius(GDrawCommand *command, uint16_t radius);
 
uint16_t gdraw_command_get_radius(GDrawCommand *command);
 
void gdraw_command_set_path_open(GDrawCommand *command, bool path_open);
 
bool gdraw_command_get_path_open(GDrawCommand *command);
 
void gdraw_command_set_hidden(GDrawCommand *command, bool hidden);
 
bool gdraw_command_get_hidden(GDrawCommand *command);
 
void gdraw_command_frame_draw(GContext *ctx, GDrawCommandSequence *sequence,
                              GDrawCommandFrame *frame, GPoint offset);
 
void gdraw_command_frame_set_duration(GDrawCommandFrame *frame, uint32_t duration);
 
uint32_t gdraw_command_frame_get_duration(GDrawCommandFrame *frame);
 
GDrawCommandImage *gdraw_command_image_create_with_resource(uint32_t resource_id);
 
GDrawCommandImage *gdraw_command_image_clone(GDrawCommandImage *image);
 
void gdraw_command_image_destroy(GDrawCommandImage *image);
 
void gdraw_command_image_draw(GContext *ctx, GDrawCommandImage *image, GPoint offset);
 
GSize gdraw_command_image_get_bounds_size(GDrawCommandImage *image);
 
void gdraw_command_image_set_bounds_size(GDrawCommandImage *image, GSize size);
 
GDrawCommandList *gdraw_command_image_get_command_list(GDrawCommandImage *image);
 
void gdraw_command_list_iterate(GDrawCommandList *command_list,
                                GDrawCommandListIteratorCb handle_command, void *callback_context);
 
void gdraw_command_list_draw(GContext *ctx, GDrawCommandList *command_list);
 
GDrawCommand *gdraw_command_list_get_command(GDrawCommandList *command_list, uint16_t command_idx);
 
uint32_t gdraw_command_list_get_num_commands(GDrawCommandList *command_list);
 
GDrawCommandSequence *gdraw_command_sequence_create_with_resource(uint32_t resource_id);
 
GDrawCommandSequence *gdraw_command_sequence_clone(GDrawCommandSequence *sequence);
 
void gdraw_command_sequence_destroy(GDrawCommandSequence *sequence);
 
GDrawCommandFrame *gdraw_command_sequence_get_frame_by_elapsed(GDrawCommandSequence *sequence,
                                                               uint32_t elapsed_ms);
 
GDrawCommandFrame *gdraw_command_sequence_get_frame_by_index(GDrawCommandSequence *sequence,
                                                             uint32_t index);
 
GSize gdraw_command_sequence_get_bounds_size(GDrawCommandSequence *sequence);
 
void gdraw_command_sequence_set_bounds_size(GDrawCommandSequence *sequence, GSize size);
 
uint32_t gdraw_command_sequence_get_play_count(GDrawCommandSequence *sequence);
 
void gdraw_command_sequence_set_play_count(GDrawCommandSequence *sequence, uint32_t play_count);
 
uint32_t gdraw_command_sequence_get_total_duration(GDrawCommandSequence *sequence);
 
uint32_t gdraw_command_sequence_get_num_frames(GDrawCommandSequence *sequence);
 
GDrawCommandList *gdraw_command_frame_get_command_list(GDrawCommandFrame *frame);
 
 
 
typedef struct GPathInfo {
  uint32_t num_points;
  GPoint *points;
} GPathInfo;
 
typedef struct GPath {
  uint32_t num_points;
  GPoint *points;
  int32_t rotation;
  GPoint offset;
} GPath;
 
GPath* gpath_create(const GPathInfo *init);
 
void gpath_destroy(GPath* gpath);
 
void gpath_draw_filled(GContext* ctx, GPath *path);
 
void gpath_draw_outline(GContext* ctx, GPath *path);
 
void gpath_rotate_to(GPath *path, int32_t angle);
 
void gpath_move_to(GPath *path, GPoint point);
 
void gpath_draw_outline_open(GContext* ctx, GPath* path);
 
 
 
struct FontInfo;
typedef struct FontInfo FontInfo;
 
typedef FontInfo* GFont;
 
GFont fonts_get_system_font(const char *font_key);
 
GFont fonts_load_custom_font(ResHandle handle);
 
void fonts_unload_custom_font(GFont font);
 
 
 
typedef enum {
  GTextOverflowModeWordWrap,
  GTextOverflowModeTrailingEllipsis,
  GTextOverflowModeFill
} GTextOverflowMode;
 
typedef enum {
  GTextAlignmentLeft,
  GTextAlignmentCenter,
  GTextAlignmentRight,
} GTextAlignment;
 
struct GTextAttributes;
typedef struct GTextAttributes GTextAttributes;
 
GTextAttributes *graphics_text_attributes_create(void);
 
void graphics_text_attributes_destroy(GTextAttributes *text_attributes);
 
void graphics_text_attributes_restore_default_text_flow(GTextAttributes *text_attributes);
 
void graphics_text_attributes_enable_screen_text_flow(GTextAttributes *text_attributes,
                                                      uint8_t inset);
 
void graphics_text_attributes_restore_default_paging(GTextAttributes *text_attributes);
 
void graphics_text_attributes_enable_paging(GTextAttributes *text_attributes,
                                            GPoint content_origin_on_screen,
                                            GRect paging_on_screen);
 
void graphics_draw_text(GContext *ctx, const char *text, GFont const font, const GRect box,
                        const GTextOverflowMode overflow_mode, const GTextAlignment alignment,
                        GTextAttributes *text_attributes);
 
GSize graphics_text_layout_get_content_size(const char *text, GFont const font, const GRect box,
                                                const GTextOverflowMode overflow_mode,
                                                const GTextAlignment alignment);
 
GSize graphics_text_layout_get_content_size_with_attributes(
  const char *text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode,
  const GTextAlignment alignment, GTextAttributes *text_attributes);
 
 
 
 
#define SMARTSTRAP_TIMEOUT_DEFAULT 250
 
#define SMARTSTRAP_RAW_DATA_SERVICE_ID 0
 
#define SMARTSTRAP_RAW_DATA_ATTRIBUTE_ID 0
 
#define PBL_IF_SMARTSTRAP_ELSE(if_true, if_false) (if_true)
 
typedef enum {
  SmartstrapResultOk = 0,
  SmartstrapResultInvalidArgs,
  SmartstrapResultNotPresent,
  SmartstrapResultBusy,
  SmartstrapResultServiceUnavailable,
  SmartstrapResultAttributeUnsupported,
  SmartstrapResultTimeOut,
} SmartstrapResult;
 
typedef uint16_t SmartstrapServiceId;
 
typedef uint16_t SmartstrapAttributeId;
 
typedef struct SmartstrapAttribute SmartstrapAttribute;
 
typedef void (*SmartstrapServiceAvailabilityHandler)(SmartstrapServiceId service_id,
                                                     bool is_available);
 
typedef void (*SmartstrapReadHandler)(SmartstrapAttribute *attribute, SmartstrapResult result,
                                      const uint8_t *data, size_t length);
 
typedef void (*SmartstrapWriteHandler)(SmartstrapAttribute *attribute, SmartstrapResult result);
 
typedef void (*SmartstrapNotifyHandler)(SmartstrapAttribute *attribute);
 
typedef struct {
  SmartstrapServiceAvailabilityHandler availability_did_change;
  SmartstrapReadHandler did_read;
  SmartstrapWriteHandler did_write;
  SmartstrapNotifyHandler notified;
} SmartstrapHandlers;
 
SmartstrapResult smartstrap_subscribe(SmartstrapHandlers handlers);
 
void smartstrap_unsubscribe(void);
 
void smartstrap_set_timeout(uint16_t timeout_ms);
 
SmartstrapAttribute *smartstrap_attribute_create(SmartstrapServiceId service_id,
                                                     SmartstrapAttributeId attribute_id,
                                                     size_t buffer_length);
 
void smartstrap_attribute_destroy(SmartstrapAttribute *attribute);
 
bool smartstrap_service_is_available(SmartstrapServiceId service_id);
 
SmartstrapServiceId smartstrap_attribute_get_service_id(SmartstrapAttribute *attribute);
 
SmartstrapAttributeId smartstrap_attribute_get_attribute_id(SmartstrapAttribute *attribute);
 
SmartstrapResult smartstrap_attribute_read(SmartstrapAttribute *attribute);
 
SmartstrapResult smartstrap_attribute_begin_write(SmartstrapAttribute *attribute,
                                                      uint8_t **buffer, size_t *buffer_length);
 
SmartstrapResult smartstrap_attribute_end_write(SmartstrapAttribute *attribute,
                                                    size_t write_length, bool request_read);
 
 
 
 
typedef void *ClickRecognizerRef;
 
typedef void (*ClickHandler)(ClickRecognizerRef recognizer, void *context);
 
typedef void (*ClickConfigProvider)(void *context);
 
uint8_t click_number_of_clicks_counted(ClickRecognizerRef recognizer);
 
ButtonId click_recognizer_get_button_id(ClickRecognizerRef recognizer);
 
bool click_recognizer_is_repeating(ClickRecognizerRef recognizer);
 
 
 
struct Layer;
typedef struct Layer Layer;
 
typedef void (*LayerUpdateProc)(struct Layer *layer, GContext* ctx);
 
Layer* layer_create(GRect frame);
 
Layer* layer_create_with_data(GRect frame, size_t data_size);
 
void layer_destroy(Layer* layer);
 
void layer_mark_dirty(Layer *layer);
 
void layer_set_update_proc(Layer *layer, LayerUpdateProc update_proc);
 
void layer_set_frame(Layer *layer, GRect frame);
 
GRect layer_get_frame(const Layer *layer);
 
void layer_set_bounds(Layer *layer, GRect bounds);
 
GRect layer_get_bounds(const Layer *layer);
 
GRect layer_get_unobstructed_bounds(const Layer *layer);
 
GPoint layer_convert_point_to_screen(const Layer *layer, GPoint point);
 
GRect layer_convert_rect_to_screen(const Layer *layer, GRect rect);
 
struct Window *layer_get_window(const Layer *layer);
 
void layer_remove_from_parent(Layer *child);
 
void layer_remove_child_layers(Layer *parent);
 
void layer_add_child(Layer *parent, Layer *child);
 
void layer_insert_below_sibling(Layer *layer_to_insert, Layer *below_sibling_layer);
 
void layer_insert_above_sibling(Layer *layer_to_insert, Layer *above_sibling_layer);
 
void layer_set_hidden(Layer *layer, bool hidden);
 
bool layer_get_hidden(const Layer *layer);
 
void layer_set_clips(Layer *layer, bool clips);
 
bool layer_get_clips(const Layer *layer);
 
void* layer_get_data(const Layer *layer);
 
 
 
struct Window;
typedef struct Window Window;
 
typedef void (*WindowHandler)(struct Window *window);
 
typedef struct WindowHandlers {
  WindowHandler load;
 
  WindowHandler appear;
 
  WindowHandler disappear;
 
  WindowHandler unload;
} WindowHandlers;
 
Window* window_create(void);
 
void window_destroy(Window* window);
 
void window_set_click_config_provider(Window *window, ClickConfigProvider click_config_provider);
 
void window_set_click_config_provider_with_context(Window *window, ClickConfigProvider click_config_provider, void *context);
 
ClickConfigProvider window_get_click_config_provider(const Window *window);
 
void *window_get_click_config_context(Window *window);
 
void window_set_window_handlers(Window *window, WindowHandlers handlers);
 
struct Layer* window_get_root_layer(const Window *window);
 
void window_set_background_color(Window *window, GColor background_color);
 
bool window_is_loaded(Window *window);
 
void window_set_user_data(Window *window, void *data);
 
void* window_get_user_data(const Window *window);
 
void window_single_click_subscribe(ButtonId button_id, ClickHandler handler);
 
void window_single_repeating_click_subscribe(ButtonId button_id, uint16_t repeat_interval_ms, ClickHandler handler);
 
void window_multi_click_subscribe(ButtonId button_id, uint8_t min_clicks, uint8_t max_clicks, uint16_t timeout, bool last_click_only, ClickHandler handler);
 
void window_long_click_subscribe(ButtonId button_id, uint16_t delay_ms, ClickHandler down_handler, ClickHandler up_handler);
 
void window_raw_click_subscribe(ButtonId button_id, ClickHandler down_handler, ClickHandler up_handler, void *context);
 
void window_set_click_context(ButtonId button_id, void *context);
 
 
 
void window_stack_push(Window *window, bool animated);
 
Window* window_stack_pop(bool animated);
 
void window_stack_pop_all(const bool animated);
 
bool window_stack_remove(Window *window, bool animated);
 
Window* window_stack_get_top_window(void);
 
bool window_stack_contains_window(Window *window);
 
 
 
struct Animation;
typedef struct Animation Animation;
 
typedef int32_t AnimationProgress;
 
typedef enum {
  AnimationCurveLinear = 0,
  AnimationCurveEaseIn = 1,
  AnimationCurveEaseOut = 2,
  AnimationCurveEaseInOut = 3,
  AnimationCurveDefault = AnimationCurveEaseInOut,
  AnimationCurveCustomFunction = 4,
  AnimationCurveCustomInterpolationFunction = 5,
  // Two more Reserved for forward-compatibility use.
  AnimationCurve_Reserved1 = 6,
  AnimationCurve_Reserved2 = 7,
} AnimationCurve;
 
Animation * animation_create(void);
 
bool animation_destroy(Animation *animation);
 
#define ANIMATION_DURATION_INFINITE UINT32_MAX
 
#define ANIMATION_PLAY_COUNT_INFINITE UINT32_MAX
 
#define ANIMATION_NORMALIZED_MIN 0
 
#define ANIMATION_NORMALIZED_MAX 65535
 
Animation *animation_clone(Animation *from);
 
Animation *animation_sequence_create(Animation *animation_a, Animation *animation_b,
                                     Animation *animation_c, ...);
 
Animation *animation_sequence_create_from_array(Animation **animation_array, uint32_t array_len);
 
Animation *animation_spawn_create(Animation *animation_a, Animation *animation_b,
                                  Animation *animation_c, ...);
 
Animation *animation_spawn_create_from_array(Animation **animation_array, uint32_t array_len);
 
bool animation_set_elapsed(Animation *animation, uint32_t elapsed_ms);
 
bool animation_get_elapsed(Animation *animation, int32_t *elapsed_ms);
 
bool animation_set_reverse(Animation *animation, bool reverse);
 
bool animation_get_reverse(Animation *animation);
 
bool animation_set_play_count(Animation *animation, uint32_t play_count);
 
uint32_t animation_get_play_count(Animation *animation);
 
bool animation_set_duration(Animation *animation, uint32_t duration_ms);
 
uint32_t animation_get_duration(Animation *animation, bool include_delay, bool include_play_count);
 
bool animation_set_delay(Animation *animation, uint32_t delay_ms);
 
uint32_t animation_get_delay(Animation *animation);
 
bool animation_set_curve(Animation *animation, AnimationCurve curve);
 
AnimationCurve animation_get_curve(Animation *animation);
 
typedef AnimationProgress (*AnimationCurveFunction)(AnimationProgress linear_distance);
 
bool animation_set_custom_curve(Animation *animation, AnimationCurveFunction curve_function);
 
AnimationCurveFunction animation_get_custom_curve(Animation *animation);
 
typedef void (*AnimationStartedHandler)(Animation *animation, void *context);
 
typedef void (*AnimationStoppedHandler)(Animation *animation, bool finished, void *context);
 
typedef struct AnimationHandlers {
  AnimationStartedHandler started;
  AnimationStoppedHandler stopped;
} AnimationHandlers;
 
bool animation_set_handlers(Animation *animation, AnimationHandlers callbacks, void *context);
 
void *animation_get_context(Animation *animation);
 
bool animation_schedule(Animation *animation);
 
bool animation_unschedule(Animation *animation);
 
void animation_unschedule_all(void);
 
bool animation_is_scheduled(Animation *animation);
 
typedef void (*AnimationSetupImplementation)(Animation *animation);
 
typedef void (*AnimationUpdateImplementation)(Animation *animation,
              const AnimationProgress progress);
 
typedef void (*AnimationTeardownImplementation)(Animation *animation);
 
typedef struct AnimationImplementation {
  AnimationSetupImplementation setup;
  AnimationUpdateImplementation update;
  AnimationTeardownImplementation teardown;
} AnimationImplementation;
 
bool animation_set_implementation(Animation *animation,
                                  const AnimationImplementation *implementation);
 
const AnimationImplementation* animation_get_implementation(Animation *animation);
 
 
struct PropertyAnimationAccessors;
typedef struct PropertyAnimationAccessors PropertyAnimationAccessors;
 
struct PropertyAnimationImplementation;
typedef struct PropertyAnimationImplementation PropertyAnimationImplementation;
 
struct PropertyAnimation;
typedef struct PropertyAnimation PropertyAnimation;
 
PropertyAnimation *property_animation_create_layer_frame(struct Layer *layer, GRect *from_frame,
                                                         GRect *to_frame);
 
PropertyAnimation *property_animation_create_bounds_origin(struct Layer *layer, GPoint *from,
    GPoint *to);
 
PropertyAnimation* property_animation_create(const PropertyAnimationImplementation *implementation,
                      void *subject, void *from_value, void *to_value);
 
void property_animation_destroy(PropertyAnimation* property_animation);
 
void property_animation_update_int16(PropertyAnimation *property_animation,
                                     const uint32_t distance_normalized);
 
void property_animation_update_uint32(PropertyAnimation *property_animation,
                                      const uint32_t distance_normalized);
 
void property_animation_update_gpoint(PropertyAnimation *property_animation,
                                      const uint32_t distance_normalized);
 
void property_animation_update_grect(PropertyAnimation *property_animation,
                                     const uint32_t distance_normalized);
 
void property_animation_update_gcolor8(PropertyAnimation *property_animation,
                                       const uint32_t distance_normalized);
 
typedef GPoint GPointReturn;
 
typedef GRect GRectReturn;
 
typedef void (*Int16Setter)(void *subject, int16_t int16);
 
typedef int16_t (*Int16Getter)(void *subject);
 
typedef void (*UInt32Setter)(void *subject, uint32_t uint32);
 
typedef uint32_t (*UInt32Getter)(void *subject);
 
typedef void (*GPointSetter)(void *subject, GPoint gpoint);
 
typedef GPointReturn (*GPointGetter)(void *subject);
 
typedef void (*GRectSetter)(void *subject, GRect grect);
 
typedef GRectReturn (*GRectGetter)(void *subject);
 
typedef void (*GColor8Setter)(void *subject, GColor8 gcolor);
 
typedef GColor8 (*GColor8Getter)(void *subject);
 
typedef struct PropertyAnimationAccessors {
  union {
    Int16Setter int16;
    GPointSetter gpoint;
    GRectSetter grect;
    GColor8Setter gcolor8;
    UInt32Setter uint32;
  } setter;
  union {
    Int16Getter int16;
    GPointGetter gpoint;
    GRectGetter grect;
    GColor8Getter gcolor8;
    UInt32Getter uint32;
  } getter;
} PropertyAnimationAccessors;
 
typedef struct PropertyAnimationImplementation {
  AnimationImplementation base;
  PropertyAnimationAccessors accessors;
} PropertyAnimationImplementation;
 
Animation *property_animation_get_animation(PropertyAnimation *property_animation);
 
#define property_animation_clone(property_animation) \
    (PropertyAnimation *)animation_clone((Animation *)property_animation)
 
#define property_animation_get_from_grect(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(GRect), false)
 
#define property_animation_set_from_grect(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(GRect), true)
 
#define property_animation_get_from_gpoint(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(GPoint), false)
 
#define property_animation_set_from_gpoint(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(GPoint), true)
 
#define property_animation_get_from_int16(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(int16_t), false)
 
#define property_animation_set_from_int16(property_animation, value_ptr) \
    property_animation_from(property_animation, value_ptr, sizeof(int16_t), true)
 
#define property_animation_get_to_grect(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(GRect), false)
 
#define property_animation_set_to_grect(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(GRect), true)
 
#define property_animation_get_to_gpoint(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(GPoint), false)
 
#define property_animation_set_to_gpoint(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(GPoint), true)
 
#define property_animation_get_to_int16(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(int16_t), false)
 
#define property_animation_set_to_int16(property_animation, value_ptr) \
    property_animation_to(property_animation, value_ptr, sizeof(int16_t), true)
 
#define property_animation_get_subject(property_animation, value_ptr) \
    property_animation_subject(property_animation, value_ptr, false)
 
#define property_animation_set_subject(property_animation, value_ptr) \
    property_animation_subject(property_animation, value_ptr, true)
 
bool property_animation_subject(PropertyAnimation *property_animation, void **subject, bool set);
 
bool property_animation_from(PropertyAnimation *property_animation, void *from, size_t size,
                              bool set);
 
bool property_animation_to(PropertyAnimation *property_animation, void *to, size_t size,
                            bool set);
 
 
 
 
typedef void (*UnobstructedAreaWillChangeHandler)(GRect final_unobstructed_screen_area,
                                                  void *context);
 
typedef void (*UnobstructedAreaChangeHandler)(AnimationProgress progress, void *context);
 
typedef void (*UnobstructedAreaDidChangeHandler)(void *context);
 
typedef struct UnobstructedAreaHandlers {
  UnobstructedAreaWillChangeHandler will_change;
  UnobstructedAreaChangeHandler change;
  UnobstructedAreaDidChangeHandler did_change;
} UnobstructedAreaHandlers;
 
void unobstructed_area_service_subscribe(UnobstructedAreaHandlers handlers, void *context);
 
void unobstructed_area_service_unsubscribe(void);
 
 
 
 
struct TextLayer;
typedef struct TextLayer TextLayer;
 
TextLayer* text_layer_create(GRect frame);
 
void text_layer_destroy(TextLayer* text_layer);
 
Layer* text_layer_get_layer(TextLayer *text_layer);
 
void text_layer_set_text(TextLayer *text_layer, const char *text);
 
const char* text_layer_get_text(TextLayer *text_layer);
 
void text_layer_set_background_color(TextLayer *text_layer, GColor color);
 
void text_layer_set_text_color(TextLayer *text_layer, GColor color);
 
void text_layer_set_overflow_mode(TextLayer *text_layer, GTextOverflowMode line_mode);
 
void text_layer_set_font(TextLayer *text_layer, GFont font);
 
void text_layer_set_text_alignment(TextLayer *text_layer, GTextAlignment text_alignment);
 
void text_layer_enable_screen_text_flow_and_paging(TextLayer *text_layer, uint8_t inset);
 
void text_layer_restore_default_text_flow_and_paging(TextLayer *text_layer);
 
GSize text_layer_get_content_size(TextLayer *text_layer);
 
void text_layer_set_size(TextLayer *text_layer, const GSize max_size);
 
 
 
struct ScrollLayer;
typedef struct ScrollLayer ScrollLayer;
 
typedef void (*ScrollLayerCallback)(struct ScrollLayer *scroll_layer, void *context);
 
typedef struct ScrollLayerCallbacks {
 
  ClickConfigProvider click_config_provider;
 
  ScrollLayerCallback content_offset_changed_handler;
 
} ScrollLayerCallbacks;
 
ScrollLayer* scroll_layer_create(GRect frame);
 
void scroll_layer_destroy(ScrollLayer *scroll_layer);
 
Layer* scroll_layer_get_layer(const ScrollLayer *scroll_layer);
 
void scroll_layer_add_child(ScrollLayer *scroll_layer, Layer *child);
 
void scroll_layer_set_click_config_onto_window(ScrollLayer *scroll_layer, struct Window *window);
 
void scroll_layer_set_callbacks(ScrollLayer *scroll_layer, ScrollLayerCallbacks callbacks);
 
void scroll_layer_set_context(ScrollLayer *scroll_layer, void *context);
 
void scroll_layer_set_content_offset(ScrollLayer *scroll_layer, GPoint offset, bool animated);
 
GPoint scroll_layer_get_content_offset(ScrollLayer *scroll_layer);
 
void scroll_layer_set_content_size(ScrollLayer *scroll_layer, GSize size);
 
GSize scroll_layer_get_content_size(const ScrollLayer *scroll_layer);
 
void scroll_layer_set_frame(ScrollLayer *scroll_layer, GRect frame);
 
void scroll_layer_scroll_up_click_handler(ClickRecognizerRef recognizer, void *context);
 
void scroll_layer_scroll_down_click_handler(ClickRecognizerRef recognizer, void *context);
 
void scroll_layer_set_shadow_hidden(ScrollLayer *scroll_layer, bool hidden);
 
bool scroll_layer_get_shadow_hidden(const ScrollLayer *scroll_layer);
 
void scroll_layer_set_paging(ScrollLayer *scroll_layer, bool paging_enabled);
 
bool scroll_layer_get_paging(ScrollLayer *scroll_layer);
 
struct ContentIndicator;
typedef struct ContentIndicator ContentIndicator;
 
ContentIndicator *scroll_layer_get_content_indicator(ScrollLayer *scroll_layer);
 
typedef enum {
  ContentIndicatorDirectionUp = 0, 
  ContentIndicatorDirectionDown, 
  NumContentIndicatorDirections 
} ContentIndicatorDirection;
 
typedef struct {
  Layer *layer; 
  bool times_out; 
  GAlign alignment; 
  struct {
    GColor foreground; 
    GColor background; 
  } colors;
} ContentIndicatorConfig;
 
ContentIndicator *content_indicator_create(void);
 
void content_indicator_destroy(ContentIndicator *content_indicator);
 
bool content_indicator_configure_direction(ContentIndicator *content_indicator,
                                           ContentIndicatorDirection direction,
                                           const ContentIndicatorConfig *config);
 
bool content_indicator_get_content_available(ContentIndicator *content_indicator,
                                             ContentIndicatorDirection direction);
 
void content_indicator_set_content_available(ContentIndicator *content_indicator,
                                             ContentIndicatorDirection direction,
                                             bool available);
 
 
 
void menu_cell_basic_draw(GContext* ctx, const Layer *cell_layer, const char *title,
                          const char *subtitle, GBitmap *icon);
 
void menu_cell_title_draw(GContext* ctx, const Layer *cell_layer, const char *title);
 
void menu_cell_basic_header_draw(GContext* ctx, const Layer *cell_layer, const char *title);
 
#define MENU_CELL_BASIC_HEADER_HEIGHT ((const int16_t) 16)
 
 
#define MENU_INDEX_NOT_FOUND ((const uint16_t) ~0)
 
typedef struct MenuIndex {
  uint16_t section;
  uint16_t row;
} MenuIndex;
 
#define MenuIndex(section, row) ((MenuIndex){ (section), (row) })
 
int16_t menu_index_compare(const MenuIndex *a, const MenuIndex *b);
 
typedef struct MenuCellSpan {
  int16_t y;
  int16_t h;
  int16_t sep;
  MenuIndex index;
} MenuCellSpan;
 
struct MenuLayer;
typedef struct MenuLayer MenuLayer;
 
typedef uint16_t (*MenuLayerGetNumberOfSectionsCallback)(struct MenuLayer *menu_layer,
                                                         void *callback_context);
 
typedef uint16_t (*MenuLayerGetNumberOfRowsInSectionsCallback)(struct MenuLayer *menu_layer,
                                                               uint16_t section_index,
                                                               void *callback_context);
 
typedef int16_t (*MenuLayerGetCellHeightCallback)(struct MenuLayer *menu_layer,
                                                  MenuIndex *cell_index,
                                                  void *callback_context);
 
typedef int16_t (*MenuLayerGetHeaderHeightCallback)(struct MenuLayer *menu_layer,
                                                    uint16_t section_index,
                                                    void *callback_context);
 
typedef int16_t (*MenuLayerGetSeparatorHeightCallback)(struct MenuLayer *menu_layer,
                                                       MenuIndex *cell_index,
                                                       void *callback_context);
 
typedef void (*MenuLayerDrawRowCallback)(GContext* ctx,
                                         const Layer *cell_layer,
                                         MenuIndex *cell_index,
                                         void *callback_context);
 
typedef void (*MenuLayerDrawHeaderCallback)(GContext* ctx,
                                            const Layer *cell_layer,
                                            uint16_t section_index,
                                            void *callback_context);
 
typedef void (*MenuLayerDrawSeparatorCallback)(GContext* ctx,
                                               const Layer *cell_layer,
                                               MenuIndex *cell_index,
                                               void *callback_context);
 
typedef void (*MenuLayerSelectCallback)(struct MenuLayer *menu_layer,
                                        MenuIndex *cell_index,
                                        void *callback_context);
 
typedef void (*MenuLayerSelectionChangedCallback)(struct MenuLayer *menu_layer,
                                                  MenuIndex new_index,
                                                  MenuIndex old_index,
                                                  void *callback_context);
 
typedef void (*MenuLayerSelectionWillChangeCallback)(struct MenuLayer *menu_layer,
                                                     MenuIndex *new_index,
                                                     MenuIndex old_index,
                                                     void *callback_context);
 
typedef void (*MenuLayerDrawBackgroundCallback)(GContext* ctx,
                                                const Layer *bg_layer,
                                                bool highlight,
                                                void *callback_context);
 
typedef struct MenuLayerCallbacks {
  MenuLayerGetNumberOfSectionsCallback get_num_sections;
 
  MenuLayerGetNumberOfRowsInSectionsCallback get_num_rows;
 
  MenuLayerGetCellHeightCallback get_cell_height;
 
  MenuLayerGetHeaderHeightCallback get_header_height;
 
  MenuLayerDrawRowCallback draw_row;
 
  MenuLayerDrawHeaderCallback draw_header;
 
  MenuLayerSelectCallback select_click;
 
  MenuLayerSelectCallback select_long_click;
 
  MenuLayerSelectionChangedCallback selection_changed;
 
  MenuLayerGetSeparatorHeightCallback get_separator_height;
 
  MenuLayerDrawSeparatorCallback draw_separator;
 
  MenuLayerSelectionWillChangeCallback selection_will_change;
 
  MenuLayerDrawBackgroundCallback draw_background;
} MenuLayerCallbacks;
 
MenuLayer* menu_layer_create(GRect frame);
 
void menu_layer_destroy(MenuLayer* menu_layer);
 
Layer* menu_layer_get_layer(const MenuLayer *menu_layer);
 
ScrollLayer* menu_layer_get_scroll_layer(const MenuLayer *menu_layer);
 
void menu_layer_set_callbacks(MenuLayer *menu_layer, void *callback_context,
                                       MenuLayerCallbacks callbacks);
 
void menu_layer_set_click_config_onto_window(MenuLayer *menu_layer,
                                             struct Window *window);
 
typedef enum {
  MenuRowAlignNone,
 
  MenuRowAlignCenter,
 
  MenuRowAlignTop,
 
  MenuRowAlignBottom,
} MenuRowAlign;
 
void menu_layer_set_selected_next(MenuLayer *menu_layer,
                                  bool up,
                                  MenuRowAlign scroll_align,
                                  bool animated);
 
void menu_layer_set_selected_index(MenuLayer *menu_layer,
                                   MenuIndex index, MenuRowAlign scroll_align,
                                   bool animated);
 
MenuIndex menu_layer_get_selected_index(const MenuLayer *menu_layer);
 
void menu_layer_reload_data(MenuLayer *menu_layer);
 
bool menu_cell_layer_is_highlighted(const Layer *cell_layer);
 
void menu_layer_set_normal_colors(MenuLayer *menu_layer, GColor background, GColor foreground);
 
void menu_layer_set_highlight_colors(MenuLayer *menu_layer, GColor background, GColor foreground);
 
void menu_layer_pad_bottom_enable(MenuLayer *menu_layer, bool enable);
 
bool menu_layer_get_center_focused(MenuLayer *menu_layer);
 
void menu_layer_set_center_focused(MenuLayer *menu_layer, bool center_focused);
 
bool menu_layer_is_index_selected(const MenuLayer *menu_layer, MenuIndex *index);
 
#define MENU_CELL_ROUND_FOCUSED_SHORT_CELL_HEIGHT ((const int16_t) 68)
 
#define MENU_CELL_ROUND_UNFOCUSED_SHORT_CELL_HEIGHT ((const int16_t) 24)
 
#define MENU_CELL_ROUND_FOCUSED_TALL_CELL_HEIGHT ((const int16_t) 84)
 
#define MENU_CELL_ROUND_UNFOCUSED_TALL_CELL_HEIGHT ((const int16_t) 32)
 
 
 
struct SimpleMenuLayer;
typedef struct SimpleMenuLayer SimpleMenuLayer;
 
typedef void (*SimpleMenuLayerSelectCallback)(int index, void *context);
 
typedef struct {
  const char *title;
  const char *subtitle;
  GBitmap *icon;
  SimpleMenuLayerSelectCallback callback;
} SimpleMenuItem;
 
typedef struct {
  const char *title;
  const SimpleMenuItem *items;
  uint32_t num_items;
} SimpleMenuSection;
 
SimpleMenuLayer* simple_menu_layer_create(GRect frame, Window *window,
    const SimpleMenuSection *sections, int32_t num_sections, void *callback_context);
 
void simple_menu_layer_destroy(SimpleMenuLayer* menu_layer);
 
Layer* simple_menu_layer_get_layer(const SimpleMenuLayer *simple_menu);
 
int simple_menu_layer_get_selected_index(const SimpleMenuLayer *simple_menu);
 
void simple_menu_layer_set_selected_index(SimpleMenuLayer *simple_menu, int32_t index, bool animated);
 
MenuLayer *simple_menu_layer_get_menu_layer(SimpleMenuLayer *simple_menu);
 
 
 
#define ACTION_BAR_WIDTH _ACTION_BAR_WIDTH(PBL_PLATFORM_TYPE_CURRENT)
 
#define _ACTION_BAR_WIDTH(plat) PBL_PLATFORM_SWITCH(plat, \
  /*aplite*/ 30, \
  /*basalt*/ 30, \
  /*chalk*/ 40, \
  /*diorite*/ 30, \
  /*emery*/ 34)
 
#define NUM_ACTION_BAR_ITEMS 3
 
typedef enum {
  ActionBarLayerIconPressAnimationNone = 0,
  ActionBarLayerIconPressAnimationMoveLeft,
  ActionBarLayerIconPressAnimationMoveUp,
  ActionBarLayerIconPressAnimationMoveRight,
  ActionBarLayerIconPressAnimationMoveDown,
} ActionBarLayerIconPressAnimation;
 
struct ActionBarLayer;
typedef struct ActionBarLayer ActionBarLayer;
 
ActionBarLayer* action_bar_layer_create(void);
 
void action_bar_layer_destroy(ActionBarLayer *action_bar_layer);
 
Layer* action_bar_layer_get_layer(ActionBarLayer *action_bar_layer);
 
void action_bar_layer_set_context(ActionBarLayer *action_bar, void *context);
 
void action_bar_layer_set_click_config_provider(ActionBarLayer *action_bar, ClickConfigProvider click_config_provider);
 
void action_bar_layer_set_icon(ActionBarLayer *action_bar, ButtonId button_id, const GBitmap *icon);
 
void action_bar_layer_clear_icon(ActionBarLayer *action_bar, ButtonId button_id);
 
void action_bar_layer_add_to_window(ActionBarLayer *action_bar, struct Window *window);
 
void action_bar_layer_remove_from_window(ActionBarLayer *action_bar);
 
void action_bar_layer_set_background_color(ActionBarLayer *action_bar, GColor background_color);
 
void action_bar_layer_set_icon_animated(ActionBarLayer *action_bar, ButtonId button_id,
                                        const GBitmap *icon, bool animated);
 
void action_bar_layer_set_icon_press_animation(ActionBarLayer *action_bar, ButtonId button_id,
                                               ActionBarLayerIconPressAnimation animation);
 
 
 
struct StatusBarLayer;
typedef struct StatusBarLayer StatusBarLayer;
 
typedef enum {
  StatusBarLayerSeparatorModeNone = 0,
  StatusBarLayerSeparatorModeDotted = 1,
} StatusBarLayerSeparatorMode;
 
#define STATUS_BAR_LAYER_HEIGHT _STATUS_BAR_LAYER_HEIGHT(PBL_PLATFORM_TYPE_CURRENT)
 
#define _STATUS_BAR_LAYER_HEIGHT(plat) PBL_PLATFORM_SWITCH(plat, \
  /*aplite*/ 16, \
  /*basalt*/ 16, \
  /*chalk*/ 24, \
  /*diorite*/ 16, \
  /*emery*/ 20)
 
StatusBarLayer *status_bar_layer_create(void);
 
void status_bar_layer_destroy(StatusBarLayer *status_bar_layer);
 
Layer *status_bar_layer_get_layer(StatusBarLayer *status_bar_layer);
 
GColor status_bar_layer_get_background_color(const StatusBarLayer *status_bar_layer);
 
GColor status_bar_layer_get_foreground_color(const StatusBarLayer *status_bar_layer);
 
void status_bar_layer_set_colors(StatusBarLayer *status_bar_layer, GColor background,
                                 GColor foreground);
 
void status_bar_layer_set_separator_mode(StatusBarLayer *status_bar_layer,
                                         StatusBarLayerSeparatorMode mode);
 
 
 
struct BitmapLayer;
typedef struct BitmapLayer BitmapLayer;
 
BitmapLayer* bitmap_layer_create(GRect frame);
 
void bitmap_layer_destroy(BitmapLayer* bitmap_layer);
 
Layer* bitmap_layer_get_layer(const BitmapLayer *bitmap_layer);
 
const GBitmap* bitmap_layer_get_bitmap(BitmapLayer *bitmap_layer);
 
void bitmap_layer_set_bitmap(BitmapLayer *bitmap_layer, const GBitmap *bitmap);
 
void bitmap_layer_set_alignment(BitmapLayer *bitmap_layer, GAlign alignment);
 
void bitmap_layer_set_background_color(BitmapLayer *bitmap_layer, GColor color);
 
void bitmap_layer_set_compositing_mode(BitmapLayer *bitmap_layer, GCompOp mode);
 
 
 
struct RotBitmapLayer;
typedef struct RotBitmapLayer RotBitmapLayer;
 
RotBitmapLayer* rot_bitmap_layer_create(GBitmap *bitmap);
 
void rot_bitmap_layer_destroy(RotBitmapLayer *bitmap);
 
void rot_bitmap_layer_set_corner_clip_color(RotBitmapLayer *bitmap, GColor color);
 
void rot_bitmap_layer_set_angle(RotBitmapLayer *bitmap, int32_t angle);
 
void rot_bitmap_layer_increment_angle(RotBitmapLayer *bitmap, int32_t angle_change);
 
void rot_bitmap_set_src_ic(RotBitmapLayer *bitmap, GPoint ic);
 
void rot_bitmap_set_compositing_mode(RotBitmapLayer *bitmap, GCompOp mode);
 
 
 
 
 
struct NumberWindow;
typedef struct NumberWindow NumberWindow;
 
typedef void (*NumberWindowCallback)(struct NumberWindow *number_window, void *context);
 
typedef struct {
  NumberWindowCallback incremented;
  NumberWindowCallback decremented;
  NumberWindowCallback selected;
} NumberWindowCallbacks;
 
NumberWindow* number_window_create(const char *label, NumberWindowCallbacks callbacks, void *callback_context);
 
void number_window_destroy(NumberWindow* number_window);
 
void number_window_set_label(NumberWindow *numberwindow, const char *label);
 
void number_window_set_max(NumberWindow *numberwindow, int32_t max);
 
void number_window_set_min(NumberWindow *numberwindow, int32_t min);
 
void number_window_set_value(NumberWindow *numberwindow, int32_t value);
 
void number_window_set_step_size(NumberWindow *numberwindow, int32_t step);
 
int32_t number_window_get_value(const NumberWindow *numberwindow);
 
Window *number_window_get_window(NumberWindow *numberwindow);
 
 
 
struct ActionMenuItem;
typedef struct ActionMenuItem ActionMenuItem;
 
struct ActionMenuLevel;
typedef struct ActionMenuLevel ActionMenuLevel;
 
typedef enum {
  ActionMenuAlignTop = 0,
  ActionMenuAlignCenter
} ActionMenuAlign;
 
typedef struct ActionMenu ActionMenu;
 
typedef void (*ActionMenuDidCloseCb)(ActionMenu *menu,
                                     const ActionMenuItem *performed_action,
                                     void *context);
 
typedef enum {
  ActionMenuLevelDisplayModeWide, 
  ActionMenuLevelDisplayModeThin, 
} ActionMenuLevelDisplayMode;
 
typedef void (*ActionMenuPerformActionCb)(ActionMenu *action_menu,
                                          const ActionMenuItem *action,
                                          void *context);
 
typedef void (*ActionMenuEachItemCb)(const ActionMenuItem *item, void *context);
 
typedef struct {
  const ActionMenuLevel *root_level; 
  void *context; 
  struct {
    GColor background; 
    GColor foreground; 
  } colors;
  ActionMenuDidCloseCb will_close; 
  ActionMenuDidCloseCb did_close; 
  ActionMenuAlign align;
} ActionMenuConfig;
 
char *action_menu_item_get_label(const ActionMenuItem *item);
 
void *action_menu_item_get_action_data(const ActionMenuItem *item);
 
ActionMenuLevel *action_menu_level_create(uint16_t max_items);
 
void action_menu_level_set_display_mode(ActionMenuLevel *level,
                                        ActionMenuLevelDisplayMode display_mode);
 
ActionMenuItem *action_menu_level_add_action(ActionMenuLevel *level,
                                             const char *label,
                                             ActionMenuPerformActionCb cb,
                                             void *action_data);
 
ActionMenuItem *action_menu_level_add_child(ActionMenuLevel *level,
                                            ActionMenuLevel *child,
                                            const char *label);
 
void action_menu_hierarchy_destroy(const ActionMenuLevel *root,
                                   ActionMenuEachItemCb each_cb,
                                   void *context);
 
void *action_menu_get_context(ActionMenu *action_menu);
 
ActionMenuLevel *action_menu_get_root_level(ActionMenu *action_menu);
 
ActionMenu *action_menu_open(ActionMenuConfig *config);
 
void action_menu_freeze(ActionMenu *action_menu);
 
void action_menu_unfreeze(ActionMenu *action_menu);
 
void action_menu_set_result_window(ActionMenu *action_menu, Window *result_window);
 
void action_menu_close(ActionMenu *action_menu, bool animated);
 
 
 
 
typedef struct {
  const uint32_t *durations;
  uint32_t num_segments;
} VibePattern;
 
void vibes_cancel(void);
 
void vibes_short_pulse(void);
 
void vibes_long_pulse(void);
 
void vibes_double_pulse(void);
 
void vibes_enqueue_custom_pattern(VibePattern pattern);
 
 
 
void light_enable_interaction(void);
 
void light_enable(bool enable);
 
 
 
uint32_t preferred_result_display_duration(void);
 
typedef enum PreferredContentSize {
  PreferredContentSizeSmall,
  PreferredContentSizeMedium,
  PreferredContentSizeLarge,
  PreferredContentSizeExtraLarge,
  NumPreferredContentSizes,
} PreferredContentSize;
 
PreferredContentSize preferred_content_size(void);
 
bool quiet_time_is_active(void);
 
 
 
 
 
 
 
#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) noexcept;
 
double difftime(time_t end, time_t beginning) noexcept;
 
uint16_t time_ms(time_t *t_utc, uint16_t *out_ms);
 
time_t time_start_of_today(void);