Interakcja z kafelkami

Możesz jeszcze bardziej uatrakcyjnić działanie kafelków, ustawiając je w trybie interaktywnym. Dodając użyj modyfikatora Clickable do elementu układu w kafelku, klikanie przez użytkownika tego elementu układu.

Uwaga: system automatycznie tworzy klikalny obszar o wymiarach 48 dp x 48 dp dookoła każdego interaktywnego elementu na Twoim kafelku. Umieść te elementy w odpowiedniej odległości od siebie, tak aby ich klikalne obszary się nie nakładały. Składniki materiałowe już przestrzegasz tych wskazówek.

Na tej stronie znajduje się lista kilku typowych działań, które użytkownicy wykonują w ramach interakcji oraz wskazówki dotyczące implementacji tego działania w sekcji kafelki.

Wczytaj nowy układ kafelków

Użyj ikony LoadAction, aby odświeżyć układ kafelka, gdy użytkownik kliknie interaktywnym elementem.

W poniższym fragmencie kodu przekazywany jest klikalny identyfikator ustawiony w obiekcie setId() wraz z wywołaniem onTileRequest(), dzięki czemu możesz renderować różne układy na podstawie dla tego identyfikatora:

override fun onTileRequest(requestParams: TileRequest) = Futures.immediateFuture(
    Tile.Builder()
        .setResourcesVersion("1")
        .setTileTimeline(Timeline.fromLayoutElement(
            when(requestParams.currentState.lastClickableId) {
                "foo" -> myFooLayout()
                else -> myOtherLayout()
            }
        )).build()
)

Zaktualizuj stan w kafelku

Jeśli element interaktywny w kafelku ma kilka możliwych stanów, użyj funkcji LoadAction, aby wyświetlić nową wartość elementu. W tym fragmencie kodu pokazuje zaktualizowaną wartość pola wyboru:

private fun checkboxChip(
    checkboxValue: Boolean,
    deviceParameters: DeviceParametersBuilders.DeviceParameters
): Chip =
    Chip.Builder(
            context,
            Clickable.Builder()
                .setOnClick(LoadAction.Builder()
                    .build()
                ).build(),
            deviceParameters
        ).setIconContent(if (checkboxValue) "check" else "checkoff")
        // Set checkbox labels and colors here.
        .build()

Poproś o odświeżenie zawartości kafelka

Aby poprosić o zaktualizowanie całej zawartości kafelka, użyj polecenia LoadAction i zaktualizuj jak stan żądania kafelka, tak jak pokazano to w poniższym fragmencie kodu.

Uwaga: aby uniknąć migotania i ponownego uruchomienia animacji, nie zmieniaj układu. wczytywania (z wyjątkiem części, w których dosłowne lub dynamiczne wyrażenia zostały zaktualizowane) wartości.

private fun tappableElement(): LayoutElement =
    Button.Builder(this, Clickable.Builder()
            .setId("foo")
            .setOnClick(LoadAction.Builder()
                .setRequestState(
                    StateBuilders.State.Builder()
                        /* Update state information here. */
                        .build()
                ).build()
            ).build())
        .setTextContent("Tap me!")
        .build()

Wczytywanie aktywności za pomocą precyzyjnego linku

Aby wczytać aktywność za pomocą precyzyjnego linku, powiąż element, który można kliknąć, Obiekt LoadAction:

private fun tappableElement(): LayoutElement =
    Text.Builder()
        .setText("Tap me!")
        .setModifiers(Modifiers.Builder()
            .setClickable(Clickable.Builder()
                .setId("foo")
                .setOnClick(LoadAction.Builder().build())
                .build()
            ).build()
        ).build()

Następnie w metodzie onTileRequest() użyj obiektu TaskStackBuilder jako pomocnik:

override fun onTileRequest(requestParams: TileRequest): ListenableFuture<TileBuilders.Tile> {
    val lastClickableId = requestParams.currentState.lastClickableId
    if (lastClickableId == "foo") {
      TaskStackBuilder.create(this)
        .addNextIntentWithParentStack(Intent(
            Intent.ACTION_VIEW,
            "https://www.example.com/$lastClickableId".toUri(),
            context,
            MyWearOsAppActivity::class.java
        ))
        .startActivities()
    }
    // The user clicked somewhere else on the tile instead.
}

Wczytaj wyeksportowaną aktywność

Aby wczytać wyeksportowaną aktywność według nazwy zajęć z dodatkami do intencji, użyj funkcji LaunchAction

Uwaga: zwróć uwagę na to, jak LaunchAction wpływa na nawigację w aplikacji. Utwórz na Wear OS zaleca korzystanie z pojedynczej aktywności w aplikacji.

private fun tappableElement(): LayoutElement =
    Text.Builder(this, "Tap me!")
        .setModifiers(Modifiers.Builder()
            .setClickable(Clickable.Builder()
                .setId("foo")
                .setOnClick(ActionBuilders.launchAction(
                    ComponentName("my.package.name", "MyActivity")
                )).build()
            ).build()
        ).build()

W ramach uruchomionej aktywności możesz pobrać identyfikator użyty do utworzenia kafelka jak w tym przykładzie:

class MyActivity : FragmentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val clickableId =
            intent.getStringExtra(TileService.EXTRA_CLICKABLE_ID)
        // clickableId will be "foo" when launched from the Tile
    }
}