Packaging Wearable Apps

When publishing to users, you must package a wearable app inside of a handheld app, because users cannot browse and install apps directly on the wearable. If packaged properly, when users download the handheld app, the system automatically pushes the wearable app to the paired wearable.

Note: This feature doesn't work when you are signing your apps with a debug key when developing. While developing, installing apps with adb install or Android Studio directly to the wearable is required.

Package with Android Studio

To properly package a wearable app in Android Studio:

  1. Declare a Gradle dependency in the handheld app's build.gradle file that points to the wearable app module:
    dependencies {
       compile ''
       compile '''
       wearApp project(':wearable')
  2. Click Build > Generate Signed APK... and follow the on-screen instructions to specify your release keystore and sign your app. Android Studio exports the signed handheld app with the wearable app embedded in it automatically into your project's root folder.

    Alternatively, you can create a signingConfig rule in the wearable and handheld modules' build.gradle file to sign them with your release key. Both apps must be signed to have the automatic pushing of the wearable app work.

    android {
      signingConfigs {
        release {
          keyAlias 'myAlias'
          keyPassword 'myPw'
          storeFile file('path/to/release.keystore')
          storePassword 'myPw'
      buildTypes {
        release {
          signingConfig signingConfigs.release

    Build the handheld app by clicking the Gradle button on the right vertical toolbar of Android Studio and running the assembleRelease task. The task is located under Project name > Handheld module name > assembleRelease.

    Note:This example embeds the password in your Gradle file, which might be undesirable. See Configure signing settings for information about how to create an environment variable for the passwords instead.

Signing the wearable and handheld app separately

If your build process requires signing the wearable app separately from the handheld app, you can declare the following Gradle rule in the handheld module's build.gradle to embed the previously-signed wearable app:

dependencies {
  wearApp files('/path/to/wearable_app.apk')

You then sign your handheld app in any manner you wish (either with the Android Studio Build > Generate Signed APK... menu item or with Gradle signingConfig rules as described in the previous section.

Package Manually

It's still possible to package the wearable app into the handheld app manually if you are using another IDE or another method of building.

  1. Copy the signed wearable app to your handheld project's res/raw directory. We'll refer to the APK as wearable_app.apk.
  2. Create a res/xml/wearable_app_desc.xml file that contains the version and path information of the wearable app. For example:
    <wearableApp package="">

    The package, versionCode, and versionName are the same values specified in the wearable app's AndroidManifest.xml file. The rawPathResId is the static variable name of the APK resource. For example, for wearable_app.apk, the static variable name is wearable_app.

  3. Add a meta-data tag to your handheld app's <application> tag to reference the wearable_app_desc.xml file.
      <meta-data android:name="" 
  4. Build and sign the handheld app.

Turn off Asset Compression

Many build tools automatically compress any files added to the res/raw directory of an Android app. Because the wearable APK is already zipped, these tools re-compress the wearable APK and the wearable app installer can no longer read the wearable app.

When this happens, the installation fails. On the handheld app, the PackageUpdateService logs the following error: "this file cannot be opened as a file descriptor; it is probably compressed."

Android Studio doesn't compress your APK by default, but if you are using another build process, ensure that you don't doubly compress the wearable app.