Membuat layanan tampilan jam

Tampilan jam adalah layanan yang dikemas dalam aplikasi Wear OS. Saat pengguna memilih tampilan jam yang tersedia, tampilan jam tersebut ditampilkan dan metode callback layanan dipanggil.

Setelah pengguna menginstal aplikasi Wear OS yang memiliki tampilan jam, tampilan jam tersebut dapat diakses di jam tangan melalui pemilih tampilan jam. Atau, pengguna dapat memilih tampilan jam dari aplikasi pendamping di ponsel yang tersambung.

Halaman ini menjelaskan cara mengonfigurasi project Wear OS agar menyertakan tampilan jam dan cara mengimplementasikan layanan tampilan jam.

Membuat project tampilan jam

Untuk membuat project tampilan jam di Android Studio:

  1. Klik File > New > New project.
  2. Di jendela Create Project Android, terima nilai default, lalu klik Next.
  3. Di jendela Target Android Devices, pilih hanya opsi Wear, dan pada daftar versi SDK, pilih versi terbaru yang tersedia. Klik Next.
  4. Di jendela Add an Activity to Wear, pilih Watch Face, lalu klik Next.
  5. Di jendela Configure Activity, terima nilai default, lalu klik Finish.

Android Studio membuat project dengan modul app untuk layanan tampilan jam. Untuk informasi lebih lanjut tentang project di Android Studio, lihat Membuat Project.

Dependensi

Wearable Support Library menyediakan class yang diperlukan, yang dapat diperluas untuk membuat implementasi tampilan jam. Library klien layanan Google Play (play-services dan play-services-wearable) diperlukan untuk menyinkronkan item data antara perangkat pendamping dan perangkat wearable dengan API Lapisan Data Wearable.

Android Studio otomatis menambahkan entri yang diperlukan dalam file build.gradle ketika Anda membuat project sesuai instruksi di atas.

Referensi Wearable Support Library API

Dokumentasi referensi memberikan informasi mendetail tentang class yang digunakan untuk mengimplementasikan tampilan jam. Pelajari dokumentasi referensi API untuk Wearable Support Library.

Catatan: Kami merekomendasikan penggunaan Android Studio untuk pengembangan Wear OS karena program tersebut menyediakan penyiapan project, penyertaan library, dan kemudahan pengemasan.

Mendeklarasikan izin

Tampilan jam memerlukan izin WAKE_LOCK. Tambahkan izin berikut ke file manifes aplikasi Wear OS (aplikasi wearable) dan aplikasi seluler (ponsel) pada elemen manifest:

    <manifest ...>
        <uses-permission
            android:name="android.permission.WAKE_LOCK" />

        <!-- Required for complications to receive complication data and open the provider chooser. -->
        <uses-permission
            android:name="com.google.android.wearable.permission.RECEIVE_COMPLICATION_DATA"/>
        ...
    </manifest>
    

Perhatian: Aplikasi genggam harus menyertakan semua izin yang dideklarasikan dalam aplikasi wearable.

Mengimplementasikan metode layanan dan callback

Tampilan jam di Wear OS diimplementasikan sebagai layanan. Jika tampilan jam aktif, sistem akan memanggil metode dalam layanannya saat waktu berubah atau peristiwa penting terjadi (seperti beralih ke mode standby atau menerima notifikasi baru). Implementasi layanan ini kemudian menggambar tampilan jam di layar menggunakan waktu yang diperbarui dan data relevan lainnya.

Untuk mengimplementasikan tampilan jam, Anda perlu memperluas class CanvasWatchFaceService dan CanvasWatchFaceService.Engine, kemudian mengganti metode callback dalam class CanvasWatchFaceService.Engine. Semua class tersebut disertakan dalam Wearable Support Library.

Cuplikan berikut menguraikan secara singkat metode utama yang perlu Anda implementasikan:

Kotlin

    class AnalogWatchFaceService : CanvasWatchFaceService() {

        override fun onCreateEngine(): Engine {
            /* provide your watch face implementation */
            return Engine()
        }

        /* implement service callback methods */
        inner class Engine : CanvasWatchFaceService.Engine() {

            override fun onCreate(holder: SurfaceHolder) {
                super.onCreate(holder)
                /* initialize your watch face */
            }

            override fun onPropertiesChanged(properties: Bundle?) {
                super.onPropertiesChanged(properties)
                /* get device features (burn-in, low-bit ambient) */
            }

            override fun onTimeTick() {
                super.onTimeTick()
                /* the time changed */
            }

            override fun onAmbientModeChanged(inAmbientMode: Boolean) {
                super.onAmbientModeChanged(inAmbientMode)
                /* the wearable switched between modes */
            }

            override fun onDraw(canvas: Canvas, bounds: Rect) {
                /* draw your watch face */
            }

            override fun onVisibilityChanged(visible: Boolean) {
                super.onVisibilityChanged(visible)
                /* the watch face became visible or invisible */
            }
        }
    }
    

Java

    public class AnalogWatchFaceService extends CanvasWatchFaceService {

        @Override
        public Engine onCreateEngine() {
            /* provide your watch face implementation */
            return new Engine();
        }

        /* implement service callback methods */
        private class Engine extends CanvasWatchFaceService.Engine {

            @Override
            public void onCreate(SurfaceHolder holder) {
                super.onCreate(holder);
                /* initialize your watch face */
            }

            @Override
            public void onPropertiesChanged(Bundle properties) {
                super.onPropertiesChanged(properties);
                /* get device features (burn-in, low-bit ambient) */
            }

            @Override
            public void onTimeTick() {
                super.onTimeTick();
                /* the time changed */
            }

            @Override
            public void onAmbientModeChanged(boolean inAmbientMode) {
                super.onAmbientModeChanged(inAmbientMode);
                /* the wearable switched between modes */
            }

            @Override
            public void onDraw(Canvas canvas, Rect bounds) {
                /* draw your watch face */
            }

            @Override
            public void onVisibilityChanged(boolean visible) {
                super.onVisibilityChanged(visible);
                /* the watch face became visible or invisible */
            }
        }
    }
    

Class CanvasWatchFaceService menyediakan mekanisme pembatalan validasi yang mirip dengan metode View.invalidate(). Metode invalidate() dapat dipanggil selama implementasi ketika Anda ingin sistem menggambar ulang tampilan jam. Anda hanya dapat menggunakan metode invalidate() di thread UI utama. Untuk membatalkan validasi kanvas dari thread lain, panggil metode postInvalidate().

Untuk informasi selengkapnya tentang implementasi metode dalam class CanvasWatchFaceService.Engine, lihat Menggambar Tampilan Jam.

Mendaftarkan layanan tampilan jam

Setelah mengimplementasikan layanan tampilan jam, selanjutnya Anda perlu mendaftarkan implementasi tersebut dalam file manifes aplikasi wearable. Setelah pengguna menginstal aplikasi, sistem akan menggunakan informasi layanan tersebut untuk menyediakan tampilan jam di aplikasi pendamping Wear OS dan di pemilih tampilan jam pada perangkat wearable.

Cuplikan berikut menunjukkan cara mendaftarkan implementasi tampilan jam pada elemen application:

    <service
        android:name=".AnalogWatchFaceService"
        android:label="@string/analog_name"
        android:permission="android.permission.BIND_WALLPAPER" >
        <meta-data
            android:name="android.service.wallpaper"
            android:resource="@xml/watch_face" />
        <meta-data
            android:name="com.google.android.wearable.watchface.preview"
            android:resource="@drawable/preview_analog" />
        <meta-data
            android:name="com.google.android.wearable.watchface.preview_circular"
            android:resource="@drawable/preview_analog_circular" />
        <intent-filter>
            <action android:name="android.service.wallpaper.WallpaperService" />
            <category
                android:name=
                "com.google.android.wearable.watchface.category.WATCH_FACE" />
        </intent-filter>
    </service>
    

Aplikasi pendamping Wear OS dan pemilih tampilan jam di perangkat wearable menggunakan gambar pratinjau yang ditetapkan oleh entri metadata com.google.android.wearable.watchface.preview ketika menyajikan semua tampilan jam yang terinstal di perangkat kepada pengguna. Untuk mendapatkan gambar pratinjau ini, jalankan tampilan jam pada perangkat Wear OS atau instance emulator, lalu ambil screenshot. Pada perangkat Wear OS dengan layar hdpi, gambar pratinjau biasanya berukuran 320x320 piksel.

Tampilan jam yang terlihat cukup berbeda pada perangkat berlayar bundar dapat menampilkan gambar pratinjau bulat dan juga persegi. Untuk menentukan gambar pratinjau bundar, gunakan entri metadata com.google.android.wearable.watchface.preview_circular. Jika tampilan jam menyertakan kedua jenis gambar pratinjau, aplikasi pendamping dan pemilih tampilan jam pada perangkat wearable akan menampilkan gambar yang sesuai, tergantung bentuk jam tangannya. Jika gambar pratinjau bundar tidak disertakan, gambar pratinjau persegi akan digunakan baik pada perangkat layar persegi maupun bundar. Untuk perangkat layar bundar, gambar pratinjau persegi akan di-crop menggunakan bentuk melingkar.

Entri metadata android.service.wallpaper menentukan file resource watch_face.xml, yang berisi elemen wallpaper:

    <?xml version="1.0" encoding="UTF-8"?>
    <wallpaper xmlns:android="http://schemas.android.com/apk/res/android" />
    

Aplikasi wearable Anda dapat memuat lebih dari satu tampilan jam. Untuk setiap implementasi tampilan jam, Anda harus menambahkan entri layanan ke file manifes aplikasi wearable.