We may earn an affiliate commission when you visit our partners.
Barry Michael Doyle

This course teaches you how to build your own custom Fitbit Ionic Clock Faces from scratch all the way through to deploying it on the Fitbit App Gallery.

It is suitable for beginner developers with no prior knowledge of JavaScript, however a background in web development is certainly beneficial.

Basic knowledge of

The course instructor Barry Michael Doyle will also provide support and aid where possible to help you if you get stuck.

It all begins here.

Enroll now

What's inside

Learning objectives

  • Build custom fitbit ionic smart watch clock faces
  • Display time, date, day etc.
  • Get and display steps, floors climbed, distance travelled
  • Monitor and display heart rate
  • Monitor battery charge state and draw svg elements based on value
  • Publish clock face on the fitbit app gallery

Syllabus

Have expectations for the course set with the final goal in sight. Have Fitbit developer account created for getting started in the next section.
Read more

A quick introduction for students to get to know Barry and grab a quick overview of what the course consists of.

An explanation for what we're aiming to build. Developing is always easier when you have the end in mind.

Set Up Fitbit Developer Account

After completing this lecture, students will be able to start a new project and run a project on their Ionic.

After completing this section, students will be able to display all the time features such as Time, Date and Day. Students will also have a basic understanding of how to style clock face elements.

An attempt to explain the functionality of all the code in the clock face code template.

NB: In this section, if you test your app at the end, the time will not show. I resolve this problem instantly in the next video lecture!

A link to Fitbit's official documentation on Application Structure

In this video you're taught how to draw an arc around the time display.

In this video we divide the circle arc into two halves so that we can draw the battery charge level indication with it later.

Link to useful docs on arcs and other SVG components.

In this video we show you how to get the date and day text elements correctly displayed on the screen. The next video takes care of setting the values to the correct date and day.

In this video we clean up the code (also known as refactoring) so that it will be easier to add more features later.

This video ties of the section of getting a working clock face out there. It now shows Time, Date and Day of the week.

At the end of this section. Students will be able to display stats on their clock face. They'll learn how to add icons and values for floors, steps, distance and heart rate.

Some notes regarding downloading the icons folder.

In this video we add icons to our project folder so that we can make use of them in the next lecture.

In this lecture you'll learn how to display images on your clock face.

In this video we add the statistic labels where you'll also learn how to rotate elements in your GUI document.

In this video we add in user permission request so that we can access the daily floors and steps values for display purposes.

Here's the link to the docs regarding user-activity: https://dev.fitbit.com/build/reference/device-api/user-activity/


In this lecture we display the distance in kilometers or miles. We'll build a util function to calculate the distance to display based on whether you want to show kilometers or miles.

Here's the code for the round function:

export function round(x, n) {
  return parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n);
}

x is the value you want to round and n is the precision (i.e. the number of decimal places you want to round to). 

In this lecture we set up the Heart Rate Monitor and update the display on every Heart Rate reading.

The documentation for the Heart Rate Sensor can be found here: https://dev.fitbit.com/build/reference/device-api/heart-rate/

In this section students learn how to really manipulate the clock face graphics based off of real time state (in this case the battery charge). It even includes a little animation.

In this video we change the color of the arc based off of the battery charge state.

The documentation for the power API can be found here: https://dev.fitbit.com/build/reference/device-api/power/

In this lecture we draw the arc lengths based off the current battery charge state.

We add a little Easter egg in this lecture that lets our arc spin around whenever we click on it.

If you'd like to experiment further in animations, be sure to consult the docs on animations over here: https://dev.fitbit.com/build/guides/user-interface/animations/

Students will learn how to publish their clock faces here and find out where else they can find me out on social media and other channels.

We end off the course by learning how to publish our completed clock face.

Head over to https://gam.fitbit.com to publish your clock faces.

Some final notes to end off with.

Save this course

Save Create Fitbit Ionic Clock Faces using JavaScript to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Create Fitbit Ionic Clock Faces using JavaScript with these activities:
Review JavaScript Fundamentals
Solidify your understanding of JavaScript fundamentals to better grasp the concepts used in building Fitbit clock faces.
Browse courses on JavaScript Fundamentals
Show steps
  • Review variables, data types, and operators.
  • Practice control flow statements (if/else, loops).
  • Familiarize yourself with functions and objects.
Eloquent JavaScript, 3rd Edition
Gain a deeper understanding of JavaScript concepts and best practices to enhance your Fitbit clock face development skills.
View Melania on Amazon
Show steps
  • Read the chapters on data structures and functions.
  • Work through the exercises at the end of each chapter.
  • Apply the concepts learned to your Fitbit clock face project.
Create a Simple Mock Clock Face
Practice the basic concepts of displaying time and date on a simple clock face before diving into the full Fitbit project.
Show steps
  • Set up a basic HTML and JavaScript environment.
  • Display the current time and date using JavaScript.
  • Style the clock face using CSS.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Follow SVG Tutorials
Learn how to create and manipulate SVG elements, which are essential for drawing custom graphics on Fitbit clock faces.
Show steps
  • Find online tutorials on SVG basics.
  • Practice creating simple shapes and paths.
  • Experiment with SVG animations and transformations.
Document Your Learning Journey
Reinforce your understanding by documenting your progress, challenges, and solutions while building Fitbit clock faces.
Show steps
  • Create a blog or journal to record your learning.
  • Summarize key concepts and techniques learned.
  • Share your insights and code snippets with others.
Contribute to a Fitbit Clock Face Project
Gain experience by contributing to an existing open-source Fitbit clock face project on platforms like GitHub.
Show steps
  • Find an open-source Fitbit clock face project.
  • Identify a bug or feature to work on.
  • Submit a pull request with your changes.
Fitbit's API Documentation
Deepen your understanding of the Fitbit API and its capabilities to create more advanced and feature-rich clock faces.
Show steps
  • Explore the documentation for the User API.
  • Understand the data structures returned by the API.
  • Experiment with different API calls in your clock face.

Career center

Learners who complete Create Fitbit Ionic Clock Faces using JavaScript will develop knowledge and skills that may be useful to these careers:
Wearable App Developer
A wearable app developer focuses on creating applications specifically for wearable devices. As a wearable app developer, you would contribute to the growing market of smartwatches and fitness trackers. This course helps build a foundation for developing custom applications, starting with Fitbit Ionic Clock Faces. You'll learn how to display real-time data such as time, date, steps, heart rate, and battery charge, skills directly applicable to wearable app development. The course culminates in publishing your creation on the Fitbit App Gallery, providing practical experience in the entire app development lifecycle.
JavaScript Developer
JavaScript developers use JavaScript to create interactive web pages and applications. As a JavaScript developer, you can apply your existing skills to the development of applications for wearable devices. This course helps you to apply your JavaScript abilities to the Fitbit Ionic platform. The curriculum focuses on using JavaScript to control the display of time, date, sensor data, and battery status on the clock face. You will gain experience working with the Fitbit API and deploying applications to the Fitbit App Gallery.
Application Developer
Application developers create software applications for a variety of platforms. As an application developer, you can develop applications for wearable devices, such as the Fitbit Ionic. This course helps focus your application development skills specifically on the Fitbit Ionic platform. The course covers the entire application development lifecycle, from setting up the development environment to building the user interface, accessing sensor data, and deploying the application to the Fitbit App Gallery.
Mobile Application Developer
Mobile application developers create applications for mobile devices. As a mobile application developer, this encompasses a wide range of platforms and devices, including smartwatches. This course helps build your skills in developing for a specific wearable platform, Fitbit Ionic. The knowledge gained in building custom clock faces, displaying real-time data, and optimizing for battery life translates to mobile app development. Publishing the clock face provides experience in the app store submission process.
IoT Developer
Internet of things developers create software for connected devices. As an Internet of things developer, you would connect wearables into a wider network of connected devices and systems. This course may be useful because it will familiarize you with developing for a wearable device, the Fitbit Ionic. You'll gain insight into how to access and process sensor data, manage device resources, and deploy applications to a device. These skills translate into IOT development, where resource constraints and real-time data processing are common.
Software Engineer
A software engineer designs, develops, tests, and deploys software systems. As a software engineer, you might work on applications for a variety of platforms. This course may be useful to build your skills in developing for a specific platform, Fitbit Ionic. The course covers the process of creating a working application, from initial setup to deployment, and touches upon key software engineering principles like code refactoring. Learning to manage device constraints, such as battery life, is also valuable.
Front-End Developer
Front end developers specialize in the user-facing aspects of software applications. As a front end developer, you would focus on creating appealing and functional interfaces. This course may be useful in providing experience in front end development for a wearable device, the Fitbit Ionic. You will learn how to style elements, draw graphics, and implement animations, all within the constraints of a wearable platform. The course provides hands-on experience, culminating in the publication of a clock face.
Embedded Systems Programmer
An embedded systems programmer writes code for devices with dedicated functions. As an embedded systems programmer, you would develop applications for various devices, including wearables. This course may be useful by teaching you practical skills in programming for a specific embedded environment, the Fitbit Ionic. The course's focus on displaying real-time data from sensors and managing battery consumption provides valuable insights into the constraints and challenges of embedded systems programming. Furthermore, the experience of deploying an application to a device is directly relevant.
Software Development Engineer in Test
Software development engineers in test are responsible for ensuring the quality of software through testing. As a software development engineer in test, you might test applications across various platforms, including wearables. This course may be useful by providing an understanding of the development process for Fitbit Ionic Clock Faces. Knowing how these applications are built, how they interact with sensors, and how they are deployed assists in developing effective test strategies. Understanding the challenges of wearable development, such as battery life and display limitations, is also helpful.
Full-Stack Developer
A full stack developer works on both the front end and back end of software applications. As a full stack developer, you may work on the front end portion of an application. This course may be useful by exposing you to aspects of front end development for a wearable platform. You'll learn how to create user interfaces, display data, and interact with device sensors on the Fitbit Ionic. This experience can complement your full stack skillset by providing a new perspective on front end development in a constrained environment.
UI/UX Designer
UI/UX designers focus on the user experience of software applications. As a UI/UX Designer, you would learn about the principles of good design through practical application. This course may be useful to designers looking to explore wearable interfaces. The course involves designing clock faces for the Fitbit Ionic, which includes considerations for usability, information display, and visual appeal within the constraints of a small screen. You'll gain insights into how users interact with wearable devices and how to optimize the user experience.
User Interface Engineer
A user Interface engineer focuses on the visual elements that users interact with. As a user interface engineer, you would focus on creating intuitive and visually appealing interfaces for various applications, including those on wearable devices. This course may be useful because it provides hands-on experience in designing and implementing user interfaces for Fitbit Ionic Clock Faces. The course curriculum covers styling clock face elements, drawing arcs, displaying images, and incorporating animations, all of which will build your skillset in UI development for wearables.
Software Architect
Software architects are responsible for designing the overall structure of software systems. As a software architect, you could benefit from understanding the nuances of wearable application development. This course may be useful by providing insights into the architecture of Fitbit Ionic Clock Faces. While the scope is narrow, the course touches on aspects of system design, such as managing real-time data, optimizing for battery life, and interacting with device sensors. Understanding these architectural considerations informs the design of larger wearable applications.
Firmware Engineer
Firmware engineers develop the low-level software that controls hardware devices. As a firmware engineer, you would work on the software that directly interacts with the hardware of devices. This course may be useful because, while not directly related to firmware development, the course will give you insights into how applications interact with the hardware and sensors of the Fitbit Ionic. Knowledge of the device API and the constraints of wearable platforms helps understand the system-level considerations relevant to firmware development.
Technical Writer
A technical writer creates documentation for software and hardware products. As a technical writer, you could document APIs, SDKs, and development tools for wearable platforms. This course may be useful by giving hands-on experience developing for the Fitbit Ionic. This will give insights into the developer experience, the challenges faced, and the functionalities available. All of this will help you write more effective documentation for other developers.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Create Fitbit Ionic Clock Faces using JavaScript.
This is the official documentation for the Fitbit API. It contains detailed information on all the available endpoints, data structures, and authentication methods. It is an essential resource for any developer working with the Fitbit platform. This documentation adds breadth to the course by providing the most up-to-date information on the Fitbit API.
Provides a comprehensive introduction to JavaScript programming. It covers the core language features, including data structures, functions, and object-oriented programming. It is particularly useful for those with some programming experience but new to JavaScript. This book adds depth to the course by providing a solid foundation in JavaScript, which is essential for creating custom Fitbit clock faces.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser