Mentransfer aset di Wear

Untuk mengirim blob data biner yang besar melalui pengiriman Bluetooth, seperti gambar, Anda dapat melampirkan Asset ke item data dan memasukkan item data tersebut ke data store yang direplikasi.

Catatan: Meskipun aplikasi Wear dapat berkomunikasi dengan aplikasi ponsel menggunakan Data Layer API yang direferensikan di bawah ini, menghubungkan ke jaringan menggunakan API ini tidak disarankan.

Aset secara otomatis menangani caching data untuk mencegah transmisi ulang dan menghemat bandwidth Bluetooth. Pola umum ditujukan bagi aplikasi perangkat genggam untuk mendownload gambar, memperkecil ke ukuran yang sesuai untuk tampilan di perangkat wearable, dan mentransmisikan ke perangkat wearable sebagai aset. Contoh berikut mendemonstrasikan pola tersebut.

Catatan: Meskipun ukuran item data terbatas hingga 100 KB, ukuran aset dapat sebesar yang diinginkan. Namun, mentransfer aset besar akan memengaruhi pengalaman pengguna dalam banyak kasus, jadi sebaiknya uji aplikasi Anda untuk memastikan transfer tersebut berjalan baik ketika Anda mentransfer aset besar.

Mentransfer aset

Buat aset menggunakan salah satu metode create...() dalam class Asset. Berikut ini, kami akan mengonversi bitmap ke aliran byte, lalu memanggil createFromBytes() untuk membuat aset.

    private fun createAssetFromBitmap(bitmap: Bitmap): Asset =
        ByteArrayOutputStream().let { byteStream ->
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream)
            Asset.createFromBytes(byteStream.toByteArray())
        }
    

    private static Asset createAssetFromBitmap(Bitmap bitmap) {
        final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream);
        return Asset.createFromBytes(byteStream.toByteArray());
    }
    

Saat Anda memiliki aset, lampirkan aset tersebut ke item data dengan metode putAsset() di DataMap atau PutDataRequest, lalu masukkan item data tersebut ke dalam data store dengan putDataItem():

Menggunakan PutDataRequest

    val asset: Asset = BitmapFactory.decodeResource(resources, R.drawable.image).let { bitmap ->
        createAssetFromBitmap(bitmap)
    }
    val request: PutDataRequest = PutDataRequest.create("/image").apply {
        putAsset("profileImage", asset)
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(context).putDataItem(request)
    

    Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
    Asset asset = createAssetFromBitmap(bitmap);
    PutDataRequest request = PutDataRequest.create("/image");
    request.putAsset("profileImage", asset);
    Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);
    

Menggunakan PutDataMapRequest

    val asset: Asset = BitmapFactory.decodeResource(resources, R.drawable.image).let { bitmap ->
        createAssetFromBitmap(bitmap)
    }
    val request: PutDataRequest = PutDataMapRequest.create("/image").run {
        dataMap.putAsset("profileImage", asset)
        asPutDataRequest()
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(context).putDataItem(request)
    

    Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
    Asset asset = createAssetFromBitmap(bitmap);
    PutDataMapRequest dataMap = PutDataMapRequest.create("/image");
    dataMap.getDataMap().putAsset("profileImage", asset);
    PutDataRequest request = dataMap.asPutDataRequest();
    Task<DataItem> putTask = Wearable.getDataClient(context).putDataItem(request);
    

Menerima aset

Ketika aset dibuat, Anda mungkin ingin membaca dan mengekstraknya di sisi lain koneksi. Berikut adalah contoh cara menerapkan callback untuk mendeteksi perubahan aset dan mengekstrak aset:

    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents
                .filter { it.type == DataEvent.TYPE_CHANGED && it.dataItem.uri.path == "/image" }
                .forEach { event ->
                    val bitmap: Bitmap? = DataMapItem.fromDataItem(event.dataItem)
                            .dataMap.getAsset("profileImage")
                            .let { asset -> loadBitmapFromAsset(asset) }
                    // Do something with the bitmap
                }
    }

    fun loadBitmapFromAsset(asset: Asset): Bitmap? {
        // convert asset into a file descriptor and block until it's ready
        val assetInputStream: InputStream? =
                Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
                ?.inputStream

        return assetInputStream?.let { inputStream ->
            // decode the stream into a bitmap
            BitmapFactory.decodeStream(inputStream)
        } ?: run {
            Log.w(TAG, "Requested an unknown Asset.")
            null
        }
    }
    

    @Override
    public void onDataChanged(DataEventBuffer dataEvents) {
      for (DataEvent event : dataEvents) {
        if (event.getType() == DataEvent.TYPE_CHANGED &&
            event.getDataItem().getUri().getPath().equals("/image")) {
          DataMapItem dataMapItem = DataMapItem.fromDataItem(event.getDataItem());
          Asset profileAsset = dataMapItem.getDataMap().getAsset("profileImage");
          Bitmap bitmap = loadBitmapFromAsset(profileAsset);
          // Do something with the bitmap
        }
      }
    }

    public Bitmap loadBitmapFromAsset(Asset asset) {
        if (asset == null) {
            throw new IllegalArgumentException("Asset must be non-null");
        }
        // convert asset into a file descriptor and block until it's ready
        InputStream assetInputStream =
            Tasks.await(Wearable.getDataClient(context).getFdForAsset(asset))
                .getInputStream();
        if (assetInputStream == null) {
            Log.w(TAG, "Requested an unknown Asset.");
            return null;
        }
        // decode the stream into a bitmap
        return BitmapFactory.decodeStream(assetInputStream);
    }