The core of the Pebble SDK.

App entry point and event loop.

The event loop for C apps, to be used in app's main(). Will block until the app is ready to exit.

API for interacting with the Pebble communication subsystem.

Intervals during which the Bluetooth module may enter a low power mode. The sniff interval defines the period during which the Bluetooth module may not exchange (ACL) packets. The longer the sniff interval, the more time the Bluetooth module may spend in a low power mode. It may be necessary to reduce the sniff interval if an app requires reduced latency when sending messages.

Set the sniff interval to normal (power-saving) mode.

Reduce the sniff interval to increase the responsiveness of the radio at the expense of increasing Bluetooth energy consumption by a multiple of 2-5 (very significant)

Set the Bluetooth module's sniff interval. The sniff interval will be restored to normal by the OS after the app's de-init handler is called. Set the sniff interval to normal whenever possible.

Get the Bluetooth module's sniff interval.

API for the application to modify its glance.

The ID of a published app resource defined within the publishedMedia section of package.json.

Can be used for the expiration_time of an AppGlanceSlice so that the slice never expires.

Can be used for the icon of an AppGlanceSlice so that the slice displays the app's default icon.

Bitfield enum describing the result of trying to add an AppGlanceSlice to an app's glance.

The slice was successfully added to the app's glance.

The subtitle_template_string provided in the slice was invalid.

The subtitle_template_string provided in the slice was longer than 150 bytes.

The icon provided in the slice was invalid.

The provided slice would exceed the app glance's slice capacity.

The expiration_time provided in the slice expires in the past.

The AppGlanceReloadSession provided was invalid.

Add a slice to the app's glance. This function will only succeed if called with a valid AppGlanceReloadSession that is provided in an AppGlanceReloadCallback.

User-provided callback for reloading the slices in the app's glance.

Clear any existing slices in the app's glance and trigger a reload via the provided callback.

An app's glance can change over time as defined by zero or more app glance slices that each describe the state of the app glance at a particular point in time. Slices are displayed in the order they are added, and they are removed at the specified expiration time.

AppMessage result codes.

(0) All good, operation was successful.

(2) The other end did not confirm receiving the sent data with an (n)ack in time.

(4) The other end rejected the sent data, with a "nack" reply.

(8) The other end was not connected.

(16) The local application was not running.

(32) The function was called with invalid arguments.

(64) There are pending (in or outbound) messages that need to be processed first before new ones can be received or sent.

(128) The buffer was too small to contain the incoming message.

(512) The resource had already been released.

(1024) The callback was already registered.

(2048) The callback could not be deregistered, because it had not been registered before.

(4096) The system did not have sufficient application memory to perform the requested operation.

(8192) App message was closed.

(16384) An internal OS error prevented AppMessage from completing an operation.

(32768) The function was called while App Message was not in the appropriate state.

Open AppMessage to transfers.

Deregisters all callbacks and their context.

Called after an incoming message is received.

Called after an incoming message is dropped.

Called after an outbound message has been sent and the reply has been received.

Called after an outbound message has not been sent successfully.

Gets the context that will be passed to all AppMessage callbacks.

Sets the context that will be passed to all AppMessage callbacks.

Registers a function that will be called after any Inbox message is received successfully.

Registers a function that will be called after any Inbox message is received but dropped by the system.

Registers a function that will be called after any Outbox message is sent and an ACK reply occurs in a timely fashion.

Registers a function that will be called after any Outbox message is not sent with a timely ACK reply. The call to app_message_outbox_send() must have succeeded.

Programatically determine the inbox size maximum in the current configuration.

Programatically determine the outbox size maximum in the current configuration.

Begin writing to the Outbox's Dictionary buffer.

Sends the outbound dictionary.

As long as the firmware maintains its current major version, inboxes of this size or smaller will be allowed.

As long as the firmware maintains its current major version, outboxes of this size or smaller will be allowed.

UI synchronization layer for AppMessage

Called whenever a Tuple changes. This does not necessarily mean the value in the Tuple has changed. When the internal "current" dictionary gets updated, existing Tuples might get shuffled around in the backing buffer, even though the values stay the same. In this callback, the client code gets the chance to remove the old reference and start using the new one. In this callback, your application MUST clean up any references to the old_tuple of a PREVIOUS call to this callback (and replace it with the new_tuple that is passed in with the current call).

Called whenever there was an error.

Initialized an AppSync system with specific buffer size and initial keys and values. The callback.value_changed callback will be called asynchronously with the initial keys and values, as to avoid duplicating code to update your app's UI.

Cleans up an AppSync system. It frees the buffer allocated by an app_sync_init() call and deregisters itself from the AppMessage subsystem.

Updates key/value pairs using an array of Tuplets.

Finds and gets a tuple in the "current" dictionary.

Runs in the background, and can communicate with the foreground app.

Possible error codes from app_worker_launch, app_worker_kill.

Success.

No worker found for the current app.

A worker for a different app is already running.

The worker is not running.

The worker is already running.

The user will be asked for confirmation.

Determine if the worker for the current app is running.

Launch the worker for the current app. Note that this is an asynchronous operation, a result code of APP_WORKER_RESULT_SUCCESS merely means that the request was successfully queued up.

Kill the worker for the current app. Note that this is an asynchronous operation, a result code of APP_WORKER_RESULT_SUCCESS merely means that the request was successfully queued up.

Callback type for worker messages. Messages can be sent from worker to app or vice versa.

Subscribe to worker messages. Once subscribed, the handler gets called on every message emitted by the other task (either worker or app).

Unsubscribe from worker messages. Once unsubscribed, the previously registered handler will no longer be called.

Send a message to the other task (either worker or app).

Generic structure of a worker message that can be sent between an app and its worker.

Enables logging data asynchronously to a mobile app

The different types of session data that Pebble supports. This type describes the type of a singular item in the data session. Every item in a given session is the same type and size.

Array of bytes. Remember that this is the type of a single item in the logging session, so using this type means you'll be logging multiple byte arrays (each a fixed length described by item_length) for the duration of the session.

Unsigned integer. This may be a 1, 2, or 4 byte integer depending on the item_length parameter.

Signed integer. This may be a 1, 2, or 4 byte integer depending on the item_length parameter.

Enumerated values describing the possible outcomes of data logging operations.

Successful operation.

Someone else is writing to this logging session.

No more space to save data.

The logging session does not exist.

The logging session was made inactive.

An invalid parameter was passed to one of the functions.

An internal error occurred.

Create a new data logging session.

Finish up a data logging_session. Logging data is kept until it has successfully been transferred over to the phone, but no data may be added to the session after this function is called.

Add data to the data logging session. If a phone is available, the data is sent directly to the phone. Otherwise, it is saved to the watch storage until the watch is connected to a phone.

Make a Uuid object from sixteen bytes.

Creates a Uuid from an array of bytes with 16 bytes in Big Endian order.

Creates a Uuid from an array of bytes with 16 bytes in Little Endian order.

Compares two UUIDs.

Writes UUID in a string form into buffer that looks like the following... {12345678-1234-5678-1234-567812345678} or {NULL UUID} if NULL was passed.

The minimum required length of a string used to hold a uuid (including null).

Transcription successful, with a valid result.

User rejected transcription and exited UI.

User exited UI after transcription error.

Too many errors occurred during transcription and the UI exited.

No speech was detected and UI exited.

No BT or internet connection.

Voice transcription disabled for this user.

Voice transcription failed due to internal error.

Cloud recognizer failed to transcribe speech (only possible if error dialogs disabled)

Dictation status callback. Indicates success or failure of the dictation session and, if successful, passes the transcribed string to the user of the dictation session. The transcribed string will be freed after this call returns, so the string should be copied if it needs to be retained afterwards.

Create a dictation session. The session object can be used more than once to get a transcription. When a transcription is received a buffer will be allocated to store the text in with a maximum size specified by buffer_size. When a transcription and accepted by the user or a failure of some sort occurs, the callback specified will be called with the status and the transcription if one was accepted.

Destroy the dictation session and free its memory. Will terminate a session in progress.

Start the dictation session. The dictation UI will be shown. When the user accepts a transcription or exits the UI, or, when the confirmation dialog is disabled and a status is received, the status callback will be called. Can only be called when no session is in progress. The session can be restarted multiple times after the UI is exited or the session is stopped.

Stop the current dictation session. The UI will be hidden and no status callbacks will be received after the session is stopped.

Enable or disable user confirmation of transcribed text, which allows the user to accept or reject (and restart) the transcription. Must be called before the session is started.

Enable or disable error dialogs when transcription fails. Must be called before the session is started. Disabling error dialogs will also disable automatic retries if transcription fails.

Convenience macro to switch between two expressions depending on mic support. On platforms with a mic the first expression will be chosen, the second otherwise.

Data serialization utilities

Return values for dictionary write/conversion functions.

The operation returned successfully.

There was not enough backing storage to complete the operation.

One or more arguments were invalid or uninitialized.

The lengths and/or count of the dictionary its tuples are inconsistent.

A requested operation required additional memory to be allocated, but the allocation failed, likely due to insufficient remaining heap memory.

Values representing the type of data that the value field of a Tuple contains.

The value is an array of bytes.

The value is a zero-terminated, UTF-8 C-string.

The value is an unsigned integer. The tuple's .length field is used to determine the size of the integer (1, 2, or 4 bytes).

The value is a signed integer. The tuple's .length field is used to determine the size of the integer (1, 2, or 4 bytes).

Calculates the number of bytes that a dictionary will occupy, given one or more value lengths that need to be stored in the dictionary.

Calculates the size of data that has been written to the dictionary. AKA, the "dictionary size". Note that this is most likely different than the size of the backing storage/backing buffer.

Initializes the dictionary iterator with a given buffer and size, resets and empties it, in preparation of writing key/value tuples.

Adds a key with a byte array value pair to the dictionary.

Adds a key with a C string value pair to the dictionary.

Adds a key with an integer value pair to the dictionary.

Adds a key with an unsigned, 8-bit integer value pair to the dictionary.

End a series of writing operations to a dictionary. This must be called before reading back from the dictionary.

Initializes the dictionary iterator with a given buffer and size, in preparation of reading key/value tuples.

Progresses the iterator to the next key/value pair.

Resets the iterator back to the same state as a call to dict_read_begin_from_buffer() would do.

Macro to create a Tuplet with a byte array value.

Macro to create a Tuplet with a c-string value.

Macro to create a Tuplet with an integer value.

Callback for dict_serialize_tuplets() utility.

Utility function that takes a list of Tuplets from which a dictionary will be serialized, ready to transmit or store.

Utility function that takes an array of Tuplets and serializes them into a dictionary with a given buffer and size.

Serializes an array of Tuplets into a dictionary with a given buffer and size.

Serializes a Tuplet and writes the resulting Tuple into a dictionary.

Calculates the number of bytes that a dictionary will occupy, given one or more Tuplets that need to be stored in the dictionary.

Type of the callback used in dict_merge()

Merges entries from another "source" dictionary into a "destination" dictionary. All Tuples from the source are written into the destination dictionary, while updating the exsting Tuples with matching keys.

Tries to find a Tuple with specified key in a dictionary.

An iterator can be used to iterate over the key/value tuples in an existing dictionary, using dict_read_begin_from_buffer(), dict_read_first() and dict_read_next(). An iterator can also be used to append key/value tuples to a dictionary, for example using dict_write_data() or dict_write_cstring().

Data structure for one serialized key/value tuple.

Non-serialized, template data structure for a key/value pair. For strings and byte arrays, it only has a pointer to the actual data. For integers, it provides storage for integers up to 32-bits wide. The Tuplet data structure is useful when creating dictionaries from values that are already stored in arbitrary buffers. See also Tuple, with is the header of a serialized key/value pair.

APIs to handle event services.

Enumerated values defining the three accelerometer axes.

Accelerometer's X axis. The positive direction along the X axis goes toward the right of the watch.

Accelerometer's Y axis. The positive direction along the Y axis goes toward the top of the watch.

Accelerometer's Z axis. The positive direction along the Z axis goes vertically out of the watchface.

Callback type for accelerometer data events.

Callback type for accelerometer raw data events.

Callback type for accelerometer tap events.

Valid accelerometer sampling rates, in Hz.

10 HZ sampling rate

25 HZ sampling rate [Default]

50 HZ sampling rate

100 HZ sampling rate

Peek at the last recorded reading.

Change the accelerometer sampling rate.

Change the number of samples buffered between each accelerometer data event.

Subscribe to the accelerometer data event service. Once subscribed, the handler gets called every time there are new accelerometer samples available.

Unsubscribe from the accelerometer data event service. Once unsubscribed, the previously registered handler will no longer be called.

Subscribe to the accelerometer tap event service. Once subscribed, the handler gets called on every tap event emitted by the accelerometer.

Unsubscribe from the accelerometer tap event service. Once unsubscribed, the previously registered handler will no longer be called.

Subscribe to the accelerometer raw data event service. Once subscribed, the handler gets called every time there are new accelerometer samples available.

A single accelerometer sample for all three axes including timestamp and vibration rumble status.

A single accelerometer sample for all three axes.

Callback type for focus events.

Subscribe to the focus event service. Once subscribed, the handlers get called every time the app gains or loses focus.

Subscribe to the focus event service. Once subscribed, the handler gets called every time the app focus changes.

Unsubscribe from the focus event service. Once unsubscribed, the previously registered handlers will no longer be called.

There are two different focus events which take place when transitioning to and from an app being in focus. Below is an example of when these events will occur: 1) The app is launched. Once the system animation to the app has completed and the app is completely in focus, the did_focus handler is called with in_focus set to true. 2) A notification comes in and the animation to show the notification starts. The will_focus handler is called with in_focus set to false. 3) The animation completes and the notification is in focus, with the app being completely covered. The did_focus hander is called with in_focus set to false. 4) The notification is dismissed and the animation to return to the app starts. The will_focus handler is called with in_focus set to true. 5) The animation completes and the app is in focus. The did_focus handler is called with in_focus set to true.

Callback type for battery state change events.

Subscribe to the battery state event service. Once subscribed, the handler gets called on every battery state change.

Unsubscribe from the battery state event service. Once unsubscribed, the previously registered handler will no longer be called.

Peek at the last known battery state.

Structure for retrieval of the battery charge state.

Enum describing the current state of the Compass Service.

The Compass Service is unavailable.

Compass is calibrating: data is invalid and should not be used Data will become valid once calibration is complete.

Compass is calibrating: the data is valid but the calibration is still being refined.

Compass data is valid and the calibration has completed.

Represents an angle relative to get to a reference direction, e.g. (magnetic) north. The angle value is scaled linearly, such that a value of TRIG_MAX_ANGLE corresponds to 360 degrees or 2 PI radians. Thus, if heading towards north, north is 0, west is TRIG_MAX_ANGLE/4, south is TRIG_MAX_ANGLE/2, and so on.

Callback type for compass heading events.

Set the minimum angular change required to generate new compass heading events. The angular distance is measured relative to the last delivered heading event. Use 0 to be notified of all movements. Negative values and values > TRIG_MAX_ANGLE / 2 are not valid. The default value of this property is TRIG_MAX_ANGLE / 360.

Subscribe to the compass heading event service. Once subscribed, the handler gets called every time the angular distance relative to the previous value exceeds the configured filter.

Unsubscribe from the compass heading event service. Once unsubscribed, the previously registered handler will no longer be called.

Peek at the last recorded reading.

Structure containing a single heading towards magnetic and true north.

Determine what the Pebble watch is connected to

Query the bluetooth connection service for the current Pebble app connection status.

Query the bluetooth connection service for the current PebbleKit connection status.

Subscribe to the connection event service. Once subscribed, the appropriate handler gets called based on the type of connection event and user provided handlers.

Unsubscribe from the bluetooth event service. Once unsubscribed, the previously registered handler will no longer be called.

Health metric values used to retrieve health data. For example, using health_service_sum().

The number of steps counted.

The number of seconds spent active (i.e. not resting).

The distance walked, in meters.

The number of seconds spent sleeping.

The number of sleep seconds in the 'restful' or deep sleep state.

The number of kcal (Calories) burned while resting due to resting metabolism.

The number of kcal (Calories) burned while active.

The heart rate, in beats per minute. This is a filtered value that is at most 15 minutes old.

The raw heart rate value of the most recent sample, in beats per minute.

Type used to represent HealthMetric values.

Type used as a handle to a registered metric alert (returned by health_service_register_metric_alert)

Return the sum of a HealthMetric's values over a time range. The time_start and time_end parameters define the range of time you want the sum for.

Convenience wrapper for health_service_sum() that returns the sum for today.

Convenience function for peeking at the current value of a metric. This is useful for metrics like HealthMetricHeartRateBPM that represent instantaneous values. It is NOT applicable for metrics like HealthMetricStepCount that must be accumulated over time (it will return 0 if passed that type of metric). This call is equivalent to calling health_service_aggregate_averaged(metric, time(NULL), time(NULL), HealthAggregationAvg, HealthServiceTimeScopeOnce)

Used by health_service_sum_averaged() to specify how the average is computed.

No average computed. The result is the same as calling health_service_sum().

Compute average using the same day from each week. For example, every Monday if the passed in time range falls on a Monday.

Compute average using either weekdays (Monday to Friday) or weekends (Saturday and Sunday), depending on which day the passed in time range falls.

Compute average across all days of the week.

Return the value of a metric's sum over a given time range between time_start and time_end. Using this call you can specify the time range that you are interested in getting the average for, as well as a scope specifier on how to compute an average of the sum. For example, if you want to get the average number of steps taken from 12 AM (midnight) to 9 AM across all days you would specify:

Used by health_service_aggregate_averaged() to specify what type of aggregation to perform. This aggregation is applied to the metric before the average is computed.

Sum the metric. The result is the same as calling health_service_sum_averaged(). This operation is only applicable for metrics that accumulate, like HealthMetricStepCount, HealthMetricActiveSeconds, etc.

Use the average of the metric. This is only applicable for metrics that measure instantaneous values, like HealthMetricHeartRateBPM.

Use the minimum value of the metric. This is only applicable for metrics that measure instantaneous values, like HealthMetricHeartRateBPM.

Use the maximum value of the metric. This is only applicable for metrics that measure instantaneous values, like HealthMetricHeartRateBPM.

Return the value of an aggregated metric over a given time range. This call is more flexible than health_service_sum_averaged because it lets you specify which aggregation function to perform.

Expresses a set of HealthActivity values as a bitmask.

A mask value representing all available activities.

Health-related activities that can be accessed using.

No special activity.

The 'sleeping' activity.

The 'restful sleeping' activity.

The 'walk' activity.

The 'run' activity.

The 'generic' activity.

Return a HealthActivityMask containing a set of bits, one set for each activity that is currently active.

Callback used by health_service_activities_iterate().

Iteration direction, passed to health_service_activities_iterate(). When iterating backwards (HealthIterationDirectionPast), activities that have a greater value for time_end come first. When iterating forward (HealthIterationDirectionFuture), activities that have a smaller value for time_start come first.

Iterate into the past.

Iterate into the future.

Iterates backwards or forward within a given time span to list all recorded activities. For example, this can be used to find the last recorded sleep phase or all deep sleep phases in a given time range. Any activity that overlaps with time_start and time_end will be included, even if the start time starts before time_start or end time ends after time_end.

Possible values returned by health_service_metric_accessible(). The values are used in combination as a bitmask. For example, to check if any data is available for a given request use: bool any_data_available = value & HealthServiceAccessibilityMaskAvailable;.

Return values are available and represent the collected health information.

The user hasn't granted permission.

The queried combination of time span and HealthMetric or HealthActivityMask is currently unsupported.

No samples were recorded for the given time span.

Check if a certain combination of metric and time span is accessible using health_service_sum by returning a value of HealthServiceAccessibilityMask. Developers should check if the return value is HealthServiceAccessibilityMaskAvailable before calling health_service_sum.

Check if a certain combination of metric, time span, and scope is accessible for calculating summed, averaged data by returning a value of HealthServiceAccessibilityMask. Developers should check if the return value is HealthServiceAccessibilityMaskAvailable before calling health_service_sum_averaged.

Check if a certain combination of metric, time span, aggregation operation, and scope is accessible for calculating aggregated, averaged data by returning a value of HealthServiceAccessibilityMask. Developers should check if the return value is HealthServiceAccessibilityMaskAvailable before calling health_service_aggregate_averaged.

Check if a certain combination of metric, HealthActivityMask and time span is accessible. Developers should check if the return value is HealthServiceAccessibilityMaskAvailable before calling any other HealthService APIs that involve the given activities.

Health event enum. Passed into the HealthEventHandler.

All data is considered as outdated and apps should re-read all health data. This happens after an app is subscribed via health_service_events_subscribe(), on a change of the day, or in other cases that significantly change the underlying data.

Recent values around HealthMetricStepCount, HealthMetricActiveSeconds, or HealthMetricWalkedDistanceMeters have changed.

Recent values around HealthMetricSleepSeconds, HealthMetricSleepRestfulSeconds, HealthActivitySleep, and HealthActivityRestfulSleep changed.

A metric has crossed the threshold set by health_service_register_metric_alert.

Value of HealthMetricHeartRateBPM or HealthMetricHeartRateRawBPM has changed.

Developer-supplied event handler, called when a health-related event occurs after subscribing via health_service_events_subscribe();.

Subscribe to HealthService events. This allocates a cache on the application's heap of up to 2048 bytes that will be de-allocated if you call health_service_events_unsubscribe(). If there's not enough heap available, this function will return false and will not subscribe to any events.

Unsubscribe from HealthService events.

Set the desired sampling period for heart rate readings. Normally, the system will sample the heart rate using a sampling period that is automatically chosen to provide useful information without undue battery drain (it automatically samples more often during periods of intense activity, and less often when the user is idle). If desired though, an application can request a specific sampling period using this call. The system will use this as a suggestion, but does not guarantee that the requested period will be used. The actual sampling period may be greater or less due to system needs or heart rate sensor reading quality issues.

Return how long a heart rate sample period request (sent via health_service_set_heart_rate_sample_period) will remain active after the app exits. If there is no current request by this app, this call will return 0.

Register for an alert when a metric crosses the given threshold. When the metric crosses this threshold (either goes above or below it), a HealthEventMetricAlert event will be generated. To cancel this registration, pass the returned HealthMetricAlert value to health_service_cancel_metric_alert. The only metric currently supported by this call is HealthMetricHeartRateBPM, but future versions may support additional metrics. To see if a specific metric is supported by this call, use:

Cancel an metric alert previously created with health_service_register_metric_alert.

Light level enum.

Return historical minute data records. This fills in the minute_data array parameter with minute by minute statistics of the user's steps, average watch orientation, etc. The data is returned in time order, with the oldest minute data returned at minute_data[0].

Convenience macro to switch between two expressions depending on health support. On platforms with health support the first expression will be chosen, the second otherwise.

Types of measurement system a HealthMetric may be measured in.

The measurement system is unknown, or does not apply to the chosen metric.

The metric measurement system.

The imperial measurement system.

Get the preferred measurement system for a given HealthMetric, if the user has chosen a preferred system and it is applicable to that metric.

Structure representing a single minute data record returned by health_service_get_minute_history(). The orientation field encodes the angle of the watch in the x-y plane (the "yaw") in the lower 4 bits (360 degrees linearly mapped to 1 of 16 different values) and the angle to the z axis (the "pitch") in the upper 4 bits. The vmc value is a measure of the total amount of movement seen by the watch. More vigorous movement yields higher VMC values.

Handling time components

Time unit flags that can be used to create a bitmask for use in tick_timer_service_subscribe(). This will also be passed to TickHandler.

Flag to represent the "seconds" time unit.

Flag to represent the "minutes" time unit.

Flag to represent the "hours" time unit.

Flag to represent the "days" time unit.

Flag to represent the "months" time unit.

Flag to represent the "years" time unit.

Callback type for tick timer events.

Subscribe to the tick timer event service. Once subscribed, the handler gets called on every requested unit change. Calling this function multiple times will override the units and handler (i.e., only  the last tick_units and handler passed will be used).

Unsubscribe from the tick timer event service. Once unsubscribed, the previously registered handler will no longer be called.

API for the application to notify the system of the reason it will exit.

AppExitReason is used to notify the system of the reason of an application exiting, which may affect the part of the system UI that is presented after the application terminates.

Exit reason not specified.

Application performed an action when it exited.

Number of AppExitReason options.

Set the app exit reason to a new reason.

Internationalization & Localization APIs

Get the ISO locale name for the language currently set on the watch.

API for checking what caused the application to launch.

AppLaunchReason is used to inform the application about how it was launched.

App launched by the system.

App launched by user selection in launcher menu.

App launched by mobile or companion app.

App launched by wakeup event.

App launched by worker calling worker_launch_app()

App launched by user using quick launch.

App launched by user opening it from a pin.

App launched by a smartstrap.

Provides the method used to launch the current application.

Get the argument passed to the app when it was launched.

Functions related to logging from apps.

A helper macro that simplifies the use of the app_log function.

Suggested log level values.

Error level log message.

Warning level log message.

Info level log message.

Debug level log message.

Verbose Debug level log message.

Math routines.

The largest value that can result from a call to sin_lookup or cos_lookup. For a code example, see the detailed description at the top of this chapter: Math.

Angle value that corresponds to 360 degrees or 2 PI radians.

Converts from a fixed point value representation to the equivalent value in degrees.

Converts from an angle in degrees to the equivalent fixed point value representation.

Look-up the sine of the given angle from a pre-computed table.

Look-up the cosine of the given angle from a pre-computed table. This is equivalent to calling sin_lookup(angle + TRIG_MAX_ANGLE / 4).

Look-up the arctangent of a given x, y pair The angle value is scaled linearly, such that a value of 0x10000 corresponds to 360 degrees or 2 PI radians.

Utility functions for managing an application's memory.

Calculates the number of bytes of heap memory not currently being used by the application.

Calculates the number of bytes of heap memory currently being used by the application.

Flushes the data cache and invalidates the instruction cache for the given region of memory, if necessary. This is only required when your app is loading or modifying code in memory and intends to execute it. On some platforms, code executed may be cached internally to improve performance. After writing to memory, but before executing, this function must be called in order to avoid undefined behavior. On platforms without caching, this performs no operation.

Managing application resources

Opaque reference to a resource.

Gets the resource handle for a file identifier.

Gets the size of the resource given a resource handle.

Copies the bytes for the resource with a given handle from flash storage into a given buffer.

Copies a range of bytes from a resource with a given handle into a given buffer.

A mechanism to store persistent application data and state

The maximum size of a persist value in bytes.

The maximum size of a persist string in bytes including the NULL terminator.

Status codes. See status_t.

Operation completed successfully.

An error occurred (no description).

No idea what went wrong.

There was a generic internal logic error.

The function was not called correctly.

Insufficient allocatable memory available.

Insufficient long-term storage available.

Insufficient resources available.

Argument out of range (may be dynamic).

Target of operation does not exist.

Operation not allowed (may depend on state).

Another operation prevented this one.

Operation not completed; try again.

Equivalent of boolean true.

Equivalent of boolean false.

For list-style requests. At end of list.

No action was taken as none was required.

Return value for system operations. See StatusCode for possible values.

Checks whether a value has been set for a given key in persistent storage.

Gets the size of a value for a given key in persistent storage.

Reads a bool value for a given key from persistent storage. If the value has not yet been set, this will return false.

Reads an int value for a given key from persistent storage.

Reads a blob of data for a given key from persistent storage into a given buffer. If the value has not yet been set, the given buffer is left unchanged.

Reads a string for a given key from persistent storage into a given buffer. The string will be null terminated. If the value has not yet been set, the given buffer is left unchanged.

Writes a bool value flag for a given key into persistent storage.

Writes an int value for a given key into persistent storage.

Writes a blob of data of a specified size in bytes for a given key into persistent storage. The maximum size is PERSIST_DATA_MAX_LENGTH.

Writes a string a given key into persistent storage. The maximum size is PERSIST_STRING_MAX_LENGTH including the null terminator.

Deletes the value of a key from persistent storage.

Can be used to execute some code at some point in the future.

Waits for a certain amount of milliseconds.

The type of function which can be called when a timer fires. The argument will be the callback_data passed to app_timer_register().

Registers a timer that ends up in callback being called some specified time in the future.

Reschedules an already running timer for some point in the future.

Cancels an already registered timer. Once cancelled the handle may no longer be used for any purpose.

Allows applications to schedule to be launched even if they are not running.

WakeupId is an identifier for a wakeup event.

The type of function which can be called when a wakeup event occurs.
The arguments will be the id of the wakeup event that occurred, as well as the scheduled cookie provided to wakeup_schedule.

Registers a WakeupHandler to be called when wakeup events occur.

Registers a wakeup event that triggers a callback at the specified time. Applications may only schedule up to 8 wakeup events. Wakeup events are given a 1 minute duration window, in that no application may schedule a wakeup event with 1 minute of a currently scheduled wakeup event.

Cancels a wakeup event.

Cancels all wakeup event for the app.

Retrieves the wakeup event info for an app that was launched by a wakeup_event (ie. launch_reason() === APP_LAUNCH_WAKEUP) so that an app may display information regarding the wakeup event.

Checks if the current WakeupId is still scheduled and therefore valid.

Functions, data structures and other things related to wall clock time.

Weekday values.

Today.

Sunday.

Monday.

Tuesday.

Wednesday.

Thursday.

Friday.

Saturday.

Copies a time string into the buffer, formatted according to the user's time display preferences (such as 12h/24h time). Example results: "7:30" or "15:00".

Gets the user's 12/24h clock style preference.

Converts a (day, hour, minute) specification to a UTC timestamp occurring in the future Always returns a timestamp for the next occurring instance, example: specifying TODAY@14:30 when it is 14:40 will return a timestamp for 7 days from now at 14:30.

Checks if timezone is currently set, otherwise gmtime == localtime.

The maximum length for a timezone full name (e.g. America/Chicago)

If timezone is set, copies the current timezone long name (e.g. America/Chicago) to user-provided buffer.

Provides information about the watch itself.

The different watch models.

Unknown model.

Original Pebble.

Pebble Steel.

Pebble Time.

Pebble Time Steel.

Pebble Time Round, 14mm lug size.

Pebble Time Round, 20mm lug size.

Pebble 2 HR.

Pebble 2 SE.

Pebble Time 2.

CoreDevices C2D (Core 2 Duo)

The different watch colors.

Unknown color.

Black.

White.

Red.

Orange.

Gray.

Stainless Steel.

Matte Black.

Blue.

Green.

Pink.

Time White.

Time Black.

Time Red.

Time Steel Silver.

Time Steel Black.

Time Steel Gold.

Time Round 14mm lug size, Silver.

Time Round 14mm lug size, Black.

Time Round 20mm lug size, Silver.

Time Round 20mm lug size, Black.

Time Round 14mm lug size, Rose Gold.

Pebble 2 HR, Black / Charcoal.

Pebble 2 HR, Charcoal / Sorbet Green.

Pebble 2 HR, Charcoal / Red.

Pebble 2 HR, White / Gray.

Pebble 2 HR, White / Turquoise.

Pebble 2 SE, Black / Charcoal.

Pebble 2 SE, White / Gray.

Pebble Time 2, Black.

Pebble Time 2, Silver.

Pebble Time 2, Gold.

CoreDevices C2D, Black.

CoreDevices C2D, White.

Provides the model of the watch.

Provides the version of the firmware running on the watch.

Data structure containing the version of the firmware running on the watch. The version of the firmware has the form X.[X.[X]]. If a version number is not present it will be 0. For example: the version numbers of 2.4.1 are 2, 4, and 1. The version numbers of 2.4 are 2, 4, and 0.

Low-level drawing routines.

Pebble Draw Commands are a way to encode arbitrary path draw and fill calls in binary format, so that vector-like graphics can be represented on the watch.

Draw commands are the basic building block of the draw command system, encoding the type of command to draw, the stroke width and color, fill color, and points that define the path (or center of a circle.

Draw command frames contain a list of commands to draw for that frame and a duration, indicating the length of time for which the frame should be drawn in an animation sequence. Frames form the building blocks of a GDrawCommandSequence, which consists of multiple frames.

Draw command images contain a list of commands that can be drawn. An image can be loaded from PDC file data.

Draw command lists contain a list of commands that can be iterated over and drawn all at once.

Callback for iterating over draw command list.

Draw command sequences allow the animation of frames over time. Each sequence has a list of frames that can be accessed by the elapsed duration of the animation (not maintained internally) or by index. Sequences can be loaded from PDC file data.

Invalid draw command type.

Arbitrary path draw command type.

Circle draw command type.

Arbitrary path drawn with sub-pixel precision (1/8th precision)

Draw a command.

Get the command type.

Set the fill color of a command.

Get the fill color of a command.

Set the stroke color of a command.

Get the stroke color of a command.

Set the stroke width of a command.

Get the stroke width of a command.

Get the number of points in a command.

Set the value of the point in a command at the specified index.

Get the value of a point in a command from the specified index.

Set the radius of a circle command.

Get the radius of a circle command.

Set the path of a stroke command to be open.

Return whether a stroke command path is open.

Set a command as hidden. This command will not be drawn when gdraw_command_draw is called with this command.

Return whether a command is hidden.

Draw a frame.

Set the duration of the frame.

Get the duration of the frame.

Creates a GDrawCommandImage from the specified resource (PDC file)

Creates a GDrawCommandImage as a copy from a given image.

Deletes the GDrawCommandImage structure and frees associated data.

Draw an image.

Get size of the bounding box surrounding all draw commands in the image. This bounding box can be used to set the graphics context or layer bounds when drawing the image.

Set size of the bounding box surrounding all draw commands in the image. This bounding box can be used to set the graphics context or layer bounds when drawing the image.

Get the command list of the image.

Iterate over all commands in a command list.

Draw all commands in a command list.

Get the command at the specified index.

Get the number of commands in the list.

Creates a GDrawCommandSequence from the specified resource (PDC file)

Creates a GDrawCommandSequence as a copy from a given sequence.

Deletes the GDrawCommandSequence structure and frees associated data.

Get the frame that should be shown after the specified amount of elapsed time The last frame will be returned if the elapsed time exceeds the total time.

Get the frame at the specified index.

Get the size of the bounding box surrounding all draw commands in the sequence. This bounding box can be used to set the graphics context or layer bounds when drawing the frames in the sequence.

Set size of the bounding box surrounding all draw commands in the sequence. This bounding box can be used to set the graphics context or layer bounds when drawing the frames in the sequence.

Get the play count of the sequence.

Set the play count of the sequence.

Get the total duration of the sequence.

Get the number of frames in the sequence.

Get the command list of the frame.

Functions to draw polygons into a graphics context

Creates a new GPath on the heap based on a series of points described by a GPathInfo.

Free a dynamically allocated gpath created with gpath_create()

Draws the fill of a path into a graphics context, using the current fill color, relative to the drawing area as set up by the layering system.

Draws the outline of a path into a graphics context, using the current stroke color and width, relative to the drawing area as set up by the layering system. The first and last points in the path do have a line between them.

Sets the absolute rotation of the path. The current rotation will be replaced by the specified angle.

Sets the absolute offset of the path. The current translation will be replaced by the specified offset.

Draws an open outline of a path into a graphics context, using the current stroke color and width, relative to the drawing area as set up by the layering system. The first and last points in the path do not have a line between them.

Data structure describing a path, plus its rotation and translation.

Data structure describing a naked path.

Functions to draw into a graphics context

Bit mask values to specify the corners of a rectangle. The values can be combines using binary OR (|), For example: the mask to indicate top left and bottom right corners can: be created as follows: (GCornerTopLeft | GCornerBottomRight)

No corners.

Top-Left corner.

Top-Right corner.

Bottom-Left corner.

Bottom-Right corner.

All corners.

Top corners.

Bottom corners.

Left corners.

Right corners.

Draws a pixel at given point in the current stroke color.

Draws line in the current stroke color, current stroke width and AA flag.

Draws a 1-pixel wide rectangle outline in the current stroke color.

Fills a rectangle with the current fill color, optionally rounding all or a selection of its corners.

Draws the outline of a circle in the current stroke color.

Fills a circle in the current fill color.

Draws the outline of a rounded rectangle in the current stroke color.

Draws a bitmap into the graphics context, inside the specified rectangle.

A shortcut to capture the framebuffer in the native format of the watch.

Captures the frame buffer for direct access, using the given format. Graphics functions will not affect the frame buffer while it is captured. The frame buffer is released when graphics_release_frame_buffer is called. The frame buffer must be released before the end of a layer's .update_proc for the layer to be drawn properly.

Releases the frame buffer. Must be called before the end of a layer's .update_proc for the layer to be drawn properly.

Whether or not the frame buffer has been captured by graphics_capture_frame_buffer. Graphics functions will not affect the frame buffer until it has been released by graphics_release_frame_buffer.

Draws a rotated bitmap with a memory-sensitive 2x anti-aliasing technique (using ray-finding instead of super-sampling), which is thresholded into a b/w bitmap for 1-bit and color blended for 8-bit.

Values to specify how a given rectangle should be used to derive an oval shape.

Places a circle at the center of the rectangle, with a diameter that matches the rectangle's shortest side.

Places a circle at the center of the rectangle, with a diameter that matches the rectangle's longest side. The circle may overflow the bounds of the rectangle.

Draws a line arc clockwise between angle_start and angle_end, where 0° is the top of the circle. If the difference between angle_start and angle_end is greater than 360°, a full circle will be drawn.

Fills a circle clockwise between angle_start and angle_end, where 0° is the top of the circle. If the difference between angle_start and angle_end is greater than 360°, a full circle will be drawn and filled. If angle_start is greater than angle_end nothing will be drawn.

Calculates a GPoint located at the angle provided on the perimeter of a circle defined by the provided GRect.

Calculates a rectangle centered on the perimeter of a circle at a given angle. Use this to construct rectangles that follow the perimeter of a circle as an input for graphics_fill_radial_internal or graphics_draw_arc_internal, e.g. to draw circles every 30 degrees on a watchface.

Functions to draw text into a graphics context

Text overflow mode controls the way text overflows when the string that is drawn does not fit inside the area constraint.

On overflow, wrap words to a new line below the current one. Once vertical space is consumed, the last line may be clipped.

On overflow, wrap words to a new line below the current one. Once vertical space is consumed, truncate as needed to fit a trailing ellipsis (...). Clipping may occur if the vertical space cannot accomodate the first line of text.

Acts like GTextOverflowModeTrailingEllipsis, plus trims leading and trailing newlines, while treating all other newlines as spaces.

Text aligment controls the way the text is aligned inside the box the text is drawn into.

Aligns the text to the left of the drawing box.

Aligns the text centered inside the drawing box.

Aligns the text to the right of the drawing box.

Creates an instance of GTextAttributes for advanced control when rendering text.

Destroys a previously created instance of GTextAttributes.

Restores text flow to the rectangular default.

Enables text flow that follows the boundaries of the screen.

Restores paging and locked content origin to the defaults.

Enables paging and locks the text flow calculation to a fixed point on the screen.

Draw text into the current graphics context, using the context's current text color. The text will be drawn inside a box with the specified dimensions and configuration, with clipping occuring automatically.

Obtain the maximum size that a text with given font, overflow mode and alignment occupies within a given rectangular constraint.

Obtain the maximum size that a text with given font, overflow mode and alignment occupies within a given rectangular constraint.

Custom and system fonts.

Pointer to opaque font data structure.

Loads a system font corresponding to the specified font key.

Loads a custom font.

Unloads the specified custom font and frees the memory that is occupied by it.

The "canvas" into which an application draws

Sets the current stroke color of the graphics context.

Sets the current fill color of the graphics context.

Sets the current text color of the graphics context.

Sets the current bitmap compositing mode of the graphics context.

Sets whether antialiasing is applied to stroke drawing.

Sets the width of the stroke for drawing routines.

Basic graphics types (point, rect, size, color, bitmaps, etc.) and utility functions.

Convert RGBA to GColor.

Convert RGB to GColor.

Convert hex integer to GColor.

True if both colors are identical or both are invisible (i.e. both have alpha values of .a=0).

This method assists in improving the legibility of text on various background colors. It takes the background color for the region in question and computes a color for maximum legibility.

Convenience macro allowing use of a fallback color for black and white platforms. On color platforms, the first expression will be chosen, the second otherwise.

Convenience macro to switch between two expression depending on the screen of the platform. On platforms with rectangular screen, the first expression will be chosen, the second otherwise.

Convenience macro to switch between two expression depending on the screen of the platform. On platforms with round screen, the first expression will be chosen, the second otherwise.

Convenience macro to switch between two expression depending on the screen of the platform. On black& white platforms, the first expression will be chosen, the second otherwise.

Convenience macro to switch between two expression depending on the screen of the platform. On color platforms, the first expression will be chosen, the second otherwise.

Convenience macro to make a GPoint.

Convenience macro to make a GPoint at (0, 0).

Tests whether 2 points are equal.

Convenience macro to make a GSize.

Convenience macro to make a GSize of (0, 0).

Tests whether 2 sizes are equal.

Convenience macro to make a GRect.

Convenience macro to make a GRect of ((0, 0), (0, 0)).

Tests whether 2 rectangles are equal.

Tests whether the size of the rectangle is (0, 0).

Converts a rectangle's values so that the components of its size (width and/or height) are both positive. In the width and/or height are negative, the origin will offset, so that the final rectangle overlaps with the original. For example, a GRect with size (-10, -5) and origin (20, 20), will be standardized to size (10, 5) and origin (10, 15).

Trim one rectangle using the edges of a second rectangle.

Tests whether a rectangle contains a point.

Convenience function to compute the center-point of a given rectangle. This is equal to (rect->x + rect->width / 2, rect->y + rect->height / 2).

Reduce the width and height of a rectangle by insetting each of the edges with a fixed inset. The returned rectangle will be centered relative to the input rectangle.

Repeat Sequence or animation indefinitely.

Duration of Sequence or animation is infinite.

The format of a GBitmap can either be 1-bit or 8-bit.

Get the number of bytes per row in the bitmap data for the given GBitmap. On rectangular displays, this can be used as a safe way of iterating over the rows in the bitmap, since bytes per row should be set according to format. On circular displays with pixel format of GBitmapFormat8BitCircular this will return 0, and should not be used for iteration over frame buffer pixels. Instead, use GBitmapDataRowInfo, which provides safe minimum and maximum x values for a given row's y value.

Get the GBitmapFormat for the GBitmap.

Get a pointer to the raw image data section of the given GBitmap as specified by the format of the bitmap.

Set the bitmap data for the given GBitmap.

Gets the bounds of the content for the GBitmap. This is set when loading the image or if changed by gbitmap_set_bounds.

Set the bounds of the given GBitmap.

Get the palette for the given GBitmap.

Set the palette for the given GBitmap.

Creates a new GBitmap on the heap using a Pebble image file stored as a resource. The resulting GBitmap must be destroyed using gbitmap_destroy().

Creates a new GBitmap on the heap initialized with the provided Pebble image data.

Create a new GBitmap on the heap as a sub-bitmap of a 'base' GBitmap, using a GRect to indicate what portion of the base to use. The sub-bitmap will just reference the image data and palette of the base bitmap. No deep-copying occurs as a result of calling this function, thus the caller is responsible for making sure the base bitmap and palette will remain available when using the sub-bitmap. Note that you should not destroy the parent bitmap until the sub_bitmap has been destroyed. The resulting GBitmap must be destroyed using gbitmap_destroy().

Create a GBitmap based on raw PNG data. The resulting GBitmap must be destroyed using gbitmap_destroy(). The developer is responsible for freeing png_data following this call.

Creates a new blank GBitmap on the heap initialized to zeroes. In the case that the format indicates a palettized bitmap, a palette of appropriate size will also be allocated on the heap. The resulting GBitmap must be destroyed using gbitmap_destroy().

Creates a new blank GBitmap on the heap, initialized to zeroes, and assigns it the given palette. No deep-copying of the palette occurs, so the caller is responsible for making sure the palette remains available when using the resulting bitmap. Management of that memory can be handed off to the system with the free_on_destroy argument.

Given a 1-bit GBitmap, create a new bitmap of format GBitmapFormat1BitPalette. The new data buffer is allocated on the heap, and a 2-color palette is allocated as well.

Destroy a GBitmap. This must be called for every bitmap that's been created with gbitmap_create_*.

Creates a GBitmapSequence from the specified resource (APNG/PNG files)

Updates the contents of the bitmap sequence to the next frame and optionally returns the delay in milliseconds until the next frame.

Updates the contents of the bitmap sequence to the frame at elapsed in the sequence. For looping animations this accounts for the loop, for example an animation of 1 second that is configured to loop 2 times updated to 1500 ms elapsed time will display the sequence frame at 500 ms. Elapsed time is the time from the start of the animation, and will be ignored if it is for a time earlier than the last rendered frame.

Deletes the GBitmapSequence structure and frees any allocated memory/decoder_data.

Restarts the GBitmapSequence to the first frame gbitmap_sequence_update_bitmap_next_frame.

This function gets the current frame number for the bitmap sequence.

This function sets the total number of frames for the bitmap sequence.

This function gets the play count (number of times to repeat) the bitmap sequence.

This function sets the play count (number of times to repeat) the bitmap sequence.

This function gets the minimum required size (dimensions) necessary to render the bitmap sequence to a GBitmap using the /ref gbitmap_sequence_update_bitmap_next_frame.

Provides information about a pixel data row.

Values to specify how two things should be aligned relative to each other.

Align by centering.

Align by making the top edges overlap and left edges overlap.

Align by making the top edges overlap and left edges overlap.

Align by making the top edges overlap and centered horizontally.

Align by making the left edges overlap and centered vertically.

Align by making the bottom edges overlap and centered horizontally.

Align by making the right edges overlap and centered vertically.

Align by making the bottom edges overlap and right edges overlap.

Align by making the bottom edges overlap and left edges overlap.

Aligns one rectangle within another rectangle, using an alignment parameter. The relative coordinate systems of both rectangles are assumed to be the same. When clip is true, rect is also clipped by the constraint.

Values to specify how the source image should be composited onto the destination image.

Assign the pixel values of the source image to the destination pixels, effectively replacing the previous values for those pixels. For color displays, when drawing a palettized or 8-bit GBitmap image, the opacity value is ignored.

Assign the inverted pixel values of the source image to the destination pixels, effectively replacing the previous values for those pixels.

Use the boolean operator OR to composite the source and destination pixels. The visual result of this compositing mode is the source's white pixels are painted onto the destination and the source's black pixels are treated as clear.

Use the boolean operator AND to composite the source and destination pixels. The visual result of this compositing mode is the source's black pixels are painted onto the destination and the source's white pixels are treated as clear.

Clears the bits in the destination image, using the source image as mask. The visual result of this compositing mode is that for the parts where the source image is white, the destination image will be painted black. Other parts will be left untouched.

Sets the bits in the destination image, using the source image as mask. This mode is required to apply any transparency of your bitmap.

helper for GEdgeInsets macro

helper for GEdgeInsets macro

helper for GEdgeInsets macro

helper for GEdgeInsets macro

helper for GEdgeInsets macro

Convenience macro to make a GEdgeInsets This macro follows the CSS shorthand notation where you can call it with.

Returns a rectangle that is shrinked or expanded by the given edge insets.

Description of a single data row in the pixel data of a bitmap.

Represents insets for four sides. Negative values mean a side extends.

Represents a point in a 2-dimensional coordinate system.

Represents a rectangle and defining it using the origin of the upper-lefthand corner and its size.

Represents a 2-dimensional size.

A list of all of the named colors available with links to the color map on the Pebble Developer website.

GColorBlack

GColorOxfordBlue

GColorDukeBlue

GColorBlue

GColorDarkGreen

GColorMidnightGreen

GColorCobaltBlue

GColorBlueMoon

GColorIslamicGreen

GColorJaegerGreen

GColorTiffanyBlue

GColorVividCerulean

GColorGreen

GColorMalachite

GColorMediumSpringGreen

GColorCyan

GColorBulgarianRose

GColorImperialPurple

GColorIndigo

GColorElectricUltramarine

GColorArmyGreen

GColorDarkGray

GColorLiberty

GColorVeryLightBlue

GColorKellyGreen

GColorMayGreen

GColorCadetBlue

GColorPictonBlue

GColorBrightGreen

GColorScreaminGreen

GColorMediumAquamarine

GColorElectricBlue

GColorDarkCandyAppleRed

GColorJazzberryJam

GColorPurple

GColorVividViolet

GColorWindsorTan

GColorRoseVale

GColorPurpureus

GColorLavenderIndigo

GColorLimerick

GColorBrass

GColorLightGray

GColorBabyBlueEyes

GColorSpringBud

GColorInchworm

GColorMintGreen

GColorCeleste

GColorRed

GColorFolly

GColorFashionMagenta

GColorMagenta

GColorOrange

GColorSunsetOrange

GColorBrilliantRose

GColorShockingPink

GColorChromeYellow

GColorRajah

GColorMelon

GColorRichBrilliantLavender

GColorYellow

GColorIcterine

GColorPastelYellow

GColorWhite

Everything related to user interface.

Abstract framework to create arbitrary animations

The type used to represent how far an animation has progressed. This is passed to the animation's update handler.

Values that are used to indicate the different animation curves, which determine the speed at which the animated value(s) change(s).

Linear curve: the velocity is constant.

Bicubic ease-in: accelerate from zero velocity.

Bicubic ease-in: decelerate to zero velocity.

Bicubic ease-in-out: accelerate from zero velocity, decelerate to zero velocity.

Custom (user-provided) animation curve.

User-provided interpolation function.

Creates a new Animation on the heap and initalizes it with the default values.

Destroys an Animation previously created by animation_create.

Constant to indicate "infinite" duration. This can be used with animation_set_duration() to indicate that the animation should run indefinitely. This is useful when implementing for example a frame-by-frame simulation that does not have a clear ending (e.g. a game).

Constant to indicate infinite play count. Can be passed to animation_set_play_count() to repeat indefinitely.

The normalized distance at the start of the animation.

The normalized distance at the end of the animation.

Create a new sequence animation from a list of 2 or more other animations. The returned animation owns the animations that were provided as arguments and no further write operations on those handles are allowed. The variable length argument list must be terminated with a NULL ptr.

An alternate form of animation_sequence_create() that accepts an array of other animations.

Create a new spawn animation from a list of 2 or more other animations. The returned animation owns the animations that were provided as arguments and no further write operations on those handles are allowed. The variable length argument list must be terminated with a NULL ptr.

An alternate form of animation_spawn_create() that accepts an array of other animations.

Seek to a specific location in the animation. Only forward seeking is allowed. Returns true if successful, false if the passed in seek location is invalid.

Get the current location in the animation.

Set an animation to run in reverse (or forward)

Get the reverse setting of an animation.

Set an animation to play N times. The default is 1.

Get the play count of an animation.

Sets the time in milliseconds that an animation takes from start to finish.

Get the static duration of an animation from start to end (ignoring how much has already played, if any).

Sets an optional delay for the animation.

Get the delay of an animation in milliseconds.

Sets the animation curve for the animation.

Gets the animation curve for the animation.

The function pointer type of a custom animation curve.

Sets a custom animation curve function.

Gets the custom animation curve function for the animation.

The function pointer type of the handler that will be called when an animation is started, just before updating the first frame of the animation.

The function pointer type of the handler that will be called when the animation is stopped.

Sets the callbacks for the animation. Often an application needs to run code at the start or at the end of an animation. Using this function is possible to register callback functions with an animation, that will get called at the start and end of the animation.

Gets the application-specific callback context of the animation. This void pointer is passed as an argument when the animation system calls AnimationHandlers callbacks. The context pointer can be set to point to any application specific data using animation_set_handlers().

Schedules the animation. Call this once after configuring an animation to get it to start running.

Unschedules the animation, which in effect stops the animation.

Unschedules all animations of the application.

Pointer to function that (optionally) prepares the animation for running. This callback is called when the animation is added to the scheduler.

Pointer to function that updates the animation according to the given normalized progress. This callback will be called repeatedly by the animation scheduler whenever the animation needs to be updated.

Pointer to function that (optionally) cleans up the animation. This callback is called when the animation is removed from the scheduler. In case the .setup implementation allocated any memory, this is a good place to release that memory again.

Sets the implementation of the custom animation. When implementing custom animations, use this function to specify what functions need to be called to for the setup, frame update and teardown of the animation.

Gets the implementation of the custom animation.

The handlers that will get called when an animation starts and stops. See documentation with the function pointer types for more information.

The 3 callbacks that implement a custom animation. Only the .update callback is mandatory, .setup and .teardown are optional. See the documentation with the function pointer typedefs for more information.

A ProperyAnimation animates the value of a "property" of a "subject" over time.

Convenience function to create and initialize a property animation that animates the frame of a Layer. It sets up the PropertyAnimation to use layer_set_frame() and layer_get_frame() as accessors and uses the layer parameter as the subject for the animation. The same defaults are used as with animation_create().

Convenience function to create and initialize a property animation that animates the bound's origin of a Layer. It sets up the PropertyAnimation to use layer_set_bounds() and layer_get_bounds() as accessors and uses the layer parameter as the subject for the animation. The same defaults are used as with animation_create().

Creates a new PropertyAnimation on the heap and and initializes it with the specified values. The same defaults are used as with animation_create(). If the from_value or the to_value is NULL, the getter accessor will be called to get the current value of the property and be used instead.

Destroy a property animation allocated by property_animation_create() or relatives.

Default update callback for a property animations to update a property of type int16_t. Assign this function to the .base.update callback field of your PropertyAnimationImplementation, in combination with a .getter and .setter accessors of types Int16Getter and Int16Setter. The implementation of this function will calculate the next value of the animation and call the setter to set the new value upon the subject.

Default update callback for a property animations to update a property of type uint32_t. Assign this function to the .base.update callback field of your PropertyAnimationImplementation, in combination with a .getter and .setter accessors of types UInt32Getter and UInt32Setter. The implementation of this function will calculate the next value of the animation and call the setter to set the new value upon the subject.

Default update callback for a property animations to update a property of type GPoint. Assign this function to the .base.update callback field of your PropertyAnimationImplementation, in combination with a .getter and .setter accessors of types GPointGetter and GPointSetter. The implementation of this function will calculate the next point of the animation and call the setter to set the new point upon the subject.

Default update callback for a property animations to update a property of type GRect. Assign this function to the .base.update callback field of your PropertyAnimationImplementation, in combination with a .getter and .setter accessors of types GRectGetter and GRectSetter. The implementation of this function will calculate the next rectangle of the animation and call the setter to set the new rectangle upon the subject.

Default update callback for a property animations to update a property of type GColor8. Assign this function to the .base.update callback field of your PropertyAnimationImplementation, in combination with a .getter and .setter accessors of types GColor8Getter and GColor8Setter. The implementation of this function will calculate the next rectangle of the animation and call the setter to set the new value upon the subject.

Work-around for function pointer return type GPoint to avoid tripping the pre-processor to use the equally named GPoint define.

Work-around for function pointer return type GRect to avoid tripping the pre-processor to use the equally named GRect define.

Function signature of a setter function to set a property of type int16_t onto the subject.

Function signature of a getter function to get the current property of type int16_t of the subject.

Function signature of a setter function to set a property of type uint32_t onto the subject.

Function signature of a getter function to get the current property of type uint32_t of the subject.

Function signature of a setter function to set a property of type GPoint onto the subject.

Function signature of a getter function to get the current property of type GPoint of the subject.

Function signature of a setter function to set a property of type GRect onto the subject.

Function signature of a getter function to get the current property of type GRect of the subject.

Function signature of a setter function to set a property of type GColor8 onto the subject.

Function signature of a getter function to get the current property of type GColor8 of the subject.

Convenience function to retrieve an animation instance from a property animation instance.

Convenience function to clone a property animation instance.

Convenience function to retrieve the 'from' GRect value from property animation handle.

Convenience function to set the 'from' GRect value of property animation handle.

Convenience function to retrieve the 'from' GPoint value from property animation handle.

Convenience function to set the 'from' GPoint value of property animation handle.

Convenience function to retrieve the 'from' int16_t value from property animation handle.

Convenience function to set the 'from' int16_t value of property animation handle.

Convenience function to retrieve the 'to' GRect value from property animation handle.

Convenience function to set the 'to' GRect value of property animation handle.

Convenience function to retrieve the 'to' GPoint value from property animation handle.

Convenience function to set the 'to' GPoint value of property animation handle.

Convenience function to retrieve the 'to' int16_t value from property animation handle.

Convenience function to set the 'to' int16_t value of property animation handle.

Retrieve the subject of a property animation.

Set the subject of a property animation.

Helper function used by the property_animation_get|set_subject macros.

Helper function used by the property_animation_get|set_from_.* macros.

Helper function used by the property_animation_get|set_to_.* macros.

Data structure containing the setter and getter function pointers that the property animation should use. The specified setter function will be used by the animation's update callback.
Based on the type of the property (int16_t, GPoint or GRect), the accompanying update callback should be used, see property_animation_update_int16(), property_animation_update_gpoint() and property_animation_update_grect().
The getter function is used when the animation is initialized, to assign the current value of the subject's property as "from" or "to" value, see property_animation_create().

Data structure containing a collection of function pointers that form the implementation of the property animation. See the code example at the top (PropertyAnimation).

Handling button click interactions

Button ID values.

Back button.

Up button.

Select (middle) button.

Down button.

Total number of buttons.

Reference to opaque click recognizer When a ClickHandler callback is called, the recognizer that fired the handler is passed in.

Function signature of the callback that handles a recognized click pattern.

This callback is called every time the window becomes visible (and when you call window_set_click_config_provider() if the window is already visible).

Gets the click count. You can use this inside a click handler implementation to get the click count for multi_click and (repeated) click events.

Gets the button identifier. You can use this inside a click handler implementation to get the button id for the click event.

Is this a repeating click. You can use this inside a click handler implementation to find out whether this is a repeating click or not.

User interface layers for displaying graphic components

Function signature for a Layer's render callback (the name of the type is derived from the words 'update procedure'). The system will call the .update_proc callback whenever the Layer needs to be rendered.

Creates a layer on the heap and sets its frame and bounds. Default values:

Creates a layer on the heap with extra space for callback data, and set its frame andbounds. Default values:

Destroys a layer previously created by layer_create.

Marks the complete layer as "dirty", awaiting to be asked by the system to redraw itself. Typically, this function is called whenever state has changed that affects what the layer is displaying.

Sets the layer's render function. The system will call the update_proc automatically when the layer needs to redraw itself, see also layer_mark_dirty().

Sets the frame of the layer, which is it's bounding box relative to the coordinate system of its parent layer. The size of the layer's bounds will be extended automatically, so that the bounds cover the new frame.

Gets the frame of the layer, which is it's bounding box relative to the coordinate system of its parent layer. If the frame has changed, layer_mark_dirty() will be called automatically.

Sets the bounds of the layer, which is it's bounding box relative to its frame. If the bounds has changed, layer_mark_dirty() will be called automatically.

Gets the bounds of the layer.

Get the largest unobstructed bounds rectangle of a layer.

Converts a point from the layer's local coordinate system to screen coordinates.

Converts a rectangle from the layer's local coordinate system to screen coordinates.

Gets the window that the layer is currently attached to.

Removes the layer from its current parent layer If removed successfully, the child's parent layer will be marked dirty automatically.

Removes child layers from given layer If removed successfully, the child's parent layer will be marked dirty automatically.

Adds the child layer to a given parent layer, making it appear in front of its parent and in front of any existing child layers of the parent. If the child layer was already part of a layer hierarchy, it will be removed from its old parent first. If added successfully, the parent (and children) will be marked dirty automatically.

Inserts the layer as a sibling behind another layer. If the layer to insert was already part of a layer hierarchy, it will be removed from its old parent first. The below_layer has to be a child of a parent layer, otherwise this function will be a noop. If inserted successfully, the parent (and children) will be marked dirty automatically.

Inserts the layer as a sibling in front of another layer. The above_layer has to be a child of a parent layer, otherwise this function will be a noop. If inserted successfully, the parent (and children) will be marked dirty automatically.

Sets the visibility of the layer. If the visibility has changed, layer_mark_dirty() will be called automatically on the parent layer.

Gets the visibility of the layer.

Sets whether clipping is enabled for the layer. If enabled, whatever the layer and its children will draw using their .update_proc callbacks, will be clipped by the this layer's frame. If the clipping has changed, layer_mark_dirty() will be called automatically.

Gets whether clipping is enabled for the layer. If enabled, whatever the layer and its children will draw using their .update_proc callbacks, will be clipped by the this layer's frame.

Gets the data from a layer that has been created with an extra data region.

Vertical, bar-shaped control widget on the right edge of the window

The width of the action bar in pixels.

The width of the action bar in pixels, for all platforms.

The maximum number of action bar items.

Creates a new ActionBarLayer on the heap and initalizes it with the default values.

Destroys a ActionBarLayer previously created by action_bar_layer_create.

Gets the "root" Layer of the action bar layer, which is the parent for the sub- layers used for its implementation.

Sets the context parameter, which will be passed in to ClickHandler callbacks and the ClickConfigProvider callback of the action bar.

Sets the click configuration provider callback of the action bar. In this callback your application can associate handlers to the different types of click events for each of the buttons, see Clicks.

Sets an action bar icon onto one of the 3 slots as identified by button_id. Only BUTTON_ID_UP, BUTTON_ID_SELECT and BUTTON_ID_DOWN can be used. The transition will not be animated. Whenever an icon is set, the click configuration provider will be called, to give the application the opportunity to reconfigure the button interaction.

Convenience function to clear out an existing icon. All it does is call action_bar_layer_set_icon(action_bar, button_id, NULL)

Adds the action bar's layer on top of the window's root layer. It also adjusts the layout of the action bar to match the geometry of the window it gets added to. Lastly, it calls window_set_click_config_provider_with_context() on the window to set it up to work with the internal callback and raw click handlers of the action bar, to enable the highlighting of the section of the action bar when the user presses a button.

Removes the action bar from the window and unconfigures the window's click configuration provider. NULL is set as the window's new click config provider and also as its callback context. If it has not been added to a window before, this function is a no-op.

Sets the background color of the action bar. Defaults to GColorBlack. The action bar's layer is automatically marked dirty.

Sets an action bar icon onto one of the 3 slots as identified by button_id. Only BUTTON_ID_UP, BUTTON_ID_SELECT and BUTTON_ID_DOWN can be used. Optionally, if animated is true, the transition will be animated. Whenever an icon is set, the click configuration provider will be called, to give the application the opportunity to reconfigure the button interaction.

Sets the animation to use while a button is pressed on an ActionBarLayer. By default we use ActionBarLayerIconPressAnimationMoveLeft.

Layer that displays a bitmap image.

Creates a new bitmap layer on the heap and initalizes it the default values.

Destroys a window previously created by bitmap_layer_create.

Gets the "root" Layer of the bitmap layer, which is the parent for the sub- layers used for its implementation.

Gets the pointer to the bitmap image that the BitmapLayer is using.

Sets the bitmap onto the BitmapLayer. The bitmap is set by reference (no deep copy), thus the caller of this function has to make sure the bitmap is kept in memory.

Sets the alignment of the image to draw with in frame of the BitmapLayer. The aligment parameter specifies which edges of the bitmap should overlap with the frame of the BitmapLayer. If the bitmap is smaller than the frame of the BitmapLayer, the background is filled with the background color.

Sets the background color of bounding box that will be drawn behind the image of the BitmapLayer.

Sets the compositing mode of how the bitmap image is composited onto the BitmapLayer's background plane, or how it is composited onto what has been drawn beneath the BitmapLayer.

Layer that displays a standard list menu. Data is provided using callbacks.

Section drawing function to draw a basic section cell with the title, subtitle, and icon of the section. Call this function inside the .draw_row callback implementation, see MenuLayerCallbacks. Note that if the size of cell_layer is too small to fit all of the cell items specified, not all of them may be drawn.

Cell drawing function to draw a basic menu cell layout with title, subtitle Cell drawing function to draw a menu cell layout with only one big title. Call this function inside the .draw_row callback implementation, see MenuLayerCallbacks.

Section header drawing function to draw a basic section header cell layout with the title of the section. Call this function inside the .draw_header callback implementation, see MenuLayerCallbacks.

Default section header height in pixels.

Macro to create a MenuIndex.

Comparator function to determine the order of two MenuIndex values.

Function signature for the callback to get the number of sections in a menu.

Function signature for the callback to get the number of rows in a given section in a menu.

Function signature for the callback to get the height of the menu cell at a given index.

Function signature for the callback to get the height of the section header at a given section index.

Function signature for the callback to get the height of the separator at a given index.

Function signature for the callback to render the menu cell at a given MenuIndex.

Function signature for the callback to render the section header at a given section index.

Function signature for the callback to render the separator at a given MenuIndex.

Function signature for the callback to handle the event that a user hits the SELECT button.

Function signature for the callback to handle a change in the current selected item in the menu.

Function signature for the callback which allows or changes selection behavior of the menu. In order to change the cell that should be selected, modify the passed in new_index. Preventing the selection from changing, new_index can be assigned the value of old_index.

Function signature for the callback which draws the menu's background. The background is underneath the cells of the menu, and is visible in the padding below the bottom cell, or if a cell's background color is set to GColorClear.

Creates a new MenuLayer on the heap and initalizes it with the default values.

Destroys a MenuLayer previously created by menu_layer_create.

Gets the "root" Layer of the MenuLayer, which is the parent for the sub- layers used for its implementation.

Gets the ScrollLayer of the MenuLayer, which is the layer responsible for the scrolling of the MenuLayer.

Sets the callbacks for the MenuLayer.

Convenience function to set the ClickConfigProvider callback on the given window to the MenuLayer internal click config provider. This internal click configuration provider, will set up the default UP & DOWN scrolling / menu item selection behavior. This function calls scroll_layer_set_click_config_onto_window to accomplish this.

Values to specify how a (selected) row should be aligned relative to the visible area of the MenuLayer.

Don't align or update the scroll offset of the MenuLayer.

Scroll the contents of the MenuLayer in such way that the selected row is centered relative to the visible area.

Scroll the contents of the MenuLayer in such way that the selected row is at the top of the visible area.

Scroll the contents of the MenuLayer in such way that the selected row is at the bottom of the visible area.

Selects the next or previous item, relative to the current selection.

Selects the item with given MenuIndex.

Gets the MenuIndex of the currently selected menu item.

Reloads the data of the menu. This causes the menu to re-request the menu item data, by calling the relevant callbacks. The current selection and scroll position will not be changed. See the note with menu_layer_set_selected_index() for the behavior if the old selection is no longer valid.

Returns whether or not the given cell layer is highlighted. Using this for determining highlight behaviour is preferable to using menu_layer_get_selected_index. Row drawing callbacks may be invoked multiple times with a different highlight status on the same cell in order to handle partially highlighted cells during animation.

Set the default colors to be used for cells when it is in a normal state (not highlighted). The GContext's text and fill colors will be set appropriately prior to calling the .draw_row callback. If this function is not explicitly called on a MenuLayer, it will default to white background with black foreground.

Set the default colors to be used for cells when it is in a highlighted state. The GContext's text and fill colors will be set appropriately prior to calling the .draw_row callback. If this function is not explicitly called on a MenuLayer, it will default to black background with white foreground.

This enables or disables padding at the bottom of the MenuLayer. Padding at the bottom of the layer keeps the bottom item from being at the very bottom of the screen. Padding is turned on by default for all MenuLayers. The color of the padded area will be the background color set using menu_layer_set_normal_colors(). To color the padding a different color, use MenuLayerDrawBackgroundCallback.

True, if the MenuLayer generally scrolls such that the selected row is in the center.

Controls if the MenuLayer generally scrolls such that the selected row is in the center. For platforms with a round display (PBL_ROUND) the default is true, otherwise false is the default.

Returns whether or not the specified cell index is currently selected.

Constant value representing MenuLayer short cell height when this item is the selected item on a round display.

Constant value representing MenuLayer short cell height when this item is not the selected item on a round display.

Constant value representing MenuLayer tall cell height when this item is the selected item on a round display.

Constant value representing MenuLayer tall cell height when this item is not the selected item on a round display.

Data structure to represent an menu item's position in a menu, by specifying the section index and the row index within that section.

Data structure containing all the callbacks of a MenuLayer.

Layer that displays a rotated bitmap image.

Creates a new RotBitmapLayer on the heap and initializes it with the default values:

Destroys a RotBitmapLayer and frees all associated memory.

Defines what color to use in areas that are not covered by the source bitmap. By default this is GColorClear.

Sets the rotation angle of this RotBitmapLayer.

Change the rotation angle of this RotBitmapLayer.

Defines the only point that will not be affected by the rotation in the source bitmap.

Sets the compositing mode of how the bitmap image is composited onto what has been drawn beneath the RotBitmapLayer. By default this is GCompOpAssign. The RotBitmapLayer is automatically marked dirty after this operation.