Month: February 2022
Creating Your Wearable Fitness App: Tips and Best Practices
Why wearables?
Holding your phone or putting it in your pocket while running isn’t very convenient. Swimming with it is nearly impossible. Though smartphones are also capable of counting your steps and tracking your location, they lack many other useful capabilities like heart rate monitoring and exercise detection.
Wearables like smartwatches sit comfortably on your wrist and don’t interfere with your activities. Moreover, they make it easier to see the information you need. You don’t have to take out your phone to check on your exercise progress.
Among all types of wearables, smartwatches and wristbands are the absolute leaders.
Interesting features and convenience have made wearables popular. As you can see in this chart, the number of wearables has grown each year since 2016, and this tendency isn’t likely to stop.
Among all types of wearables, smartwatches and wristbands are the absolute leaders. Statista also states that by 2022 over 1 billion wearable devices will be sold in the world. North America is forecast to be the region using the most wearable devices in 2022. The 439 million connections in North America would be 222 million more than in 2017. Wearables used in North America and Asia Pacific are together forecast to account for around 70% of the wearable device sales worldwide in 2022.
While wearables like smartwatches are used for activity and sleep tracking, they are also becoming more important in the healthcare industry. For example, in 2017 Apple launched the Heart Study App that allows the Apple Watch to identify irregular heart rhythms and collect data. This app may help to identify early signs of stroke and warn users.
Wearables are becoming something more than devices for sports fans. They’re getting more advanced and multifunctional, which makes them a great help when it comes to healthcare.
The number of apps for wearables is also growing. In this article we’ll talk about the best wearables and apps for them on the market, focusing on smartwatches. After giving you some tips on developing apps for android wear, we will give you some examples of wearables and apps for them that already exist.
Wearables statistics
The global wearables market reached a new high of 84.5 million devices, up 94.6% from the prior year, during the third quarter of 2019 (3Q19) according to new data from the International Data Corporation (IDC) Worldwide Quarterly Wearable Device Tracker. The wristband category grew 16.2% during the quarter. Meanwhile, hearables grew 68.3% and accounted for 54.9% of the entire market.
The spread of COVID-19 also had adverse effects on the supply of smart watches as many of these devices share components and resources with smartphones and PCs, which were also impacted during the first quarter of 2020.
How to Make an Android Wear App
This is an instruction on how to make an Android Wear application.
1. The first thing you’ll need to do before starting developing an Android Wear app is create a watch emulator. After it’s launched in a cold boot mode, connect the smartphone via USB, as you won’t be able to connect it to the smartphone emulator, according to official documentation.
2. Install an Android Wear companion app to prepare the smartphone. Now you’ll need to connect it to smartwatches. Use an adb devices command to make sure that both devices are recognized and connected.
3. Use the adb -d forward tcp:5601 tcp:5601 command to connect them. You’ll need to use it each time you connect smartwatches.
4. Launch the application and pair it with the emulator as shown here:
5. After the connection is established, you can start creating your project.
Don’t forget to put a check into a Wear checkbox to indicate that the project will include the wearable app.
Note, that Android Wear works only with API 23 and over. In your new project you’ll see a smartphone model and smartwatches modules. Each of them has its own gradle file.
Mobile module:
6. Choose the module of a smartwatch app and launch it.
7. Next step is to set an app for a mobile phone. Add a layout to the activity_main.xml file.
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.example.user.testwatchapp.MainActivity">
<Button
android:id="@+id/btn_send"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginEnd="8dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:text="Send notification"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/edt_message" />
<EditText
android:id="@+id/edt_message"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginEnd="8dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:ems="10"
android:inputType="textPersonName"
android:hint="Massage"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</android.support.constraint.ConstraintLayout>
8. You’ll need to add this code to the MainActivity class.
public class MainActivity extends Activity {
Button send;
EditText message;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
send = (Button) findViewById(R.id.btn_send);
message = (EditText) findViewById(R.id.edt_message);
send.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
sendNotification(message.getText().toString());
}
});
}
public void sendNotification(String message) {
if (message.isEmpty())
message = "You sent an empty notification";
Notification notification = new NotificationCompat.Builder(getApplication())
.setSmallIcon(R.mipmap.ic_launcher)
.setContentTitle("Test Notification")
.setContentText(message)
.extend(new NotificationCompat.WearableExtender().setHintShowBackgroundOnly(true))
.build();
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(getApplication());
int notificationId = 1;
notificationManager.notify(notificationId, notification);
}
}
Watch module:
9. To make notifications appear on the smartwatches screen, you need to specify the extent parameter in NotificationCompat.Builder. Launch the app to get this result:
10. Now it’s time to set the application for smartwatches. Add this layout to the activity_main.xml file:
<android.support.wear.widget.BoxInsetLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/dark_grey"
tools:context="com.example.user.testwatchapp.MainActivity"
tools:deviceIds="wear">
<FrameLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_gravity = "center"
app:boxedEdges="all">
<TextView
android:id="@+id/textView"
android:layout_gravity = "center"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hi!"/>
</FrameLayout>
</android.support.wear.widget.BoxInsetLayout>
In this code you can see BoxInsetLayout. BoxInsetLayout is a screen shape-aware FrameLayout, that can box its children in the center square of a round screen by using the layout_box attribute.
11. Add this code to the MainActivity:
public class MainActivity extends WearableActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
setAmbientEnabled();
}
}
After you launch an app, you’ll see this:
12. Finally, it’s time to test your application. Install the application on your smartphone and smartwatches and send a message.
As you can see, after you send a message, it will appear in smartwatches notifications.
Now you have a basic application you can add your features into!
Things to consider when building your own wearable app
You should include some features typically found in mobile fitness apps when you create an Android wear app. They include GPS navigation, system of motivation, instructions if needed and other details.
Modern smartwatches have lots of sensors, from standard accelerometers and GPS modules to heart rate sensors. Use their capabilities to make your app comprehensive and universal, so that a user can have a calorie counter and a personal trainer in one place.
Features for your workout app should include:
Great UI/UX
Developing a mobile app is pretty similar to Android app development for wearables; the main difference is in the design. Make sure that you can fit the most important information on the small screen of a smartwatch.
The Android developer community recommends to use 2D Picker – it is a UI design pattern that allows a user to choose from a specific list of items.
You can use your custom layout as well, but make sure that it’s comfortable for your users.
Information has to be clear and visible, and when it comes to smartwatches, less is more. You’ll notice that many fitness apps for wearables have a simple design with minimal colors. Usually these colors contrast with the screen so they can be seen better.
But you can find bright designs, too. For example, Apple Activity is colorful yet simple.
The interface of a smartwatch app has to be really simple and responsive so that users aren’t distracted or irritated during their workouts.
Notifications
There are two types of notifications in wearable applications: bridge notifications and contextual ones. What’s the difference?
Bridge notifications come from a user’s smartphone. It means, that these are standard Android notifications, that are displayed on a wearable device. Bridge notifications are closely connected to smartphone’s features, and they usually include calls, SMS, etc.
Contextual notifications come from the wearable and they are independent from a smartphone. They usually include the information that comes from the wearable’s sensors, for example, when a user should rest, how many steps were walked and so on.
Notifications that pop up on smartwatch screens are different than those you usually see on your smartphone. They need to be more compact, containing one word or some sort of indicator, such as a color, to let your users know what’s happening.
Cloud technology
Smartwatch hardware doesn’t allow you to store a lot of information, which is why cloud technology is very important for synchronizing your devices and sending data. And don’t forget about security – all sensitive user data needs to be protected.
Battery issues
Battery life of a wearable device is one of the biggest challenges for developers. Its’ critical that your development team is aware of potential issues with a battery life, and that you work with efficient technologies that perform well and don’t eat the charge too fast. Invest into building battery-saving features in your wearable app, otherwise it won’t be able to stand the competition.
Security and privacy
Wearable devices can become a convenient entry point for hackers because of their constant connection to the internet, so you need to design your apps with security in mind. Your users’ private data can also be visible on a display, so it’s important to build such UI that will prevent other people from seeing private conversations or sensitive data on a user’s screen. For example, you can warn a user about an incoming notification by making the smart watch vibrate before displaying the notification.
Functionality
Though your application should be minimalistic, it’s important to still add valuable functionality on top of what’s expected. For example, a wearable sleep app should not only show how many hours a user has slept, but also give recommendations on their sleeping routine and remind a user to go for a walk or turn off the screens before sleep. Make your app’s functinality personal and make suggestions based on your users’ habits.
Connection with devices and platforms
It can be hard to adapt your wearable application to multiple devices, because they often have different operating systems that don’t allow a cross-platform approach. However, wearables are paired with mobile devcies, and it’s important to never develop a wearable app in isolation to a smartphone that it will be paired with. Make sure that your wearable app handles different tasks from a smartphone app: for example, while a wearable app collects data about the heart rate, a smaprtphone analyses that data and provides recommendations.
One final tip for Android wearable development: make it with the Chinese market in mind. By 2021, China will account for one-third of all wearables sales, and fitness apps are really popular there. You have the opportunity to enter a market with several billion people, increasing your potential audience.
What can wearable apps track?
Wearable applications can track health parameters of their users depending on what the hardware allows, meaning that the wearable device you build your app for should have certain sensors. The list of what applications can usually track is this:
- distance covered
- elevation
- speed
- calories burned
- heart rate
- location
- blood pressure
- sleep
Some advanced wearables can also track:
- blood oxygen
- sweat level
- stress level
Apps for Smartwatches and Trackers
There are many applications for smartwatches. Some of them are specific to a certain operating system or watch type, for example Apple Watch Activity and Google Fit. However, you can find other third-party apps for your smart watch.
Smartwatches have their own operating systems. Apple has WatchOS and Android has Android Wear. Most third-party apps support both platforms and can also include APIs of other manufacturers that allow you to use them with fitness wristbands.
Below, we’ll give you some Apple and Android wear app examples that are already on the market.
1. Strava
Strava is one of the most popular fitness apps and works both on smartwatches and mobile devices. There’s also an independent Strava application for smartwatches that can work without connecting to a smartphone.
2. Runkeeper
Runkeeper supports Apple Watch and Android Wear devices. Like Strava, Runkeeper has built-in GPS and can work independently on your wearable without having to connect to your phone.
3. Zombies, run!
This app is creative – it turns a usual jog into a quest with great storytelling in The Walking Dead style. A beautiful park where you like jogging will immediately become a battlefield in a postapocalyptic world with this app. You’ll need to run for your life, otherwise the zombies will be glad to eat you. Run, set challenges and listen to engaging music and become a hero of a great story.
4. 7 Minute Workout Training Challenge
This app is designed for people with packed schedules who can hardly find time to work out. 7 Minute Workout Challenge helps you keep fit in only seven minutes a day. It supports both Apple Watch and Android Wear.
5. FitStar Yoga
This application is designed for relaxed yoga sessions. It tells you how long to hold each position and how many calories you’ve burned during each training. It also uses your feedback to tailor exercises for a better yoga experience, so you can become a creator of your own yoga sessions.
As you can see, there are countless ideas for fitness apps. The growing market for fitness apps provides opportunities for creating new software for wearables. Now we’ll talk about the must-have features for wearable applications.
Final Thoughts
Healthcare and fitness are two of the fastest-growing markets in the world. If you develop an Android wear app, that’s a great start. The next thing you should do is find the right development team that will be able to bring your idea to life.
At Mobindustry, we build smartwatch apps for android and will gladly develop and support your application. Contact us for more information or advice on how to make a successful wearable fitness app.
Article written by:
Vladislav Mykhalyk
