Making Pebble.js a Pebble Package means Pebble.js projects can be converted to standard Pebble C projects. This gives benefits like the ability to easily utilize other Pebble Packages, such as Clay for Pebble, or easily importing and exporting the project with CloudPebble.

The Pebble.js package is using the develop branch from the Pebble.js repository on Github, and can be updated independently from CloudPebble deployments.

It also supports the Diorite platform!.

Creating a New Project

The initial steps vary if you're using CloudPebble or the Local SDK. Follow the appropriate steps below to create a new project.

CloudPebble

If you're using CloudPebble, follow these initial steps:

1. Create a new project:

   • Project Type = Pebble C SDK
   • Template = Empty Project

2. Add the following dependency:

   • Package Name = pebblejs
   • Version = 1.0.0

3. Add a new main.c file and an index.js file.

Now continue to add the default project files.

Local SDK

If you're using the Local SDK, just create a new C project with Javascript support:

$ pebble new-project PROJECTNAME --javascript

Now continue to add the default project files.

Default Project Files

Copy and paste these default project files into your project, replacing any existing file contents:

your-main.c

#include <pebble.h>
#include "pebblejs/simply.h"

int main(void) {
  Simply *simply = simply_create();
  app_event_loop();
  simply_destroy(simply);
}

index.js

require('pebblejs');
var UI = require('pebblejs/ui');

var card = new UI.Card({
  title: 'Hello World',
  body: 'This is your first Pebble app!',
  scrollable: true
});

card.show();

At this point you should be able to compile and run your new project.

Migrating an Existing Project

Unfortunately there isn't an automated way to migrate your existing Pebble.js project, but the steps are fairly straightforward.

1. Create a new project, following the steps above.

2. Change the project settings to match your old project settings, including the UUID.

3. Copy your project resources (images, fonts etc.), and source files into the new project.

4. Compile and enjoy your new C project with Pebble.js support.

Note: index.js is a direct replacement for app.js, which may be your old Javascript file.

Next Steps?

Want to add Clay support to your project? It's now easy by following the standard Clay Getting Started instructions!

If you have any questions or problems, post the details on the developer forum or Discord.

Happy Holidays!

Jon Barlow + Team #PEBBLExFITBIT

It's. Oh. So quiet. Ssshhhhhh.

We've added an often requested method for developers to detect if Quiet Time is enabled. To say that we had a lot of requests for this would be an understatement.

Quiet Time can be enabled manually, via calendar events, or via scheduled times, so we've made a simple method for querying whether it's currently active.

All you need to do is check each minute if it's active. This is easily done within the tick event, as follows:

static void handle_tick(struct tm *tick_time, TimeUnits units_changed) {
  if (units_changed & MINUTE_UNIT) {
    if (quiet_time_is_active()) {
      // It's nice and quiet
    } else {
      // Starts another big riot
    }
  }
}

You may also peek this value, for example, to prevent your application from vibrating during Quiet Time:

static void do_vibration() {
  if (!quiet_time_is_active()) {
    vibes_short_pulse();
  }
}

Raw HRM BPM

The Pebble Health API now exposes the raw BPM value from the Heart Rate Monitor sensor. This raw value is not filtered and is useful for applications which need to display the real-time sensor value, similar to the Pebble Workout app.

For example, in order to peek the current real-time HRM sensor, you would do the following:

HealthServiceAccessibilityMask hr = health_service_metric_accessible(HealthMetricHeartRateRawBPM, time(NULL), time(NULL));
if (hr & HealthServiceAccessibilityMaskAvailable) {
  HealthValue val = health_service_peek_current_value(HealthMetricHeartRateRawBPM);
  if(val > 0) {
    // Display raw HRM value
    static char s_hrm_buffer[8];
    snprintf(s_hrm_buffer, sizeof(s_hrm_buffer), "%lu BPM", (uint32_t)val);
    text_layer_set_text(s_hrm_layer, s_hrm_buffer);
  }
}

Find out more in the Heart Rate Monitor API guide.

PebbleKit 4.0

PebbleKit for iOS and Android facilitates communication between Pebble watchapps and 3rd party companion phone apps. Version 4.0 introduces a number of new features and bug fixes, including:

• Support for Pebble 2 (required for iOS only)
• Removal of Bluetooth Classic (iOS)
• Sports API - Support 3rd party HRM
• Sports API - Custom data field and label
• Sports API - Helper object to simplify usage, and minimize updates via Bluetooth

For further information about the specific platform changes, view the full iOS, or Android changelogs.

BLE HRM Mode

Ever wanted to use your Pebble 2 HRM as a dedicated BLE HRM device with your favourite mobile fitness app? Well now you can! Firmware 4.3 now implements the standard Bluetooth Heart Rate Service profile. In order to enable this profile, users must enable 'Pebble Health', then enable 'Heart Rate Monitoring' within the Pebble Health settings within the Pebble mobile app.

Developers who are looking to integrate directly with this profile should be aware of the following:

The Heart Rate Service UUID will be present in the advertising payload of Pebble, but you must open the Bluetooth settings on the Pebble to make it advertise and be discoverable over Bluetooth.

Because it's highly likely that the Pebble is already connected to the phone, it will not be advertising. Therefore, we recommend that your mobile app also enumerates already connected devices, to see if any of them support the Heart Rate Service. This is in addition to scanning for advertisements to find new devices that support HRS. By enumerating connected devices, you improve the user experience: users will not have to go into the Bluetooth settings menu on Pebble if their Pebble is already connected to the phone.

The first time an application subscribes to the Heart Rate Measurement characteristic, a UI prompt will appear on the Pebble, asking the user to allow sharing of their heart rate data. This permission is stored for the duration of the Bluetooth connection.

When HR data sharing is active, the HR sensor will run continuously at ~1Hz sample rate. This means there is a significant battery impact when using this feature for an extended period of time.

When all applications have unsubscribed from the Heart Rate Measurement characteristic, the HR sensor automatically returns to its default state.

Mobile apps should unsubscribe from the Heart Rate Measurement characteristic as soon as the data is no longer required. For example, a workout app should unsubscribe when the workout has finished and/or the application is exited.

If the Heart Rate Service is used continuously for a prolonged period of time (currently 4hrs), a notification is presented on the watch to remind the user that the HR data is still being shared.

The user can stop sharing HRM data from Settings > Bluetooth > Device. If the user chooses to stop sharing, the Bluetooth connection is briefly disconnected and reconnected to forcefully remove all subscribers. Unfortunately the Bluetooth GATT specification does not provide a better mechanism for a service to unsubscribe subscribers, only subscribers can unsubscribe themselves.

Service Characteristics Notes:

• 'Sensor Contact' field is used.
• 'Body Sensor' characteristic is used. The value is constant though (It will read "Wrist" / 0x02)
• 'RR Interval' is currently NOT used.
• 'Energy Expended' field is currently NOT used.
• 'Heart Rate Control Point' characteristic is currently NOT used.

What's Next

Check out the release notes for a full list of changes and fixes that were included in SDK 4.3.

Let us know on Twitter if you built something cool using the new APIs! We'd love to hear about your experiences with the SDK.

Happy Hacking!

Team Pebble

All About Those Pixels

The new display on the Pebble Time 2 is almost 53% physically larger, and the Pixels per inch (PPI) has been increased from 182 PPI to 202 PPI. This is a massive 200x228 pixels, compared to 144x168 on the Pebble Time Steel, that's an 88% increase in the total amount of pixels!.

Take a look at our Hardware guide for further information about the specifications of the Pebble Time 2.

Watchfaces and watchapps that have not been updated for the Emery platform will run in Bezel Mode. This means they will appear centered on screen at their original resolution (144x168), but due to the change in PPI, they appear slightly smaller.

Left: Pebble Time Steel, Middle: Pebble Time 2 - Bezel Mode, Right: Optimized for Pebble Time 2.
Concentricity Watchface

The increased number of pixels would immediately make you think that you can just add more elements to your watchface design, but due to the increase in PPI, existing elements and fonts may feel slightly smaller than expected when viewed on an actual device.

The image below simulates how the PPI difference makes a bezel mode application feel smaller on the Pebble Time 2.

Left: Pebble Time Steel, Right: Pebble Time 2 - Bezel Mode.

We've now seen that the increased amount of pixels doesn't necessarily equate to bigger text on our devices, due to the change in PPI, that's why we've created the new ContentSize API.

Introducing the ContentSize API

All existing Pebble smartwatches provide the ability for users to change the size of text for notifications and some system UI components using Settings > Notifications > Text Size.

The new ContentSize API now exposes this setting to developers, in order for them to adapt their application design and layout based on this user preference.

In the previous section, we saw how the PPI increase on Pebble Time 2 affected the relative size of a watchface. In the image below you can see precisely how text sizes are affected by the PPI change.

Yellow: Pebble Time Steel, Green: Pebble Time 2.

To negate the effects of this reduced font size, the Emery platform uses larger fonts by default. Developers can use the ContentSize API to match this behaviour within their own applications.

The following table explains how the text size setting affects the content size on each platform:

Developers should aim to implement designs which adapt to the capabilities of the device, but also the accessibility requirements of the user. The ContentSize API satisfies both of these goals.

For more information, read the ContentSize guide.

New for Rocky.js

With the release of SDK 4.2, we're extremely proud to announce that Rocky.js watchfaces can be published into the Pebble appstore! As usual, don't publish apps with the beta SDK into the appstore, please wait for the final release.

In addition to finalizing the memory contract for Rocky.js apps, we've also added a few new APIs to work with:

Memory Pressure

The memorypressure event has been added to allow developers to handle the situations which occur when the amount of memory available to their application has changed. Initially we've only implemented the high memory pressure level, which occurs right before your application is about to be terminated, due to a lack of memory. If you can free sufficient memory within the callback for this event, your application will continue to run. Please refer to the Rocky.js documentation and the memory pressure example application.

UserPreferences

The first watchface setting exposed in the new UserPreferences object is contentSize. This exposes the new ContentSize API to Rocky.js watchface developers. Find out more in the Rocky.js UserPreferences documentation.

What's Next

Check out the release notes for a full list of changes and fixes that were included in SDK 4.2-beta4.

Let us know on Twitter if you built something cool using the new APIs! We'd love to hear about your experiences with the SDK.

Happy Hacking!

Team Pebble

Pebble 2 smartwatches are on their way to Kickstarter backers, and firmware 4.1 will be ready and waiting for them.

Heart Rate Monitor API

The HRM APIs allow allow developers to query the user's current and historical heart rates. We've provided a simple to use API which caters for the most common use-cases.

Find out more in the Heart Rate Monitor API guide.

AppGlance REST API

The AppGlance REST API enables developers to programmatically set the icon and subtitle that appears alongside their app in the launcher. Developers can push slices to the their app's glance using their own backend servers by sending HTTPS requests to the timeline endpoint.

Find out more about App Glance in the SDK documentation, or read the AppGlance REST API guide.

What's Next

Check out the release notes for a full list of changes and fixes that were included in SDK 4.1.

Let us know on Twitter if you built something cool using the new APIs! We'd love to hear about your experiences with the SDK.

Happy Hacking!

Team Pebble

The Past and the Furious

However, there was one change which was met with mixed feedback from both users and developers alike, the removal of timeline past. Previously accessible via the UP button, timeline past was removed as part of the new 4.0 user experience (UX). In 4.0 we introduced new APIs to give developers more options to improve their application’s UX and potentially shift away from using the past for interactions

Unfortunately, this change prevented users from accessing any timeline pin which wasn’t in the present or future, negatively affecting a number of apps and their use cases for the timeline.

We carefully listened to feedback and suggestions from our developer community via the forums, Reddit, Twitter and Discord, and we are happy to announce that timeline past has returned in the v4.0.1 update. Users who need to access the timeline past can now assign it to one of their quick launch buttons.

And so, with the reintroduction of timeline past, balanced was restored, and that was the end of the story. Or was it?

Back to the Future!

If you’re the developer of an application which relies upon timeline past, you will probably want to inform your users about how they can access timeline past, as it will not be enabled by default. Fortunately, there are multiple ways in which you can do this easily.

1. App Store Description

Use the app store description of your app to explain that your application utilizes timeline past and that users will need to assign it to quick launch. For example:

This application utilizes pins in the timeline past. On your Pebble, go to ‘Settings’, ‘Quick Launch’, ‘Up Button’, then select ‘Timeline Past’. You can then access timeline past by long pressing UP.

2. Display a Splash Screen

Add a splash screen to your application which only runs once, and display a message informing users how to enable timeline past. You could use the ‘about-window’ Pebble package for a really quick and easy solution.

3. Display a One-Time Notification

Display a system notification which only fires once, and display a message informing users how to enable timeline past.

4. Display a Timeline Notification

Display a timeline notification, and display a message informing users how to enable timeline past.

The Future of the Past

For now, developers can continue to utilize timeline past, but over time we would like to provide a more diverse set of functionality that allows developers to surface information to their users. For example, some use cases of timeline past may be more appropriate as using an app glance, or timeline quick view instead.

We’re Listening!

Your feedback is incredibly important to us, it’s how we keep making awesome things. We love to receive your product and feature suggestions too.

We’re particularly interested to hear about your use cases and ideas for timeline as we travel further into the future! Let us know via the forums, Twitter and Discord!

What's New

Pebble OS 4.0 has been released and users with Pebble Time, Pebble Time Steel and Pebble Time Round will be receiving the update today.

We covered the new features in detail very recently, but let's have a quick reminder of the new APIs and functionality that's included.

Rocky.js

Javascript on the freakin' watch! Although still in beta, Rocky.js lets you start developing watchfaces in JavaScript using standard Web APIs, which you can then run directly on your watch. It's an embedded JavaScript revolution!

Read the updated Rocky.js blog post to get started.

Timeline Quick View

Timeline Quick View displays upcoming information from your timeline on your watchface. We introduced the UnobstructedArea API to allow developers to detect if the screen is being obstructed by a system modal, such as Timeline Quick View. Developers can use this new API to adapt their watchface layout according to the available screen real estate.

Read the UnobstructedArea guide to get started.

AppGlances

With the new AppGlance API, developers can dynamically change the icon and subtitle of their watchapp within the system launcher, at runtime. This allows developers to provide meaningful feedback to users without the need for their application to be launched.

Read the AppGlance C guide and the AppGlance PebbleKit JS guide to get started.

Diorite Platform

The new Pebble 2 devices use apps built for the Diorite platform, so you'll need SDK 4.0 to develop applications which target those devices.

Take a look at the Hardware Information guide to find out about the capabilities of the Pebble 2.

One Click Action application

The One Click Action application pattern promotes a type of watchapp which serves a single purpose. It launches, performs an action, and then terminates. This pattern utilizes the new AppGlance and AppExitReason APIs.

Take a look at the One Click Actions guide to get started.

Dude, Where's my HRM API?

We had planned on shipping the Heart Rate API with 4.0, but it's been pushed back into 4.1 so that we can add even more awesomeness. Pebble 2 devices will begin to appear on wrists after firmware 4.1 ships, so you'll still have time to begin implementing HRM data into your watchapps and watchfaces. We will announce details of the HRM API as soon as it's available.

What's Next

Please remember that we will promote watchfaces and watchapps that make use of these new 4.0 APIs if you submit them to the appstore from August 31st onwards.

Let us know on Twitter if you build something cool using the new APIs! We'd love to hear about your experiences with the SDK.

Happy Hacking!

Team Pebble

Pebble Time owners will be receiving OS 4.0 before Kickstarter backers receive their Pebble 2 watches, so we're recommending that developers publish their 4.0 watchapps and watchfaces into the appstore from August 31st onwards.

We'll be promoting new and updated apps which utilize the new SDK 4.0 APIs and features by creating a brand new category in the appstore called 'Optimized for 4.0'. This is your time to shine!

If you haven't even begun to prepare for 4.0, there are some really quick wins you can use to your advantage.

Menu Icon in the Launcher

The new launcher in 4.0 allows developers to provide a custom icon for their watchapps and watchfaces.

If your png file is color, we will use the luminance of the image to add some subtle gray when rendering it in the launcher, rather than just black and white. Transparency will be preserved.

You should add a 25x25 png to the resources.media section of the package.json file, and set "menuIcon": true. Please note that icons that are larger will be ignored and your app will have the default icon instead.

"resources": {
  "media": [
    {
      "menuIcon": true,
      "type": "png",
      "name": "IMAGE_MENU_ICON",
      "file": "images/icon.png"
    }
  ]
}

Timeline Quick View

This new feature really brings your timeline into the present, with your next appointment appearing as a modal notification over the active watchface.

We introduced the UnobstructedArea API in 4.0 to allow developers to detect if the screen is being obstructed by a system modal. Below you can see two examples of the Simplicity watchface. The Pebble on the left is not using the UnobstructedArea API, and the Pebble on the right is.

You can detect changes to the available screen real-estate and then move, scale, or hide their layers to achieve an optimal layout while the screen is partially obscured. This provides a fantastic experience to your users.

There's a dedicated guide which goes into more detail about the UnobstructedArea API, it contains examples and links to sample implementations.

AppGlances

While your static app icon and app title from the package.json are being used as the default to present your app to the user, AppGlances allow developers to control this content at runtime and to provide meaningful feedback to users directly from the new launcher. The API exposes the ability to dynamically change the icon and subtitle_template_string text of your application in the launcher.

Preview version of 4.0 launcher

Utilizing the App Glance API doesn't need to be difficult. We've provided guides, examples and sample applications for using the AppGlance C API and the AppGlance PebbleKit JS API.

The Diorite Platform

The Diorite platform was created for the new Pebble 2 devices. Its display is rectangular, 144x168 pixels, with 2 colors (black and white). It has a microphone and heart rate monitor, but it doesn't have a compass. If your app works with Aplite it will already work with Diorite, but there are some important considerations to note:

• If you chose to limit your app to some platforms, you need to add "diorite" to your targetPlatforms in the package.json.
• Check for the appropriate usage of compiler directives.

In general, it's better to use capability and feature detection, rather than platform detection. For example, when dealing with resources, use the suffix ~bw instead of ~aplite so they are picked on all black and white platforms.

What's Next

We're really excited for the release of Pebble OS 4.0 and the new features it brings. It's now time for you to take advantage of the new APIs and enhance your existing projects, or even create entirely new ones!

Why not build something like the One Click Action application, which utilizes the new App Glance and AppExitReason APIs.

Please remember that we will promote watchfaces and watchapps that make use of these new 4.0 APIs if you submit them to the appstore from August 31st onwards.

Let us know on Twitter if you build something cool using the new APIs! We'd love to hear about your experiences with the SDK.

Happy Hacking!

Team Pebble

It's JavaScript on the freakin' watch!

var rocky = require('rocky');

rocky.on('minutechange', function(event) {
  rocky.requestDraw();
});

rocky.on('draw', function(event) {
  var ctx = event.context;
  ctx.clearRect(0, 0, ctx.canvas.clientWidth, ctx.canvas.clientHeight);
  ctx.fillStyle = 'white';
  ctx.textAlign = 'center';

  var w = ctx.canvas.unobstructedWidth;
  var h = ctx.canvas.unobstructedHeight;
  ctx.fillText('JavaScript\non the watch!', w / 2, h / 2);
});

Right now we're giving you early access to this game-changing environment to create watchfaces entirely in JavaScript. Feel free to share your code, to install it on the emulator and on your watch (with the upcoming firmware 4.0), but please don't upload apps to the appstore as they will stop working in a future release.

We can't wait to hear your feedback and see what amazing watchfaces you create!

Enough hype, let's dive into the eye of the tiger!

Rocky.js Projects

Things are a little different in the JavaScript world, so let's take a closer look at the structure of a Rocky.js project:

package.json
src/rocky/index.js
src/pkjs/index.js
common/*.js

package.json

The format of the package.json file remains roughly the same as existing Pebble projects, with some minor differences:

• "projectType": "rocky".
• Aplite targetPlatform is not supported.
• resources are not currently supported, but will consume space in your PBW if specified.
• messageKeys are not permitted.

src/rocky/index.js

This is now the main entry point into our application on the watch. This is where our Rocky.js JavaScript code resides. All code within this file will be executed on the smartwatch. Additional scripts may be placed in this folder, see below.

src/pkjs/index.js

This file contains our PebbleKit JS (pkjs) JavaScript code. This code will execute on the mobile device connected to the smartwatch. Additional scripts may be placed in this folder, see below.

For Rocky.js projects only, we've added a new simplified communication channel postMessage() and on('message', ...) which allows you to send and receive JavaScript JSON objects between the phone and smartwatch.

Additional Scripts

Both the rocky and pkjs folders support the use of multiple .js files, which helps to keep your code clean and modular. Use the CommonJS Module format for your additional scripts, then require() them in your index.js.

// file: src/rocky/additional.js
function test() {
  console.log('Additional File');
}

module.exports.test = test;

// file: src/rocky/index.js
var additional = require('./additional');
additional.test();

common/*.js

If you need to share code between rocky and pkjs, you can create a common folder, then add your JavaScript files.

// file: src/common/shared.js
function test() {
  console.log('Hello from shared code');
}

module.exports.test = test;

// file: src/rocky/index.js
var shared = require('../common/shared');
shared.test();

// file: src/pkjs/index.js
var shared = require('../common/shared');
shared.test();

Available APIs

In this initial release of Rocky.js, we have focused on the ability to create watchfaces only. We will be adding more and more APIs as time progresses, and we're determined for JavaScript to have feature parity with the rest of the Pebble developer ecosystem.

We've developed our API in-line with standard Web APIs, which may appear strange to existing Pebble developers, but we're confident that this will facilitate code re-use and provide a better experience overall.

System Events

We've provided a series of events which every watchface will likely require, and each of these events allow you to provide a callback method which is emitted when the event occurs.

Existing Pebble developers will be familiar with the tick style events, including: secondchange, minutechange, hourchange and daychange. By using these events, instead of setInterval, we're automatically kept in sync with the wall clock time.

We also have a message event for receiving JavaScript JSON objects from the pkjs component, and a draw event which you'll use to control the screen updates.

rocky.on('minutechange', function(event) {
  // Request the screen to be redrawn on next pass
  rocky.requestDraw();
});

Drawing Canvas

The canvas is a 2D rendering context and represents the display of the Pebble smartwatch. We use the canvas context for drawing text and shapes. We're aiming to support standard Web API methods and properties where possible, so the canvas has been made available as a CanvasRenderingContext2D.

Please note that the canvas isn't fully implemented yet, so certain methods and properties are not available yet. We're still working on this, so expect more in future updates!

rocky.on('draw', function(event) {
  var ctx = event.context;

  ctx.fillStyle = 'red';
  ctx.textAlign = 'center';
  ctx.font = '14px Gothic';

  var w = ctx.canvas.unobstructedWidth;
  var h = ctx.canvas.unobstructedHeight;
  ctx.fillText('Rocky.js Rocks!', w / 2, h / 2);
});

Limitations

We are still in the early beta phase and there are some limitations and restrictions that you need to be aware of:

• Don't publish Rocky.js watchfaces to the Pebble appstore yet, they will stop working.
• Rocky.js watchfaces only run on the 4.0 emulators/firmware. The 4.0 firmware will be available soon for Basalt, Chalk and Diorite.
• No support for custom fonts, images and other resources, yet.
• No C code allowed.
• No messageKeys.
• There are file size and memory considerations with your Rocky.js projects. If you include a large JS library, it probably won't work.

SDK 4.0

We have published an updated version of CloudPebble which now supports creating Rocky.js watchfaces in JavaScript.

If you prefer our local tools, we've also published everything you need to begin creating Rocky.js watchfaces. Run the following command to install the Pebble Tool and 4.0 SDK:

$ brew upgrade pebble-sdk
$ pebble sdk install latest

How to Get Started

We created a 2-part tutorial for getting started with Rocky.js watchfaces. It explains everything you need to know about creating digital and analog watchfaces, plus how to retrieve weather conditions from the internet.

If you're looking for more detailed information, check out the API Documentation.

Sample Watchfaces

We've already created a few sample watchfaces:

• Tictoc - Simple analog watchface.
• Tictoc Weather - Simple analog watchface with weather data from a REST API.
• Leco with Weather - Simple digital watchface with weather data from a REST API.
• Leco with Clay - Simple analog watchface which uses Clay for configurable settings.
• Simplicity - Rocky.js version of the classic Simplicity watchface.

Feedback and Help

We hope you're as exicited about Rocky.js as we are. If you need assistance, have feedback or just want to send us some love, we're in #rockyjs on Discord or the Pebble developer forums.

We're already working on the next update of Rocky.js and your feedback will help shape the future!

Now you don't have to! Enter Cordova - an open source framework for building cross-platform mobile apps using web technologies such as HTML5 and JavaScript. What does this mean for you? One framework, and one codebase for building Pebble companion apps for iOS and Android!

Cordova allows developers to create plugins that wrap native functionality such as accessing the phone's contacts, calendar, camera, and other phone APIs. Plugins allow you to interface with these APIs through JavaScript, and use them in your Cordova projects. Needless to say, PebbleKit Android and PebbleKit iOS are now available as a singular Cordova plugin.

In this blog post, we'll look at how to use Cordova to create a companion app that allows you to retrieve the next upcoming calendar event for the current day.

Setup

The first step will be installing Cordova and creating a new project. Cordova provides these steps generically here, but if you want to follow along down to the T, here are the steps listed below.

$ npm install -g cordova
$ cordova create calendar-example com.pebble.calendarexample "Calendar Example"
$ cd calendar-example
$ cordova platform add android
$ cordova platform add ios
$ cordova plugin add cordova-plugin-calendar
$ cordova plugin add cordova-plugin-pebblekit

Note, this assumes you have node/npm already installed and avaiable on your machine. If not, head on over to nodejs.org to install node.

Doesn't seem too bad! If the cordova create command seems a little scary to you, don't be afraid to ask for help with cordova create --help.

Querying Events

The next step is to use the calendar plugin we added earlier in order to fetch the next event for the day. Before we do that though, we'll need to to setup the Cordova PebbleKit plugin, as shown below. Fire up your favourite text editor and open www/js/index.js file. This is the JavaScript file that runs when your app starts up, your application's control logic will go here.

Upon opening the file, you'll notice there's already a fair bit of code generated by Cordova. What's important here is the onDeviceReady function, this is a callback you can use to be notified once the plugins for your Cordova project have been loaded and are ready to be called. Let's create our own function called fetchCalendarEvent to be called once the PebbleKit plugin has been setup. We'll also declare a variable uuid with our Pebble app's UUID, which is required when communicating with our watchapp via AppMessage.

var uuid = "ebc92429-483e-4b91-b5f2-ead22e7e002d";
var app = {

  /* ... */

  onDeviceReady: function () {
    app.receivedEvent('deviceready');
    window.pebblekit.setup(uuid, function () {
      app.fetchCalendarEvent();
    });
  },

  fetchCalendarEvent: function () {
    var startDate = new Date(); // Now
    var endDate = new Date();
    endDate.setHours(24, 0, 0, 0); // Nearest midnight in the future

    window.plugins.calendar.findEvent(
      undefined, // title
      undefined, // eventLocation
      undefined, // notes
      startDate,
      endDate,
      app.calendarSuccessCallback,
      app.calendarFailureCallback
    );
  },

  calendarSuccessCallback: function (events) {
    // TODO
  },

  calendarFailureCallback: function (err) {
    console.error('Failed to fatch calendar events', err);
  }

  /* ... */

}

Note, the calendar plugin recommends checking that you have sufficient permissions before using its APIs. For the sake of brevity, the permission workflow has been omitted in this post.

The first 3 parameters we passed to the calendar.findEvent function are undefined, since we don't want to filter out events with specific titles, locations, or notes. The last two parameters are callback functions that will be executed when the app has succeeded or failed to fetch calendar data. Our calendarFailureCallback will log a simple message, and our calendarSuccessCallback will sort through the events and find the earliest event in the list.

calendarSuccessCallback: function (events) {
  if (events.length == 0) {
    // TODO
    return;
  }

  // Find the earliest returned event
  var earliestEvent = events[0];
  for (var i = 1; i < events.length; i++) {
    var tempDate = events[i];
    var date1 = Date.parse(earliestEvent.startDate);
    var date2 = Date.parse(tempDate.startDate);

    if (date2 < date1) {
      earliestEvent = tempDate;
    }
  }
},

Sending An AppMessage

All we have to do now is send the relevent bits of information down to our Pebble app. This is where the Pebble plugin is going to come in handy. At the end of the function, we'll call sendAppMessage which works in a similar manner to PebbleKit JS' sendAppMessage function.

The title is easy to snag - it's a property on the event object, available via event.title. The hours and minutes will take a bit of work since they only exist within a string property on the object (event.startDate). Luckily the format for the date is fixed, so we know where in the string it will be.

With this in mind, we can use the String.prototype.substring method to extract the numbers we want. The method takes two parameters, the first is the starting index (inclusive) of the substring, and the second is the the end index (exclusive). So if we want the hour, we'd pass 11 as the starting index, and 13 as the end index. This will create a substring containing the 11th and 12th characters of the string.

Also in this example, the data object represents our AppMessage, where 10, 11, and 12 are the AppMessage keys.

// Format is in YYYY-MM-DD HH:mm:ss
var hourString = earliestEvent.startDate.substring(11, 13);
var hour = parseInt(hourString);
var minuteString = earliestEvent.startDate.substring(14, 16);
var minute = parseInt(minuteString);

// AppMessage keys
var data = {
  '10': earliestEvent.title,
  '11': hour,
  '12': minute
};

window.pebblekit.sendAppMessage(uuid, data, function () {
  console.log('sent AppMessage', data);
}, function (err) {
  console.error('Couldn\'t send AppMessage', err);
});

The only thing left is to read the AppMessage on the C side. To quote every university professor I've ever had: "We leave this as an exercise to the reader". (Just kidding, you can see the watchface's full C code here, or consult the documentation).

While we only used two of the APIs of the PebbleKit Cordova plugin here, there is much more available to you, all with new and shiny documentation

For folks that are interested, our Cordova plugin is completely open source, and hosted on Github. We welcome bug reports, feature requests, and contributions with open arms :).

And that's all there is to it! If you've been holding back on writing a companion app for your amazing app, now's the time to try it!

How to get started

This post aims to provide high level explanation of how the framework works and how it came to be. Below is a quick overview of how easy it is to make your app configurable with Clay. If you would like to learn how to integrate Clay into your project, read our guide on app configuration or read the full documentation on the project GitHub repository.

1) Install the module via Pebble Packages - SDK: $ pebble package install pebble-clay - CloudPebble: Add pebble-clay, version ^1.0.0 to your project dependencies.

2) Create a configuration file that looks something like:

module.exports = [
  {
    "type": "heading",
    "defaultValue": "Example App"
  },
  {
    "type": "section",
    "items": [
      {
        "type": "color",
        "messageKey": "BackgroundColor",
        "defaultValue": "0x000000",
        "label": "Background Color"
      },
      {
        "type": "toggle",
        "messageKey": "Animations",
        "label": "Enable Animations",
        "defaultValue": false
      }
    ]
  },
  {
    "type": "submit",
    "defaultValue": "Save Settings"
  }
];

3) Update your project settings with the matching messageKeys from the config above.

4) Add a few lines to your index.js

var Clay = require('pebble-clay');
var clayConfig = require('./config');
var clay = new Clay(clayConfig);

5) Retrieve the values on the C side using standard app messages or alternatively let enamel do the work for you.

Why I created Clay

Clay began as a side project of mine. Whilst developing my Segment watchface, I wanted to add a configuration page to allow users to customize the colors of the watchface. However, I soon discovered this process to be rather fiddly. The old way of doing things required you to create and host HTML pages even for simple things like changing a background color or toggling an option. You would also need to write a bunch of boilerplate JavaScript to serialize and send the settings to the watch. Best case, for developers, this is super tedious. Worst case, it is terrifying. By day, I work as a web developer (mainly front-end) so if I was finding the process tiresome, I could only imagine how challenging it would be for someone who wasn't familiar with web technologies. And so I decided to create a framework that would alleviate this barrier for developers. I had a number of requirements that needed to be met in order for the framework to achieve my goals:

• It should not require developers to write any HTML or CSS.
• It should use JSON to define the generated config page.
• It should all work offline
• Developers should be able to add interactivity to the config page without manually manipulating DOM.
• Developers should be able to create and share their own custom components.
• The config page should be able to be versioned with the rest of the code in the project.
• It should have extensive unit tests with 100% test coverage.

How Clay Actually Works

Clay has two main components. The first is a very long string that is compiled from all the HTML, CSS and JavaScript that forms the skeleton of the generated config page. The second is the module that gets included in your index.js. This module is in charge of bundling all the dynamic elements set by the developer into a format that can be opened using Pebble.openURL(). It is also in charge of listening for the webviewclosed event and persisting the user's settings to local storage. I use Gulp and a series of Browserify transforms to compile all these components into a single module. The advantage of using a system such as Browserify, is that later, Clay can be made into a stand alone module to be used by developers who have very advanced use cases that require Clay to be run in a hosted HTML page.

The most challenging item on the requirements list was making the whole thing work offline. Neither of the Pebble mobile apps allow file system access from the config page's webview, so I had to get a little creative. It turns out that Data URIs work with more than images. You can in fact encode an entire HTML page into the URI. This was the solution to making the config pages offline. It sounds crazy but this method actually provides other advantages for developers beyond offline access. By bundling all the HTML, CSS and JavaScript into the Clay package, the version of Clay being used by the developer will not change without the developer rebuilding their app. This means developers do not need to worry about the behavior of their app's configuration page potentially breaking as new versions of Clay get released.

Advanced Use

If developers want to add additional functionality to their config page, they can. Clay allows developers to inject, what I call a custom function into the generated config page. This allows developers control of their config page without needing to manipulate the DOM. Clay achieves this by exposing an API that provides a consistent way of interacting with the config page as well as making AJAX requests. Instead of manually updating the values of HTML elements, developers can use the much simpler Clay API.

Where to find more information

• App configuration guide.
• Clay GitHub repository including full documentation.
• Chat to us in the #clay channel on Discord.
• Visit the Pebble Forums
• Tweet at @pebbledev

How to get involved

Clay is open source and welcomes pull requests from anybody. Have a look at the contributing guide for instructions on how you can help make Clay even better. Regardless of your skill level, if you have any ideas on how Clay could be improved or if you find any bugs, we would love you to submit an issue on GitHub.

In this blog post we’ll dive into the App Glance, UnobstructedArea, and AppExitReason APIs, and explain how you can use them to create great experiences for your users!

App Glance API

Let’s start with the App Glance API, which allows applications to present information for the launcher to display. The information an application displays in the launcher is called an app glance - and the information that is displayed at any particular point in time is referred to as an AppGlanceSlice.

AppGlanceSlices have expiration times, which means you can add multiple slices at once. Slices will be displayed in the order they are added and removed at their specified expiration times.

static void prv_update_app_glance(AppGlanceReloadSession *session, size_t limit, void *context) {
  // This shouldn't happen, but developers should always ensure they have
  // sufficient slices, or adding slices may fail.
  if (limit < 1) return;

  // !! When layout.icon_resource_id is not set, the app's default icon is used
  const AppGlanceSlice entry = (AppGlanceSlice) {
    .layout = {
      .template_string = "Hello from the app glance"
    },
    .expiration_time = APP_GLANCE_SLICE_NO_EXPIRATION
  };

  // Add the slice, and store the result so we can check it later
  AppGlanceResult result = app_gpance_add_slice(session, entry);
}

To dig into this feature, we recommend you start with our new AppGlance C API guide, and also give the API docs a quick read.

We are planning to extend the AppGlance API to include a PebbleKit JS API, as well as a HTTP web API, intended to allow developers to push AppGlanceSlices from external web services to their users' smartwatches.

UnobstructedArea API

The UnobstructedArea API allows developers to create watchfaces capable of sensing, and responding to Timeline Quick View events. Timeline Quick View is a new feature in SDK 4.0, which displays upcoming and ongoing events on top of the user’s watchface. The functionality added through the UnobstructedArea API allows developers to get the unobstructed bounds of a layer, or subscribe to events related to the watchface’s unobstructed area changing.

static int s_offset_top_percent = 33;
static int s_offset_bottom_percent = 20;

static void prv_unobstructed_change(AnimationProgress progress, void *context) {
  // Get the total available screen real-estate
  GRect bounds = layer_get_unobstructed_bounds(window_layer);

  // Shift the Y coordinate of the top text layer
  GRect top_frame = layer_get_frame(text_layer_get_layer(s_top_text_layer));
  top_frame.origin.y = bounds.size.h * s_offset_top_percent / 100;
  layer_set_frame(top_frame, text_layer_get_layer(s_top_text_layer));


  // Shift the Y coordinate of our bottom text layer
  GRect bottom_frame = layer_get_frame(text_layer_get_layer(s_bottom_text_layer));
  bottom_frame.origin.y = bounds.size.h * s_offset_bottom_percent / 100;
  layer_set_frame(bottom_frame, text_layer_get_layer(s_bottom_text_layer));
}

static void prv_main_window_load(Window *window) {
  unobstructed_area_service_subscribe((UnobstructedAreaHandlers) {
    .change = prv_unobstructed_change
  }, NULL);
}

We encourage developers to begin exploring what their existing watchfaces will look like when the system is displaying the Timeline Quick View dialog, and adjust their designs to provide the best experience possible for users.

Take a look at our UnobstructedArea API Guide and the API documentation to get started!

AppExitReason API

One of the APIs we haven’t talked about as much is the AppExitReason API, which enables developers to specify why their app exited, and determines whether the system returns the user to the launcher, or the active watchface. Take a look at our AppExitReason API Guide, and read the API docs to learn more.

This feature enables developers to create "One Click Action" watchapps, that perform an action, then immediately return the user to the watchface to create a simple, fluid experience.

To help get you started thinking about and designing One Click Action apps, we’ve created a One Click Action App Guide around the relatively minimal example of locking and unlocking your front door (with a Lockitron lock).

4.0 Emulator

The SDK 4 preview also includes an update to the emulator, which not only adds support for Pebble 2, but includes the updated 4.0 user interface, and a few other goodies that we’re sure developers will love.

The new emulator includes a launcher capable of displaying watchapps’ glances, and can be accessed by pressing the Select button from the watchface.

CloudPebble and the Pebble Tool also include new functionality to enable developers to toggle Timeline Quick View, allowing you to make sure your watchface looks good in every context!

Finally, we’ve added the ability to install multiple watchfaces and watchapps into the emulator. Watchfaces and watchapps installed into the emulator will remain installed (even if the emulator is closed) until pebble wipe is called from the command line.

Due to limitations with CloudPebble, this feature is currently only available in the Pebble Tool.

What’s Next

The SDK 4 developer preview is exactly that, a preview. You’ve probably noticed a few really important and exciting features we didn’t mention - the Heart Rate API has been designed, but is not yet fully implemented, and we have not yet added the ability to build applications for the Emery Platform (Pebble Time 2).

The official SDK 4 release is currently planned for the end of August - and it will include not only the Heart Rate API, and support for building Emery applications, but the first version of Pebble’s fantastic new embedded JavaScript SDK, Rocky.js.

Show Us What You Make

While we’ve been conceptualizing and designing the new functionality in SDK 4 for quite a long time, the API itself is relatively new, even for those of us lucky enough to ‘be on the inside’ - so we’ve only really just begun to see what’s possible, and we’re more than excited to see what you’ll build with this new functionality.

Send us a link to something you’ve built on Twitter ( @pebbledev) and we’ll look at including it in an upcoming newsletter (and send some swag your way).

Happy Hacking!

Team Pebble

There are already a healthy selection of Pebble libraries to be had, such as Yuriy's excellent EffectLayer, Reboot's Ramblings' palette manipulator, or even our own weather library. However, using them today is inelegant: you generally have to copy/paste all of the library code into your own project and follow some other setup instructions: assigning appmessage keys, editing resources into your appinfo.json, or similar.

Starting today, using a Pebble Package can be as simple as running pebble package install pebble-owm-weather. A Pebble Package can contain both C code for the watch and JavaScript code for the phone. Furthermore, it can also contain any resources, and define its own appmessage keys. All numeric identifiers will be resolved at app build time to ensure there are never any conflicts. This helps to enable zero-setup packages of all kinds.

To make the usage of appmessages in Pebble Packages possible, we have also substantially improved the functionality of the old appKeys section of appinfo.json. We will now automatically insert the keys into your C code with the prefix MESSAGE_KEY_. You can also access their numeric values from JavaScript by requiring the message_keys module: var keys = require('message_keys').

Packages would be nothing without a package manager, so we have built our packaging system on top of the excellent npm package manager. This gives us support for dependency management, versioning, package hosting, and more. Furthermore, some traditional JavaScript modules on npm will work out of the box, as long as they don't depend on running in node or on a browser. As part of this move we have deprecated appinfo.json: we now use package.json instead. The latest version of the Pebble Tool can convert your project when you run pebble convert-project. Old-style projects continue to be supported, but cannot use the package manager.

For your convenience, we have provided some wrappers around npm functionality:

• pebble package install to safely install a package.
• pebble package uninstall to uninstall a package.
• pebble package login to log in to or create your npm account.
• pebble package publish to publish your package to npm.

We also have UI in CloudPebble to enter your dependencies.

You can browse the available packages on npm under the pebble-package keyword, and read our guides on using and creating Pebble Packages.

I'm looking forward to seeing what you make!

There is a lot to take in, so we’re here to help break down what’s new and exciting for our favorite developer community!

The Smartwatches

We are introducing two new smartwatches designed to track and improve your health, and simplify your life.

Pebble 2, and Time 2

Pebble 2 is a take on our classic Pebble that launched the smartwatch market in 2012. It includes updated hardware with a high contrast black and white display, microphone, up to seven days battery life, plus activity, sleep and heart rate tracking.

Time 2 takes everything our users love about the Pebble Time Steel, and builds upon it. It offers the same ten day battery life, activity and sleep tracking you’re used to, and adds a larger color display, a smaller bezel, and heart rate tracking!

If you are looking to dive a bit deeper, we encourage you to check out our updated Hardware Information Guide below, and our Pebble-3D GitHub repository that includes 3D drawings of all our smartwatches!

Pebble Core

A lot of people like to call Pebble a ‘smartwatch’ company, but we’ve decided it’s Time to prove them wrong, and expand our Core business with an entirely new ultra-wearable!

Pebble Core

Pebble Core is an entirely new class of wearable device - it features 3G, WiFi, Bluetooth, GPS, an accelerometer, two programmable buttons, a headphone jack, and a hardware expansion port accessible to developers.

Oh yeah, and it’s an open platform.

Pebble Core is built on top of Android, but has the familiar Pebble developer experience you’re used to. Pebble Core will be able to run the PebbleKit JS component of watchapps, to ensure apps continue functioning when a user leaves their mobile device at home. Additionally, developers will be able to write standalone Pebble Core applications using an extended version of PebbleKit JS, allowing you to customize the user experience depending on whether or not the user has an attached Pebble smartwatch.

With Internet connectivity on the go, and programmatic access to GPS and Bluetooth Low Energy, the possibilities are endless.

• Create an app to open your Internet-connected garage door with the click of a button, or order pizza to your current location.
• Use geofencing to automatically notify your loved ones when you leave work or school.
• Hook it up to your drone and send real time sensor and location information to your phone.

We have a million ideas for Pebble Core, and we can’t wait for you to get your hands on it and start hacking! We will be providing more information and news around Pebble Core soon, so stay tuned!

SDK 4.0 (The C Part)

With the launch of Pebble 2 and Time 2 we will be releasing our next revision to the operating system with Pebble OS 4.0. The new operating system includes an updated user experience aimed at helping the user have access to the information they need at a glance, and take quick, simple actions.

Let’s look at some of the new features in Pebble OS 4.0, and how you can take advantage of them as a developer.

The most obvious change is that we have replaced timeline past with an updated Launcher capable of displaying glanceable information through a new AppGlances API. To help accommodate the removal of timeline past, we’ve updated the behaviour of “Now” pins to allow them to persist into the future.

Preview version of updated launcher with AppGlances

Along with the updated launcher, we’re also helping users gain better insight into what’s going on right now through a new feature called timeline quick view. Timeline Quick View is a small notification displayed on the user’s watchface to let them know what’s happening right now, or coming up soon.

Preview version of timeline quick view

The default behaviour for timeline quick view is to simply draw over the bottom of the watchface, however, developers will have access to a new set of APIs to manage how their watchface responds to timeline quick view events. SDK 4.0 will include APIs to find the “unobstructed area” of the display, and to react to timeline quick view being displayed, and hidden. Using these APIs, developers can create watchfaces that respond to timeline quick view, and programmatically adjust!

And of course, you’ll have programmatic access to the heart rate monitor through an updated HealthService, capable of providing both real time, and historical heart rate information.

SDK 4.0 (The Embedded JavaScript Part)

We’ve been hard at work enabling developers to write JavaScript applications that run directly on our smartwatches. In a recent firmware release, we hit a major milestone - we shipped a JavaScript version of the default watchface, TicToc, and a Pebble-specific port of an embedded JavaScript runtime to power it.

We believe that providing an embedded JavaScript SDK will make our platform more accessible, powerful, and collaborative. Our JavaScript SDK will be based on existing Standard Web APIs wherever possible - your display will be a Canvas, your watch and mobile device will communicate through a message-passing API similar to Web Worker, and you’ll access the compass and accelerometer through the Device Orientation API.

This is Real (Really!)

We’ll be shipping an early preview version of the 4.0 C SDK near the conclusion of the Kickstarter campaign. The 4.0 C SDK will include preview APIs for managing what information your watchapps display in the launcher, how your watchfaces respond to timeline quick view events, and more.

Support for building and testing Pebble 2 and Time 2 watchapps and watchfaces will be included in the first official SDK 4 release, tentatively scheduled for July 2016.

Finally, the embedded JavaScript SDK is scheduled to ship later this summer. We want to ensure that you have access to it before the first Pebble 2 smartwatches make it onto users’ wrists, so you have time to write the first wave of Pebble 2 watchfaces in JavaScript!

Let’s Meetup IRL

If you’re local to San Francisco, we welcome you to join us at SF Geekdom on June 15 at 6:00pm (more details to follow) to checkout our new hardware, and learn more about what’s new, and how to best use it. If you are like the majority of the world and don’t live in San Francisco, you’ll be able to access a recording of our Meetup after the event so you can join in the fun and learn what’s new!

If you run a Pebble Meetup, or are interested in running an event to bring together Pebble Developers, let us know - we’d love to call-in, talk about what’s new in SDK 4.0, and answer questions from your local community!

We Need You to Make This Happen

We have worked hard to pack this Kickstarter with as many developer friendly features and products as possible, and we hope you are as excited as we are! We’re counting on your support to make all of this happen - so go treat yourself to some awesome new Pebble products, and help us show the world what wearables should look like!

https://pebble.com/kickstarter

kickstarter.com/projects/655382546/pal-strap-gps-and-extended-battery-strap-for-pebbl

Powerstrap is incredibly excited to share that our Kickstarter for the world’s first GPS and battery Smartstrap for Pebble Time and Pebble Time Steel watches is now live! We have been working very closely with Pebble to provide the best strap for this amazing community since 2014 and the time (pun intended) is finally here to share it with everyone!

Meet Pal!

It features a high performance, independent GPS that allows users to track speed, distance, elevation, and route for up to 24 hours without the need for a Smartphone. Begin your activity as soon as you go out, with no time wasted idly waiting for a signal. Pal uses industry leading GPS (Qualcomm SiRF), which provides quick signal pickup. It also extends the life of Pebble Time and Pebble Time Steel for up to seven days and shares the same charger for hassle-free charging. In cases of emergency, the Pal can be used as a battery back-up to the Pebble. It also comes with a companion app for iOS and Android for GPS logs and social media sharing.

How Did We Get Started On This Journey?

We love our Pebbles and wanted to contribute to the community. I have been a watchstrap creator, watch straps are my passion. I’ve found that they usually don’t get the respect that they deserve in the creation process. So when I fell in love with Pebble, I wanted to see what I could do to lend my expertise to make the already amazing Pebble just that much more awesome. I took my experience with watch straps, enlisted two great engineers CC and Edwin, whose backgrounds are in electronics, mechanical engineering and the battery business.

One of the things that was so incredibly helpful, was being able to work hand in hand with Pebble to make sure that our idea for a functional strap matched with Pebble’s vision and community. They have been great partners in helping us identify what would be of most use to the Pebble community, best practices, and gave great feedback which helped us perfect the design. This relationship is not unlike the relationship between the Pebble and Pal, both working together in harmony to make something unique and great -- which actually helped inspire the name Pal!

Early concept drawing and battery buckle prototype

So how does it work exactly?

Let’s dive in deeper into the technical specification of the Pal Smartstrap. Pal GPS architecture is powered by Qualcomm’s SiRF chipset, this chipset can track speed, distance, and elevation as a standalone, offering an impressively fast first time signal pickup within three minutes and it will continue to work even if it goes indoors for a while, and then comes back outside. PAL also features data storage for up to 24 hours of GPS data.

Raw GPS data received from satellites are processed by Pal’s MCU and results are pumped to Pebble for display and storage - allowing the smartwatch to leverage GPS location data without the need to be connected to a mobile phone.

Per our efficient power management intelligence, Pal’s battery recharges Pebble’s battery only when the user manually activates the function or when Pebble’s battery drops to very low level and triggers auto-charging. Connecting pins between the Pal and Pebble are surrounded by soft gasket. This structure makes Pal water resistant, but it probably cannot withstand swimming or diving. In any case, even if water goes between connecting pins, Pal’s electronic design has protection measure and it won’t be damaged.

Tech Specs: GNSS support: GPS only TTFF cold fix time: about 40 seconds under open sky. Location fix time can be accelerated by AGPS (working in progress with Qualcomm) Location hot fix: within 10 seconds. Certification planned to be done upon campaign success and product launch: CE, FCC, IC Battery technical Specs: Battery capacity: 250mAh Battery chemistry: Lithium Ion Polymer Nominal Voltage: 3.8V Pebble Watch’s battery: can be charged from either PAL’s internal battery or external charging port underneath PAL Internal battery of PAL: charge up from charging port underneath PAL

Design

Together, the Pal and Pebble Time weigh only 65grams and offer users enhanced functionality, without added weight or bulkiness. The interchangeable design features a unique strap curvature that is ergonomically engineered to fit every wrist size and it only takes seconds to pin the Smartstrap to the clasp to customize the strap length.

Open Platform

From the beginning, it was important that we kept Pal open so developers have the opportunity to take the strap to the next level. We hope that by incorporating the best in class hardware components into Pal, it will help encourage app developers to be even more creative and limitless.

Obviously our first priority is getting fully funded so we can go to production, however, we are currently starting communication with interested developers as there are so many interesting and helpful potential ways that this technology can be adapted. When we are fully funded, we will release our Pal strap API. How we interact with developers moving forward will depend on the interest and size of the group, however anticipate that the dev community on Pebble.com as a likely option. If you have an idea for an app for the Pal, we would love to hear from you and potentially support your development. Contacts us here: pal@palstrap.com

We've launched a Kickstarter to help bring PAL to life. We hope you will check us out and support us at kickstarter.com/projects/655382546/pal-strap-gps-and-extended-battery-strap-for-pebbl

Supporting Chalk required a ton of bug crushing to become compatible with the new 3.0 style status bar, changes to accommodate reduced memory on the 3.x Aplite platform, adding new features such as text flow and paging, and making it easier to target multiple platforms by adding a feature detection API.

Pebble.js running on all available platforms.

Whether or not you’re targeting the Chalk platform, there are many new features for you to explore in this update - and simply recompiling your project with the latest version of Pebble.js will update the look and feel through refined spacing between text fields.

The background color of window's status bar can now be changed, allowing it to blend in with the app's background in a similar way to Pebble's Music app.

var defaultBackgroundColor = 'white';
var defaultColor = 'black';

var card = new UI.Card({
  backgroundColor: defaultBackgroundColor,
  status: {
    color: defaultColor,
    backgroundColor: defaultBackgroundColor
  }
});

card.show();

Two new elements were added, Line and Radial, and all elements now include borderWidth, borderColor and backgroundColor properties (except Line, which uses strokeWidth and strokeColor instead).

There are many bugfixes as well. Scrolling is no longer jittery for cards and menus, the status bar will no longer disappear upon changing windows that both requested to have a status bar, and large bodies of text are truncated in cards instead of just not showing up.

There is one new known issue - which causes some applications with heavy memory usage to crash. If you're experiencing this issue, we would appreciate you adding more details to #161.

This update also comes with two new guides to help familiarize yourself with the exciting new world of round and colorful apps. Using Color will help you understand all the different ways you can specify which color you want your text (and other elements) to be, and how you would go about styling your app with color. Using Feature will help you understand the new Feature API, how it can be used to specify different behaviours and UIs depending on what platform you're running on, and what features it includes.

CloudPebble

Enabling Chalk support in CloudPebble is simple. Open your project's "Settings" screen, check the "Build Chalk" box, then recompile your project.

Cloud Pebble Settings Screen.

To run your project on CloudPebble's Chalk emulator, compile your project, then open the "Compilation" sceen, and select "Emulator" then "Chalk."

Pebble Tool + Local SDK

If you're using the Pebble Tool and local SDK, you'll need to merge the master branch of the Pebble.js repositoroy into your project, then edit the appinfo.json file to include chalk in the targetPlatforms array.

{
  "uuid": "8e02b5f5-c0fb-450c-a568-47fcaadf97eb",
  "shortName": "Test",
  "longName": "Test Application",
  "companyName": "#makeawesomehappen",
  "versionLabel": "0.1",
  "sdkVersion": "3",
  "enableMultiJS": true,
  "targetPlatforms": ["aplite", "basalt", "chalk"],
  "watchapp": {
    "watchface": false
  },
  "appKeys": { },
  "resources": { }
}

To run your project with command line emulator, compile your project, then install it to the Chalk emulator:

> pebble clean
> pebble build && pebble install --emulator=chalk --logs

Remember, we’re also working on supporting native JavaScript applications on Pebble smartwatches, and are calling it Rocky.js. Rest assured, I will continue to maintain Pebble.js, and you can continue to develop and ship apps with it! Keep an eye out on future developments by following the GitHub repository and checking out the latest commits.

Let us know abour Pebble.js project or anything else you feel like mentioning, by shouting on Twitter to @PebbleDev, @Pebble or even myself @Meiguro.

Here’s to more exciting weekend coding sessions in the future for both of us!

If you want to learn to program using the C programming language, you have lots of choices. C has been around a while, so there are many textbooks and lots of Web sites that have information on the language. Most are very general, with examples and projects that you could run on any general purpose computer. Very few are tailored to embedded systems and none are targeted at smartwatches, until now, that is.

Pebble has teamed up with a college professor and a group of Pebble community developers to produce Learning C with Pebble, an online, open source textbook that teaches C with examples and projects focused on Pebble smartwatches.

In order to build apps for Pebble smartwatches, a developer needs to program in one of two languages: JavaScript or C. Of the two, you might choose JavaScript for some familiar features, but C might be the better choice since it produces apps that run more efficiently and perform with better speed than those written in JavaScript.

The book is a textbook: it teaches how to program using the C programming language. But it is very unique among textbooks.

• It is free, online, and open source. You can have your own copy for free. You can read it online or download the PDF or ePub versions.
• It is written with Markdown formatting. This means you can fork the book's source, edit it or add new content in Markdown, and submit a pull request to have your changes added to the book.
• It represents a work in progress. The online version will be updated to reflect error corrections and new content. Sections of the book will be released in intervals.

In addition to these unique features, Learning C with Pebble comes with Project Exercises at the end of each chapter. Lots of C books include questions or small exercises to work on with each chapter. This book has "project" exercises: complete Pebble smartwatch applications that give you code to start, ask you to make changes, and give you a solution so you can compare your answer to others. It encourages you to work in focused code that runs on a Pebble and helps you learn C in an environment that is targeted to Pebble programming.

In addition to learning the topics in each chapter, these Project Exercises help you learn the Pebble programming system and the scaffolding that apps for Pebble need to run. You learn Pebble code in a way that helps you to become comfortable with the runtime environment and with unfamiliar code. And you learn C along the way.

This book is written by Mike Jipping, a professor of Computer Science at Hope College in Holland, Michigan, USA. Mike has been writing apps for handheld computers, smartphones, and wearable devices for over 30 years. He has developed several apps for Pebble smartwatches. The Pebble community developers who are helping out with the book are Allan Findlay, Paul Niven, Mathew Reiss, David Rodriguez Rincon, and Rob Spiess. Everyone is active in the Pebble developer community, in the forums, and on Slack.

The book can be found at http://pbl.io/cbook. The first 8 chapters have been released with the remainder of the book will be coming out over the coming summer. This is a readable book, packed with examples and code and projects. It's a great way to learn the C programming language on Pebble smartwatches.

We'd appreciate your feedback, be sure to tweet @PebbleDev on Twitter or find us on Discord.

Hackathons are wonderful. The three I've attended thus far have been amazing opportunities to learn new technologies and work with other hackers to bring an idea to life. Hackathons embody some of the pure magical joy of computing that make your eyes light up with new ideas, and they provide an opportunity for participants to work with hardware and resources that they may not have had access to otherwise.

Working on the prototype during GrizzHacks

When I showed up to GrizzHacks I had no idea what I wanted to make, but I knew I wanted to explore some of the new hardware that was provided by the organizers, and the Pebble smartwatch and Myo armband immediately stuck out as bursting with potential. I remembered a project from a past hackathon that used the Myo wristband to control a string of colored lights based on the user’s movement, and was impressed by the expressive potential that gesture-based input suggested. I wanted to explore that.

Our minds simultaneously inhabit physical and virtual spaces, switching between the two constantly throughout the day. Using movement and gesture-based technology for control draws these spaces closer together, providing a stronger connection between the two worlds and enabling expressive and emotional interactions with virtual spaces through technology.

One of the best ways to translate and express emotion is through music, and I realized that with the gesture recognition of the Myo and the accelerometer packed inside of the Pebble I could create an instrument that allowed for musical expression through the motion of the device in a way similar to the theremin.

Now that I had my idea, I just needed to build it. I created a system to stream hardware sensor data to a Node.js server and a web front-end that listeners can connect to from anywhere in the world. Here, streaming sensor data is converted to synthesizer modulations done in-browser by a web audio synth. Movements on different axes were meant to control different parameters of the synthesizer, such as frequency and amplitude. Pebble made this task a dream - the hardware worked beautifully, and I was able to transfer accelerometer data over a websocket connection with ease.

// Simplified Pebble JS code
var UI = require('ui');
var Accel = require('ui/accel');
var ws = new WebSocket('ws://boiling-fjord-40795.herokuapp.com/');

Accel.on('data', function(e) {
  ws.send(JSON.stringify(e.accel));
});

ws.onclose = function() {
  Accel.on('data', function(e) { /* do nothing */ });
};

After ~20 hours of fiddling with server configurations and synth modules I had a working prototype. A few tweaks to the sensitivity/responsiveness (that feel much better in newer builds) and it was ready to present. Things weren’t perfect, but such is the nature of a hackathon. Larger and excited motions would cause synthesizer values to fluctuate wildly, creating an audio stream that sounded something like a dial-up connection. As a result, I believe I may have the honor of saying that I'm the first person to perform dial-up on stage. The positive response was amazing, the crowd loved it. So much so that I hurried off-stage in a rush of excitement and thanks, forgetting to speak to the very real future of the project.

Demoing the instrument to a live audience

Work has begun on expanding the project. The web app design makes it trivial to connect multiple users all playing separate instruments, enabling multi-user performances with each participant playing remotely from anywhere in the world. The viewer end of the interface is modeled as a visualization of a garden, with viewers represented as flowers in the garden and performers as bouncing balls of light. Viewers can chat through a common interface, help shape the current performance through their interaction, as well as record, play back, and share performances.

Garden's demo interface

Development has begun on a new instrument interface powered by an Android application. The app works similarly to the interface created for the Pebble - streaming sensor data from the phone to the web app, with additional concerns and design changes due to the weight of the phone and the addition of a touch screen. The differences in the two will make for two distinctly different instruments with similarly intuitive styles of control, enabling users to join together for collaborative, physically-based musical performances.

Huge thanks to the people at Pebble for their great piece of wearable tech and for being all-around awesome. This couldn’t have happened without their awesome documentation and support. I'm incredibly excited for the future of this project. It’s been a blast to work on so far, and I hope you'll join me later this summer when the new version of the site goes live for testing! If you’re interested, you can find more information about the project (including it’s source) on hackaday.io and follow me on Twitter @JeremyKarbowski where I occasionally post about the projects I’m working on.

KiezelPay was designed to help developers sell their apps and watchfaces for the Pebble smartwatch as easily, securely, and globally as possible. We learned a lot when we created a payment system for our Kiezel Watchfaces, and we wanted to improve that system and open it to all developers!

We strongly believe you deserve to get paid.

As a team we felt that bringing a solid payment system to the Pebble ecosystem would not only increase developer interest but also bring a much greater quality of apps and watchfaces to Pebble users.

How Does it Work?

KiezelPay apps have 3 possible statuses - unlicensed, trial, and licensed.

When the app is compiled with the trial setting enabled, it will check its status on our server as soon as the KiezelPay library is initialized for the first time after a clean install - otherwise, the app will check its status when told to do so by the developer (e.g. PinyWings checks for the app's status after the first level, allowing users to play the first level before purchasing the game).

The diagram above describes the flow of communication between the Pebble app and the KiezelPay servers, including what it looks like when the optional 'trial' and 'periodic rechecks after purchase' features are enabled.

Why Use KiezelPay?

KiezelPay is secure, simple to integrate, and jam packed with features like trial based apps and watchfaces, discount/promo codes, a day-­to-­day sales dashboard, worldwide transactions, and handles international taxes with ease!

Security

The first thing that comes to mind when thinking about a payment system is security. Whatever solution we created, we knew it had to be difficult to manipulate the system into giving away free usage of the app, and that the payments should be performed in a secure and trustworthy environment.

We ensure that all vital information and critical security checks happen in the application's C code, and that all communication with the KiezelPay servers use checksums, app secrets, and nonces to help secure the system.

We put a lot of effort into securing our platform, and if you would like to learn more we invite you to contact us at support@kiezelpay.com.

Taxes/Legal

International tax laws are becoming increasingly difficult to handle. Many governments have noticed that the digital goods sector is growing rapidly, and they are losing a lot of money because foreign companies can sell their digital goods with easy without having to pay local sales tax.

For these reasons, the EU recently changed their digital goods tax system, which now requires everyone to charge VAT to anyone from the EU buying digital goods from them, regardless of where the company/person selling those goods is located, and regardless of the amount sold... and many more countries are either following suit, or creating new tax requirements for digital goods of their own.

Trying to stay on top of tax requirements is an insurmountable burden for a single developer that just wants to make a few bucks selling their apps. At KiezelPay, we have spent an enormous amount of time with international accountants and lawyers to ensure we're compliant with current international taxes and laws - not only for accepting payments, but getting the developer paid legally and correctly in a timely manner.

Ease of Integration

Pebble goes to great lengths to make their development platform accessible to new and experienced developers alike, and we wanted to ensure our platform was the same. An average developer should be able to setup KiezelPay and integrate it into their app in about an hour.

Once a developer creates a product in KiezelPay, they can download a pre-built watchface that includes the KiezelPay integration that has been configured for the product they just setup!

Features

Our KiezelPay platform currently offers you the following features:

• Trial usage: You, as the developer, can choose if you want to allow users to test your app before purchasing by having a trial period. With a simple setting in your KiezelPay account, you can enable/disable trials, and define how long they last. After the trial is expired, the user will be required to purchase to continue.
• Discounts: Want to reward that user that helped you hunt down a hard to find bug with a free license or have a holiday specific pricing? No problem! Our system allows you to create all kinds of discounts for every situation: percentage based or fixed amount, one time valid or during a specific period in time, with code or for anyone that purchases, etc.
• Dashboard:​ Your KiezelPay account will show you all kinds of information about your apps. You can see a nice graph with your day­-to-­day income, easily see how much money you have made in total, how much you will receive at the next payout, and when that payout will happen.
• Purchase History: We made it easy to find any of your customers to reach out to them, see information about when they purchased the app, and what may have gone wrong during failed purchases.
• Test mode: By changing a single define in the KiezelPay library header file, you can run your app in test mode, allowing you to test the complete KiezelPay purchase process without having to pay for real.

The Future!

Kiezel is always looking to improve KiezelPay and would love any feedback you may have. We plan to improve KiezelPay in the coming weeks by adding the following:

• Acceptance of Credit/Debit Card transactions
• New dashboard analytics and graphs
• Developer initiated refunds
• Support for selling complete packages of apps/faces instead of only single apps/faces
• In­-app purchases
• And even more!

KiezelPay is officially now live and open to all developers to sign up for free. To sign up visit our site at KiezelPay.com, and join the KiezelPay Discord server.

We hope you enjoy what we’ve created!

Kristof Verpoorten & Jaron Pulver

KiezelPay LLC

The 2015 Developer Retreat - Bringing the Pebble Dev Team together with the Pebble Community!

The Developer Relations team is responsible for overseeing Pebble's developer program, managing documentation and events, listening to and advocating for our community's needs, and creating a safe, welcoming and empowered community of Pebble developers. It's a big job - and we are incredibly lucky and grateful to be able to continue the work of the brilliant and compassionate team that came before us!

And now to introduce you to the (somewhat) new faces of Developer Relation: Cat and Jon!

Cat & Jon (with special guest appearance by Jess the dog)

Cat Haines joined Pebble in October 2015, and has been helping with a lot of the behind the scenes work for Pebble's Developer Relations team. Cat enjoys tinkering with hardware and JavaScript (so naturally she's excited about Rocky), crafting, and trying her best to keep a variety of house plants alive. You can follow her antics on Twitter, GitHub, and her personal blog.

Jon Barlow joined Pebble in September 2015. He is a champion Kickstarter backer and has been a longstanding community member and forum moderator. You may remember him from such apps as 91 Dub and The Day Today. Jon has spent many years volunteering and helping people within the Pebble community and is looking forward to continuing this role as his day job. Jon works for Pebble remotely from the UK and you can find him on Twitter and GitHub.

We have some exciting updates in the works - including introductions to some of the other well know (and loved) developer facing teams at Pebble. We can't wait to share what's coming up - so stay tuned, and if you have any questions, you can always find Cat (@cat) or Jon (@orviwan) on Pebble's Slack channel.

Happy Hacking!

We’ve known for a while that our guides section was a bit of a weak link (sorry for the inconvenience!) - and to that end, we’ve spent a lot of time thinking about, and writing, a new set of guides that should help to better guide you along your path to becoming an awesome Pebble developer!

What Did We Do?

• We’ve restructured the Table of Contents and how we organize guides to make it easier to find the information you’re looking for.

• We’ve substantially improved our Communication guides (i.e. AppMessages, Datalogging, etc), which we’ve found to be one of the concepts new developers struggle with the most.

• We’ve added a new Best Practices section to help you take your apps to the next level by introducing concepts such as creating low power apps and watchfaces, and suggestions on how to organize larger projects.

• We’ve created guides around Appstore Publishing to help you get your hard work into the hands (onto the wrists?) of others.

• We’ve added new guides for Pebble Draw Commands, and more areas of Pebble development.

Why Did We Do It?

Some of the older guides, as well as the overall structure of this section of our site, have been around for a long time. While seasoned developers are likely familiar with where they can find various tidbits of buried information, more recent additions to the Pebble developer family often struggle to find the information they need.

But we haven’t just updated how we organize our guides - we’ve also taken this opportunity to update some of the best practices (and language) used throughout the guides. We’ve learned a lot over the past few years, and it’s safe to say we’re all better at this than we were when the guides were first published.

How Did We Do It?

The old set of categories was introduced in 2014. Since then we have seen the addition of new content for SDK 3.x, Pebble timeline, Design and Interaction, Smartstraps, and other smaller additions. When we started this project, we had a total of 79 guides in 20 different nested categories. After brainstorming what information should be kept as is, improved, added, and dropped, we ended up with a set of 64 guides across 13 categories.

After the drafts were agreed upon, we set to work with the task of writing the actual content, using a combination of the existing content and an appreciation of the most common questions and problems raised by our developer community.

With all of the new content in place, the final task was to shore up the improved version of the developer site. Links were checked, and redirects were created for all of the old guides - so if you have any favourite guides that you’ve bookmarked they should automagically take you to the appropriate section in the new guides.

In total, the project resulted in 16,467 lines added and 18,386 lines removed across 370 files. Wow!

What Are We Doing Next?

If we’ve done our jobs, the new guides shouldn’t need any major updates for the foreseeable future, and the new structure should make it easier to extend, improve, and add to our guides when new features come along.

Looking beyond the guides section, we have a lot of ideas (and work planned) to further improve the Pebble Developer site, and we’re excited to share it with you as soon as it’s ready.

As always, keep the feedback and bug reports coming! Hopefully nothing is missing or broken, but if it is be sure to tweet @PebbleDev on Twitter or find me in our Discord group.