
English: 
[MUSIC PLAYING]
ROMAIN GUY: Good morning,
and welcome to What's
New in Jetpack in Compose.
I don't know why it's called
that, because this is not
really what the talk is about.
It's more, what is
Jetpack Compose?
Anyway, I'm Romain Guy.
I manage the Android
Toolkit team at Google.
CLARA BAYARRI:
I'm Clara Bayarri.
I'm a tech lead on the toolkit.
ADAM POWELL: And
I'm Adam Powell.
And I am also a tech
lead on the toolkit.
ROMAIN GUY: And the toolkit
now is also Jetpack Compose.
My clicker.
I need that.
All right.
So what is Jetpack Compose?
The real title.
So according to
developer.android.com,
Jetpack Compose is a modern
toolkit for building native
Android UIs.
And it simplifies and
accelerates UI development.
Blah, blah, blah.
It's all in Kotlin.
So instead of trying
to tell you what it is,
I think it's more useful if
we try to tell you what kind
of problems we're trying to
solve, what kind of goals
we're trying to achieve
with Jetpack Compose.
We did some of that.
And look, it's me again.
Same short.
Same pants.
Different watch.
ADAM POWELL: Consistency.

Japanese: 
おはようございます
「Jetpack Composeの新機能」という
題名ですが
講演の内容はさらに広範で
Jetpack Composeとは？です
私はAndroid Toolkitチームの
ロマン・ギです
技術主任の
クララ・バヤリです
同じく技術主任の
アダム・パウエルです
Toolkitに
Jetpack Composeも加わりました
さて Jetpack Composeとは？
サイトによると
Jetpack Composeとは
AndroidのネイティブUIを構築するための
最新のツールキットです
すべてKotlinで
UI開発を簡素・加速します
直接内容を説明するのではなく
Jetpack Composeで解決したい問題と
達成したい目標を ご説明しましょう
これを以前にもご説明しました
前回と同じシャツ、同じズボンですね

Indonesian: 
-Selamat pagi.
Selamat datang di
What's New in Jetpack Compose
Saya tidak tahu
kenapa judulnya begitu,
karena bukan itu yang dibahas.
Kita akan bahas
apa itu Jetpack Compose.
Nama saya Romain Guy,
manajer tim Android
Toolkit di Google.
-Saya Clara Bayarri,
tech lead di Toolkit.
-Dan saya Adam Powell,
tech lead juga di Toolkit.
-Dan Toolkit sekarang
juga disebut Jetpack Compose.
Oh, saya perlu clicker.
Baiklah.
Jadi, apa itu Jetpack Compose?
Ini judul yang benar.
Jadi, menurut
developer.android.com,
Jetpack Compose adalah toolkit modern
untuk membuat UI Android native,
yang sederhana dan cepat.
Dan seterusnya.
Semua itu ada di Kotlin.
Saya tidak akan menjelaskan definisinya.
Lebih baik saya jelaskan
masalah yang kami coba atasi,
dan tujuan apa yang ingin kami capai
dengan Jetpack Compose.
Kami sudah
pernah melakukannya.
Oh, itu saya lagi. Kaos yang sama.
Celana yang sama.
Tapi jam tangannya beda.
-Konsistensi. Itu bagus.

Chinese: 
早上好 欢迎来听 Jetpack Compose 的最新进展
我也不知道为什么他们选了这个题目 因为要谈的并不完全是
“Jetpack Compose 里有什么新东西” 而更像是
“Jetpack Compose 究竟是什么”
总之 我是 Romain Guy
是 Google Android Toolkit 团队的经理
我是 Clara Bayarri
是 Toolkit 团队的技术主管
我是 Adam Powell 
也是 Toolkit 团队的技术主管
Toolkit 现在也是 Jetpack Compose
我的遥控器 这个不能忘了 好
那么 Jetpack Compose 是什么？
这才是本次演讲真正的主题
根据 developer.android.com 的说法
Jetpack Compose 是一个现代化的工具箱
用来构建原生 Android UI 
并简化和加速 UI 开发流程
等等 它完全采用 Kotlin 语言写成
那么 与其告诉大家 它是什么
不如我们来告诉大家 我们想用 Jetpack Compose
解决什么问题 达成什么目的
这个话题我们之前就谈过 
现在我又回来了 而且你看 还是同一件衣服同一条裤子

Korean: 
[음악 재생]
안녕하세요
오늘 강연 제목은
Jetpack Compose의 새로운 점입니다
사실 강연 제목과 제가 다룰 실제 내용은
좀 거리가 있습니다
실제로는 Jetpack Compose가
무엇인지를 다루죠
제 소개를 먼저 하자면 저는 로만 기이고
Google Android
툴킷팀을 관리하고 있습니다
저는 클라라 바야리입니다
툴킷의 테크 리드입니다
안녕하세요, 아담 파월입니다
저도 툴킷의 테크 리드입니다
툴킷 역시
Jetpack Compose입니다
리모컨이
여기있군요
됐습니다
Jetpack
Compose는 무엇일까요?
이게 진짜 주제입니다
developer.android.com에서 보면
Jetpack Compose는 네이티브
Android UI 구현에 사용되는
최신 툴킷입니다
UI 개발이 단순해지고 빨라지죠
등등
Kotlin으로만 만들었습니다
이게 무엇인지 설명드리기보다는
저희가 Jetpack Compose를 통해
해결하려는 문제가 무엇인지
달성하려는 목표가 무엇인지
말씀드리는 게 좋을 것 같습니다
이미 몇 가지는 완료됐죠
여기도 제가 나오네요
똑같은 셔츠에
똑같은 바지네요
시계는 다릅니다
일관성 있네요

Spanish: 
Buenos días.
Bienvenidos a Novedades de Jetpack Compose.
No sé por qué se llama así,
porque no es el tema de esta charla.
Más bien sería qué es Jetpack Compose.
Como sea, soy Romain Guy,
administrador del equipo
de Android Toolkit en Google.
Soy Clara Bayarri
líder de tecnología en Toolkit.
Y yo soy Adam Powell.
También soy líder de tecnología en Toolkit.
Ahora Toolkit también es Jetpack Compose.
Necesito el cliqueador.
Bien.
¿Qué es Jetpack Compose?
El título real.
Según developer.android.com,
Jetpack Compose es un kit de herramientas
moderno para compilar IU nativa de Android.
Simplifica y acelera el desarrollo de IU.
Bla, bla, bla.
Está todo en Kotlin.
En lugar de intentar decirles qué es
será mejor que les cuente
qué tipo de problemas
intentamos resolver
y qué objetivos intentamos lograr
con Jetpack Compose.
Eso ya lo hicimos.
Oh, miren yo soy.
Misma remera.
Mismos pantalones.
Diferente reloj.
Coherencia.

Portuguese: 
Bom dia!
Bem-vindos à apresentação
sobre novidades no Jetpack Compose.
Não sei porque este nome,
a palestra não é sobre isso.
É mais sobre
o que é Jetpack Compose.
Sou Romain Guy, gerente
da equipe Android Toolkit no Google.
Sou Clara Bayarri.
Líder de tecnologia no Toolkit.
E eu sou Adam Powell.
Também sou líder de tecnologia
no Toolkit.
E o Toolkit agora é
o Jetpack Compose.
Meu controle. Preciso dele!
Muito bem.
O que é o Jetpack Compose?
O título real.
De acordo com
developer.android.com,
Compose é um toolkit moderno
para criar IUs nativas do Android.
Simplifica e acelera
o desenvolvimento de IU, blá-blá-blá.
Tudo no Kotlin.
Em vez de tentar dizer o que é,
acho que é melhor tentar dizer
que tipo de problemas queremos resolver
e os objetivos que buscamos
com o Jetpack Compose.
Um pouco disso...
Vejam, eu de novo.
Mesma camiseta.
Mesma calça.

Japanese: 
- 時計は違う
- 一貫性がありますね
そうですね
前回の説明は ほぼすべて
アダムとジムが担当しました
そこでは理由の一部を説明したので
今回は別の点を説明します
第１は開発の簡素化です
私達はAndroid開発の複雑さに
慣れています
「複雑さ」とは 使いにくいAPIや
多すぎるファイルや言語などのことです
実際の例をお見せします
Composeのコンパイラと
ランタイムに取り組むジムが
Composeのメリットを
社内で説明するために作成しました
名前を一覧表示する
単純なアプリを構築します
上部に入力すれば
一覧を絞り込めます
既存のUIツールキットでは
どう構築するか？
単純なXMLファイルから始めます
お馴染みのRecyclerViewですね
一覧の各項目用には
別のXMLファイルが必要です
すでにXMLファイルが複数あります
さらに FilteredListViewに

Indonesian: 
-Ya.
Waktu itu saya
bersama Adam dan Jim.
Mereka yang bicara paling banyak.
Kami menjelaskan beberapa hal.
Dan saya ingin
menambahkan poin lainnya.
Yang pertama adalah kami ingin
menyederhanakan pengembangan.
Kita sudah terbiasa dengan rumitnya
pengembangan Android.
Dan kerumitan
bisa menyebabkan banyak hal.
Beberapa API pun sudah
mulai tidak enak dipakai.
Ada terlalu banyak
file dan bahasa yang berbeda.
Saya akan tunjukkan contoh aktual.
Ini adalah sesuatu yang
didapatkan Jim,
yang mengerjakan compiler
Compose di runtime,
untuk meyakinkan
banyak orang di internal
bahwa Compose
adalah sesuatu yang bagus.
Idenya adalah
membuat aplikasi sederhana
yang berisi daftar nama.
Kita ingin mengetikkan
sesuatu di atasnya
untuk memfilter daftar itu.
Bagaimana melakukannya
dengan toolkit UI yang sudah ada?
Kita mulai dengan
file XML sederhana.
Semua pasti sudah terbiasa dengan
tampilan recycler dengan teks
dan semua alat yang bagus itu.
Kita juga perlu file XML lain
untuk tiap item dalam daftar.
Jadi kita sudah punya dua file XML.
Lalu kita perlu
tampilan daftar terfilter

Portuguese: 
-Outro relógio.
-Consistência, isso é bom!
Sim!
Adam e Jim estavam
comigo no palco e falaram mais.
Explicamos um pouco da lógica.
E eu queria falar de outros pontos.
O primeiro é simplificar
o desenvolvimento.
Nos acostumamos com complexidade
no desenvolvimento do Android.
E isso pode significar muitas coisas.
Algumas das nossas APIs são complicadas.
Há muitos arquivos e
linguagens diferentes.
Quero mostrar um exemplo real.
É algo que o Jim,
que trabalha com o Compose Compiler
no ambiente de execução,
criou para mostrar que o Compose é bom.
A ideia é criar um app simples
com uma lista de nomes.
Ao digitar algo no topo,
a lista é filtrada.
Como fazer isso no Toolkit atual?
Começamos com um arquivo XML simples.
Todos estão acostumados,
uma RecyclerView com texto, layout etc.
Precisamos de outro arquivo XML
para cada item na lista.
Já temos alguns arquivos em XML.
Precisamos da FilteredListView,
que executa findViewById,

Chinese: 
-不过手表变了  -一致性很强 这是好事
Adam 和 Jim 当时和我一起在台上
大部分的演讲都是由他们完成的
我们当时解释了一些原因
现在我想谈点别的
我们首先关注的是 如何简化开发流程
我们都已经习惯了复杂的 Android 开发流程
这里的复杂 可以有很多方面的含义
我们的一些 API 用起来已经很难受了
各种各样的文件和语言太多
我想给大家展示一个真实的例子
Jim 主导的 Compose 运行时编译器
让一些内部人员觉得 Compose 是个好东西
构思是这样的 构建一个简单的应用
在里面有一个名称列表
你只需要在顶端输入一些东西
它就会过滤列表
那么你要如何使用既存的 UI 工具来做到这一点呢？
首先从简单的 XML 文件起步
大家都习惯了它 
RecyclerView TextView 和 LinearLayout 之类的
此外 你还需要为列表中的每个内容
都安排一个 XML 文件
我们已经在 XML 中有了一些文件
然后你需要 FilteredListView 来

English: 
It's good.
ROMAIN GUY: Yes.
So Adam and Jim were
with me on stage
and did most of the talking.
So we explained some
of the reasoning.
And I wanted to go
over other points.
The first one for us is to
simplify the development.
And we all got used
to the complexity
of Android development.
And the complexity can
mean many different things.
Some of our APIs already
are awkward to use.
You have two many different
files, different languages.
So I want to show you
an actual example.
So that's something
that Jim, who
works on the Compose
compiler in runtime,
has come up with to try to
convince a bunch of people
internally that Compose
is a good thing.
So the idea is to
build a simple app
where you have a list of names.
And you just want to type
something at the top.
And it's going to
filter the list.
So how would you do that
with the existing UI toolkit?
You start with the
simple XML file.
You're all used to that, a
recycler view with the text
and the [INAUDIBLE],,
all that good stuff.
Then you need another XML file
for each list item in the list.
So we already have a
couple files in XML.
Then you need your
filtered list view

Spanish: 
Es bueno.
Sí.
Adam y Jim me acompañaron
y dimos gran parte de la charla.
Explicamos el razonamiento,
y queríamos repasar otros puntos.
Para nosotros, el primero
es simplificar el desarrollo.
Ya todos nos acostumbramos
a la complejidad de desarrollo
en Android.
"Complejidad" puede significar varias cosas.
Algunas de nuestras API son extrañas,
hay muchos archivos y lenguajes diferentes…
Quiero mostrarles un ejemplo real.
Eso es algo que creó Jim,
que trabaja en el entorno
y el compilador de Compose,
para convencer a algunas personas
de que Compose es algo bueno.
La idea es compilar una app simple
en la que hay una lista de nombres,
y cuando escriben algo arriba
se filtrará la lista.
¿Cómo harían eso con
el kit de herramientas de IU existente?
Comenzarían con un archivo XML simple.
Todos están acostumbrados a eso;
la vista de reciclador con el texto,
el diseño y todo lo bueno.
Luego necesitan otro archivo XML
para cada elemento de la lista.
Ya tenemos un par de archivos en XML.
Luego necesitan la vista de lista filtrada

Korean: 
좋아요
네
함께 연단에 올랐던 아담 씨, 짐 씨가
강연 대부분을 진행했습니다
몇 가지 핵심 내용을 설명했고요
오늘은 다른 부분을 다루려고 합니다
첫 번째는 개발을 단순화하기입니다
저희는 Android 개발의 복잡성에
이미 익숙해졌습니다
복잡성이라는 말에는
많은 의미가 담겨 있죠
일부 API는 사용하기가 불편합니다
파일과 언어가 너무 다양합니다
그래서 실제 예시를 보여드리려고 합니다
런타임 내 Compose 컴파일러
업무를 맡고 있는 짐 씨가
Compose가 좋다는 것을
많은 내부 직원들에게 설득하기 위해
예시로 든 것입니다
기본 개념은 이름 목록이 있는
간단한 앱을 구현하는 것입니다
맨 위에 무언가를 입력하면
목록을 필터링합니다
기존 UI 툴킷에서는 어떻게 하면 될까요?
간단한 XML 파일로 시작합니다
여러분이 익숙한 리사이클러 뷰에는
텍스트 등 좋은 것이 다 있습니다
목록에 있는 항목마다
XML 파일이 하나 더 필요합니다
그래서 XML로 된 파일이 몇 개 생기죠
이제 ID로 뷰를 찾고
텍스트 삭제를 찾고

Korean: 
리스너를 설정해 주며
리사이클러 뷰를 찾고
어댑터를 설정하는
필터링된 리스트 뷰가 필요합니다
직접 해보지는 않겠습니다
이제 어댑터가 필요합니다
이게 좀 재밌는데요
사실 슬라이드에 이 내용을 넣으면서
이것이 목록을 필터링하는
최선의 방법이 맞는가라는 생각이 들었습니다
그래서 Google에서 검색했습니다
그랬더니
[웃음]
제가 필터링 API의
일부를 작성했기 때문에
더 나은 방법이 있을 거라고 생각했죠
결과적으로는 아니었습니다
블로그 게시물, 기사,
심지어 Stack Overflow에도
어떻게 해야 하느냐는 질문이 있습니다
제가 가장 간단한 방법 중
하나를 소개할 수 있어서 기쁘네요
이제 실행을 위해 RxJava
등의 멋진 프레임워크를
사용하면 됩니다
어쨌든 코드가 많습니다
성가시죠
간결하지 않습니다
이게 전체 Compose 버전인데요
필요한 모든 코드가 화면에 있습니다
훨씬 쉽죠
버그를 찾기도 훨씬 수월합니다
더 중요한 것은 코드를 읽을 때
코드를 읽는 사람이 누구이든
어떤 작업을 하고자 하든 관계없이
코드의 의도를 분명히
알 수 있다는 것입니다
스크롤러나
텍스트 필드 열을 원하셨다거나
죄송합니다

English: 
that's just going to do
that find [INAUDIBLE],,
find delete text,
set up the listeners,
find the recycler view,
set up the adapter.
I'm not even showing
the activity here.
Finally, you need
the adapter itself.
So actually, it's funny.
Because when I put that on
the slide, I'm like, wait,
is that the best way we
have to filter a list?
So I Googled it.
And it turns out--
[LAUGHTER]
Because I did write some
of the filtering APIs.
So I thought there
was a better way.
It turns out there's not really.
And there's a lot of blog
posts, articles, and even Stack
Overflow questions
on how to do this.
I'm proud to announce that this
is one of the simpler ways.
And then you can use
RxJava or fancy frameworks
to make this happen.
Anyway, that's a lot of code.
It's annoying.
It is not simple.
So this is the entire
Compose version.
All the code you need
is there on screen.
Much easier.
It's going to be a lot
easier to find bugs.
And more importantly,
when you read the code,
it's pretty obvious what
the intent of the code
is, whoever read that code,
what they wanted to do.
So you say, I want a scroller.
I want a column of text fields.
Sorry.

Spanish: 
donde podrán buscar por ID,
por edición de texto,
por la vista de reciclador,
configurar objetos de escucha,
configurar el adaptador…
No les estoy mostrando la actividad aquí.
Por último, necesitan el adaptador.
De hecho, es gracioso.
Porque cuando lo pongo en la diapositiva
pienso, ¿es la mejor manera
de filtrar una lista?
Entonces, lo busco en Google.
Y resulta que…
Como escribí algunas de las API de filtrado,
pensé que había una mejor manera.
Resulta que, en realidad, no la hay.
Hay muchas publicaciones en blogs, artículos,
y preguntas en Stack Overflow
sobre cómo hacerlo.
Me enorgullece anunciarles
que esta es una de las maneras más simples.
También pueden usar RxJava
o marcos de trabajo complejos
para lograrlo.
De todos modos, es mucho código.
Es molesto. No es simple.
Esta es la versión completa de Compose.
Este es todo el código que necesitan.
Mucho más fácil.
Será mucho más fácil encontrar errores.
Y, lo más importante,
al leer el código resulta bastante obvio,
cuál es su objetivo, sin importar
quién lo escribió ni para qué.
Supongamos
que quiero una barra de desplazamiento
una columna de campos de texto.
Lo siento.

Indonesian: 
dengan mencari tampilan
dan delete text,
menyiapkan pemroses,
mencari tampilan recycler,
dan menyiapkan adapter.
Saya tidak menunjukkan
aktivitasnya di sini.
Akhirnya, kita perlu adapter.
Jadi ada yang lucu.
Saat saya masukkan ini
di slide, terlintas pertanyaan,
apa cara terbaik
untuk memfilter daftar?
Jadi saya menelusurinya di Google.
Dan ternyata--
Karena saya menulis
beberapa API pemfilteran,
saya merasa ada
cara yang lebih baik.
Dan ternyata tidak ada.
Ada banyak postingan blog, 
artikel, dan pertanyaan Stack Overflow
tentang cara melakukannya.
Saya bangga bisa menyampaikan
salah satu cara yang lebih sederhana ini.
Anda bisa gunakan RxJava
atau framework keren lain
untuk melakukannya.
Tapi memang kodenya banyak.
Dan itu mengganggu.
Tidak sederhana.
Jadi inilah seluruh
versi Compose.
Semua kode yang Anda perlukan
ditampilkan di layar.
Lebih sederhana.
Menemukan bug
jadi jauh lebih mudah.
Dan yang terpenting,
saat kodenya dibaca,
sangat jelas intent kode itu
bagi yang membaca
dan ingin melakukan sesuatu.
Misalnya, Anda ingin scroller,
atau kolom teks.
Maaf.
Kolom dengan bidang teks di atasnya.

Chinese: 
findViewById 查找或者拿掉字符串
设置事件监听器 找到 RecyclerView
设置适配器 (adapter) 等等
我现在甚至还没开始向大家展示 Activity
最后 你还需要适配器本身
这个很有意思 因为 当我把它放上幻灯片的时候
我在想 等等 这样开发过滤列表是最优的做法吗？
于是我 Google 了一下 结果发现...
因为有些过滤器 API 确实是我写的
我当时以为 还有更好的办法
但结果并不是这样 而且
有大量的博客 文章 甚至 StackOverflow 提问
都在讲如何做到这一点
很高兴在这里宣布 这是一种比较简单的方式
然后你可以使用 RxJava 或者其他酷炫的框架来解决问题
总之 这需要很多代码 很烦人 并不简单
这是整个 Compose 版本
你需要的代码就是屏幕上这些
调试起来简单多了 
更重要的是 当你阅读代码时
代码的意图会很直白
无论是谁在阅读代码 都能知道代码想干什么
比如你说 我想要个滑动条
我想要列排列的文本框 抱歉说错了

Japanese: 
findViewByIdや
addTextChangedListener
findViewById などを追加します
他にも多くのコードを追加し
最後にアダプタです
スライドに載せたとき
これがリストをフィルタする
最適な方法なのか疑問に思ったので
ググってみました
判明したのは...
フィルタリングAPIを書いた経験があるので
より良い方法があると思いましたが
ありませんでした
方法に関するブログや記事
さらにStack Overflowまでも
確認しましたが
これは最もシンプルな方法の１つでした
実行にはRxJavaなどの
フレームワークを使用します
コードが多く 面倒で複雑です
これがComposeの場合です
必要なコードは これだけです
ずっとシンプルで
バグ発見も簡単です
さらに重要なのは
コードの意図がひと目で分かることです
誰が読んでも明確です
スクローラーが欲しい
上部にテキスト欄がある列が欲しい

Portuguese: 
encontra o texto do ID, define listeners,
acha a RecyclerView, define o adaptador.
Não estou nem mostrando a atividade.
Agora precisamos do adaptador mesmo.
É engraçado.
Quando coloquei isso no slide, pensei:
"Este é o melhor jeito
de filtrar uma lista?"
Então, pesquisei no Google.
E o resultado...
Porque escrevi algumas APIs
de filtro para adaptador,
e pensei que havia um jeito melhor.
Na verdade, não há.
E há muitas posts, artigos e 
perguntas no Stack Overflow sobre isso.
Tenho orgulho de dizer que
esse é um dos jeitos mais simples.
E é possível usar RxJava
ou frameworks sofisticados para isso.
Mas é muito código.
É irritante.
Não é simples.
Esta é versão inteira do Compose.
Todo código necessário está na tela.
Bem mais fácil.
Muito melhor de encontrar bugs.
E o mais importante,
o intent do código fica óbvio.
Posso dizer: "Quero rolagem.
Quero uma coluna de campos de texto."
Perdão.

Chinese: 
我想要一个列 列的顶部放一个文本
而每一行我都想要一段虚拟的文本
每当列表内容更改为真实的联系人列表的时候
所有内容都会如你期待的那样更新
我们还想做的一件事是 修正错误
我们有一些 API 需要修改
我们在 Google I/O 上提到过这件事
如果大家想要了解详情的话 建议去看看当时的演讲
我们还有一些有趣的奇闻轶事
其中之一就是 现在 View.Java 有大约3万行代码
当然 其中有很多注释
我记得这个数量还是减少过了的
没错 不过还是非常多
所以 我们的计划是...
我们有很多的惯例和历史 有些东西是无法修改的
我们知道有问题 但就是改不了
如果强行修改 可能会造成新 bug 
应用可能会依赖当前的行为
所以 我们可以说是卡在这里了
在现有的 UI 工具箱里 我们似乎没法做什么了
我们不想再做弊
这是我们之前做过的事
Adam 近来在 Kotlinlang Slack 频道讲过
我们非常想让 @hide 消失
如果你熟悉 Android 平台的源代码
就会发现 我们提供了这个神奇的注解 @hide

Portuguese: 
Uma coluna com
campo de texto no topo
e, para cada linha,
quero texto específico.
E assim que altera o conteúdo da lista
para uma lista de contatos,
tudo é atualizado como esperado.
Também queremos corrigir o
que não funciona.
Nossos arrependimentos em APIs.
Falamos disso no I/O.
Assistam a palestra
se quiserem saber mais.
Tivemos momentos engraçados.
Um dos melhores: View.Java agora está
com umas 30 mil linhas de código.
É claro que há muitos comentários.
Em algum momento,
o número diminui.
Sim.
Mas ainda é muito.
Nós temos um plano.
Também temos muita bagagem e história.
E tem coisas que não podemos resolver.
Sabemos que há problemas,
mas não podemos resolver.
Poderíamos introduzir bugs,
e há apps que precisam
do comportamento atual.
Estamos "presos".
Não dá para fazer muito
com o Toolkit atual.
Queremos parar com as "gambiarras".
Fizemos isso no começo.
Acho que o Adam disse
no canal "kotlinlang" do Slack
que queria muito que @hide desaparecesse.
No código-fonte da plataforma Android,

Japanese: 
各行に画像とテキストが欲しい
などの要望があっても
リストの内容を変更するだけで
すぐに反映できます
別のポイントは 修正作業です
これはAPIに関するトピックです
詳しくはGoogle I/Oの
録画をご覧ください
例えばView.Javaは
約３万行のコードで動作しています
コメントも多く含まれます
- 以前よりは少ないです
- ええ でも多い
これだけコードが多いと
修正が困難です
修正が不可能な部分もあります
問題を把握しているのに
直せないのです
新たなバグの恐れや
既存アプリとの依存関係など
身動きが取れません
既存のUIツールキットでは無理です
目的はチートを止めることです
つまり「@hide」を無くすことです
プラットフォームのソースを見ると

English: 
I want a column with a
text field at the top.
And for you each row I want
an imagined piece of text.
And as soon as you change
the content of the list
to contact list, everything
updates as you would expect.
Another thing we want to
do is fix what's broken.
So that's our API regrets.
We talked about
this at Google I/O.
I invite you to watch the
talk if you want to know more.
We had a few funny anecdotes.
One of the good
ones, of course, is
View.Java that now clocks at
around 30,000 lines of code.
Sure.
There's a lot of comments
in there, but still--
ADAM POWELL: I think that's
down from some point.
ROMAIN GUY: Yeah.
But still, it's a lot.
So the plan for
us is also we have
a lot of baggage and history.
So there are things
that we just cannot fix.
We know there are problems,
but we just can't fix them.
We could introduce
new bugs, or apps
may be relying on
the current behavior.
So we're kind of stuck.
We can't really do much more
with the existing UI toolkit.
We want to stop cheating.
This is something
we did originally.
And I think Adam
recently, you said
on the Kotlin
[INAUDIBLE] Slack channel
that you really, really
want add hide to disappear.
So if you ever looked at the
source code of the Android

Korean: 
상단에 텍스트 필드가 있는 열을 원하고
각 행에 생각해 둔
텍스트를 넣으려 할 수 있습니다
리스트의 내용을
연락처 목록으로 변경하면
모든 내용이 제대로 업데이트됩니다
또 저희가 하려는 한 가지는
문제를 해결하는 것입니다
바로 API 수정 사항입니다
이 내용은 Google I/O에서 다뤘습니다
해당 강연을 보시면
자세한 내용을 알 수 있습니다
재미있는 일이 좀 있었습니다
잘된 일 하나는
View.Java의 코드 줄 수가
30,000개 정도라는 것입니다
사실
여기에 대한 의견이 많습니다만
줄어든 것 같은데요
네
하지만 여전히 많죠
그래서 저희가 가지고 있는
쌓인 문제가 아주 많습니다
저희가 해결할 수 없는 문제가 많죠
문제가 있다는 걸
알면서도 해결하지 못하죠
새로운 버그를 유발하거나
앱이 현재의 동작에 의존하게 될 테니까요
이도 저도 못 하는 거죠
기존 UI 툴킷으로는 더 이상
할 수 있는 것이 많지 않습니다
꼼수를 쓰고 싶지는 않고요
이게 저희가 원래 했던 일입니다
아담 씨가 최근에
Kotlin Slack 채널에서
add hide를 정말
없애고 싶다고 말씀하셨는데요
Android 플랫폼의
소스 코드를 보시면

Indonesian: 
Dan untuk setiap baris, 
saya mau teks imajiner.
Saat Anda mengubah konten
daftar menjadi daftar kontak,
semuanya diupdate
sesuai harapan Anda.
Kami juga ingin
memperbaiki yang rusak.
Kami punya penyesalan
terkait API,
yang kami bahas di Google I/O.
Diskusinya bisa ditonton jika
ingin tahu lebih jauh.
Kami punya anekdot konyol.
Salah satu yang terbaik adalah
View.Java yang sekarang mencapai
sekitar 30.000 baris kode.
Tentu ada banyak komentar,
tapi--
-Saya rasa itu sudah berkurang.
-Ya.
Tapi tetap banyak.
Jadi rencananya adalah,
karena kami juga punya
banyak beban dan riwayat,
ada yang tak bisa diperbaiki.
Kami tahu ada masalah,
tapi tak bisa menanganinya.
Kami bisa buat bug
baru, atau aplikasi mungkin
mengandalkan perilaku saat ini.
Jadi, seolah macet.
Kami tak bisa melakukan lebih banyak
hal dengan toolkit UI yang sudah ada.
Kami ingin berhenti main curang.
Awalnya kami melakukannya.
Dan sepertinya Adam
baru-baru ini berkata
di Kotlin,
saluran Slack,
sungguh ingin
add hide dihilangkan.
Jika kita lihat kode
sumber platform Android,

Spanish: 
Quiero una columna
con un campo de texto arriba,
y para cada fila, quiero cierto texto.
En cuanto cambian el contenido de la lista
a una lista de contactos,
todo se actualiza según lo esperado.
También quiero corregir lo que está roto.
Es lo que nos apena de las API
y sobre lo que hablamos en Google I/O.
Los invito a ver la charla.
Hay varias anécdotas divertidas.
Una de las mejores es, claro, View.Java
que ya tiene unas 30,000 líneas de código.
Claro que hay muchos comentarios, pero igual…
Creo que, en algún punto, bajó.
Sí, pero igual, es mucho.
Nuestro plan es tener mucho historial.
Hay cosas que no podemos arreglar.
Sabemos que hay problemas,
pero no podemos resolverlos.
Podríamos crear nuevos errores
o tal vez las apps
dependen del comportamiento actual.
Estamos atascados; no podemos hacer mucho más
con el kit de herramientas de IU actual.
Queremos dejar de hacer trampa.
Eso es lo que hicimos originalmente.
Adam, creo que recientemente
dijiste en el canal de Slack de Kotlin
que realmente querías
que "add hide" desapareciera.
Si alguna vez vieron el código fuente
de la plataforma Android

Korean: 
공개 API를 비공개 API로 전환하는
마법 같은 주석인
add hide가 있는 것을 알 수 있습니다
저희에겐 정말 유용하죠
자바 프로그래밍 언어의 한계를
피할 수 있게 해주기 때문입니다
하지만 시간이 지나면서
문제가 생겼습니다
예를 들어 텍스트 뷰에서
어떤 작업을 하려고 하는데
텍스트 뷰가 바로 작동되지 않습니다
그래서 나름의 방법으로
텍스트 뷰를 작성합니다
실마리를 푸는 데 착수하죠
이때 전체 텍스트 패키지를 가져오고
전체 공간에서 두 개의
우선순위 API가 실행 중인데
여기에서 할 수 있는 것이 없습니다
문제인 거죠
저희에게 문제가 됩니다
저희는 Compose를 사용함으로써
더 이상 비공개 API에
의존하지 않으려고 합니다
저희는 낮은 수준에서
플랫폼과 상호 작용해야 합니다
그런데 저희 위젯은
여러분들이 이용하실 수 있는
공개 API로만 구현되어 있습니다
예시를 하나 보여드리겠습니다
좋은 소식은
플랫폼 자체에서
더 많은 것들을 공개할 수 있는
강제 함수를 만들고 있다는 겁니다
저희가 공개하는 것에 대해
더 고심해 봐야 할 것 같습니다
머티리얼과 애니메이션
슬라이드에 예쁜
하트 이모티콘이 있었는데
사라졌네요

English: 
platform, we have this magical
annotation called add hide,
which turns public APIs
into very private APIs.
And super useful to us.
It was a way to work around some
of the limitations of the Java
programming language.
But it led, over the
years, to an issue for us.
For instance, let's say you want
to do something with text view.
That text view doesn't
do well out of the box.
So you have your sensors.
Write your own text view.
Well, you start
pulling that thread.
And then you're grabbing
the entire text package.
And you're running two priority
APIs all over the place,
and you can't do
anything about it.
So that's an issue for us.
And it's an issue for us.
So what we want
to do with Compose
is we don't want to rely
on private APIs anymore.
We kind of have to
at the low level
to interact with the platform.
But all of our widgets
are built entirely
using public APIs that
are available to you.
And I'm going to show you
actually an example of that.
ADAM POWELL: And
the good news is
that it's kind of forming a
forcing function for us to open
more things in the platform
itself along the way.
ROMAIN GUY: And we have to
think a little harder about what
we open.
Material and animations.
Oh, I had a pretty heart
emoji on the slide.
It's gone.

Spanish: 
verán que tenemos
la anotación mágica "add hide"
que convierte las API públicas en privadas.
Era muy útil para nosotros.
Servía para resolver algunas limitaciones
del lenguaje Java.
Pero, con los años,
implicó un problema para nosotros.
Por ejemplo, supongamos
que quieren hacer algo con vista de texto.
Esa vista no funciona bien
en su forma original.
Así que toman sus sensores,
escriben su vista de texto,
y comienzan a publicar el subproceso.
Luego agarran todo el paquete de texto
ejecutan dos API con prioridad en simultáneo
y no pueden solucionarlo.
Eso representa un problema.
Lo que queremos hacer con Compose
es dejar de depender de API privadas.
Tenemos que interactuar
con la plataforma en el nivel inferior.
Pero todos los widgets
están compilados con API públicas
que están disponibles para ustedes.
Les mostraré un ejemplo.
La buena noticia es
que nos está forzando
a abrir más elementos en la plataforma.
Tenemos que pensar un poco más
acerca de lo que abrimos.
Material y animaciones.
Oh, tenía un emoji de corazón.
Desapareció.

Japanese: 
@hideアノテーションがあります
これはパブリックAPIを
プライベートAPIに変えます
非常に便利です
Javaの制限の一部を回避できます
しかし月日を経て 問題になってきました
TextViewを使うとしましょう
しかし そのままでは
上手く機能しないので
独自にTextViewを書き
スレッドを作ります
テキストパッケージ全体を扱います
こうなると
２種類のAPIが入り交じり
非常に複雑になります
これは問題です
プライベートAPIへの依存は
避けたいところです
そこで
プラットフォームとのやり取りは
低いレベルで行いつつ
すべてのウィジェットを
パブリックAPIのみで構成しました
実際にその例をお見せします
よりオープンなプラットフォームを
推進できることが利点です
何をオープンにするかは
慎重に決める必要があります
次は マテリアルとアニメーションです

Portuguese: 
temos a anotação mágica @hide,
que transforma APIs públicas
em APIs bem privadas.
É superútil para nós.
É um jeito de driblar algumas limitações
da linguagem Java.
Mas, com o passar dos anos,
virou um problema.
Suponha que você queira
fazer algo com a TextView.
Ela não funciona bem originalmente.
Você tem os sensores.
Escreve a TextView.
Começa a extrair a linha.
E então pega todo o pacote de texto.
Executa duas APIs privadas
e não pode fazer nada a respeito.
É um problema para todos.
O que queremos fazer com Compose
é não depender mais de APIs privadas.
No nível de baixo,
precisamos interagir com a plataforma.
Mas todos nosso widgets são criados
com APIs públicas disponíveis para vocês.
E vou mostrar um exemplo disso.
E a boa notícia é que isso cria
uma movimento que nos faz abrir
mais elementos na plataforma.
E temos que pensar mais
sobre o que abrimos.
Material Design e animações.
Tinha um emoji
de coração tão lindo no slide...
Não tem mais.

Chinese: 
它可以把公共 API 转变成私有 API
这个功能对我们很有用
我们可以用它来绕过一些 Java 编程语言的限制
但是 多年以来 它产生了一个问题
举个例子 比如说你想使用文本视图做点事情
而这个文本视图直接拿来用是不太好用的
所以你只能自己处理 来编写你自己的文本视图
你开始去解析线程 然后用到了整个文本包
然后你在内部各处运行两个优先 API
而且你对这种情况毫无办法
我们认为这是个问题
我们对 Compose 的期待是
我们不想再依靠私有 API 了
我们必须在低层级上和平台互动
但我们所有的 widget
都完全是使用大家都能接触到的公共 API 做成的
下面我来为大家展示一个例子
好消息是 它形成了某种强制功能
可以顺便打开平台内的更多东西
我们也需要仔细考虑一下 我们打开的是什么
Material 和动画
哦 我本来还在幻灯片上标了一个很好看的心形表情 现在没了

Indonesian: 
ada anotasi ajaib
yang disebut add hide,
yang mengubah API publik
jadi API yang sangat pribadi.
Ini sangat berguna buat kami
sebagai cara mengatasi
beberapa keterbatasan
bahasa pemrograman Java.
Namun, seiring tahun berjalan, cara
ini menyebabkan masalah buat kami.
Misalnya, jika ingin melakukan
sesuatu dengan tampilan teks.
Tampilan teks itu tak langsung
berfungsi baik.
Misalnya Anda punya sensor,
dan menulis tampilan teks.
Lalu Anda tarik thread,
mengambil seluruh paket teks,
dan menjalankan dua API
prioritas di semua tempat,
dan Anda tidak bisa
mengubahnya lagi.
Itulah masalah kami.
Yang ingin kami
lakukan untuk Compose
adalah menghilangkan
ketergantungan pada API pribadi.
Itu harus dilakukan di level bawah
untuk berinteraksi dengan platform.
Tapi semua widget kami dibuat
menggunakan API publik yang
tersedia untuk Anda.
Saya akan tunjukkan contoh nyatanya.
-Kabar baiknya adalah
cara itu seolah memaksa
kami untuk membuka
lebih banyak hal di platform
seiring perkembangannya.
-Dan kami harus berpikir lebih
keras tentang apa yang harus
kami buka.
Material dan animasi.
Oh, sebenarnya ada emoji hati
cantik di slide.
Tapi sudah tidak ada.

Spanish: 
Oh.
Me gustan los corazones.
Bueno, ahora estamos
en el mundo de Material Design.
El kit de herramientas se compiló
antes de que Material Design existiera.
Lo bueno es que ahora
contamos con Material Design.
A eso se dedican Clara
y su equipo en Londres.
También compilamos animaciones
junto con el resto del equipo
del kit de herramientas de IU de Compose.
Esperamos que resulte en algo
más poderoso y fácil de lo que es ahora.
Herramientas y Compose.
Lo mismo.
Cuando compilamos el kit
de herramientas de IU
no había mucha interacción
con el equipo de herramientas
porque era un equipo muy pequeño.
Muchas herramientas
surgieron después del hecho.
El editor visual, las alertas de movimiento
que vieron en el resumen.
Nosotros queríamos cambiar eso.
Ya vieron que estamos compilando
elementos, como vistas previas
y estamos compilando Compose mismo.
Adoptamos Kotlin.
Anunciamos que primero
queríamos adoptar Kotlin.
Eso es algo que queríamos decirles
que adopten Kotlin primero.
Pensamos que sería buena idea
hacer lo que les decimos que deberían hacer.

Chinese: 
我喜欢心形表情
在 Material Design 世界中
现有的 UI 工具箱是在 Material Design 出现之前构建的
好消息是 我们现在可以整合 Material Design 的要素了
这就是 Clara 和她的团队在伦敦做的事情了
我们也在构建与其余 Compose UI 工具箱相配合的动画效果
我们认为 它将会比现有的版本更易用 更强大
Tools 和 Compose 也是一样
我们在构建初始 UI 工具箱 也就是现存版本 的时候
当时我们和 Tools 团队没有太多的交流
因为当时 Tools 团队还很小
所以很多工具其实是初始版本发布后才加上的
比如大家在主题演讲中看到的界面编辑器 动效编辑器等
我们想要改变这种局面
大家刚刚看到 我们在构建一些东西
比如和我们的 Compose 构建过程同步的组合式实时预览
我们采用了 Kotlin 
我们宣布 会优先使用 Kotlin
不过 倡导大家使用 Kotlin 
终究还是不如我们自己先来带头试用

Japanese: 
ハートの絵文字が消えてますね
今はマテリアルデザインの時代ですが
既存のUIツールキットは
それより前の産物です
新ツールでは
マテリアルデザインの要素を使えます
クララのチームの担当ですね
またCompose UIツールキットと
密に連携した
アニメーションを作成しています
ですから既存ツールよりもシンプルで
優れた環境になります
次は ツールとComposeです
既存のUIツールキットを作成した当初
ツールの数は限定的でした
ツールの多くは
後から追加されたものです
ビジュアルエディタなどです
それを変えたいのです
そこで登場したのが
ライブプレビュー機能などです
次はKotlinです
Kotlinファーストを発表しました
皆様にも Kotlinファーストを勧めます
皆様に勧める以上は 有言実行のため

Indonesian: 
Yah...
saya suka hati.
Jadi sekarang kita ada dalam
dunia Desain Material.
Toolkit UI yang ada saat ini dibuat
sebelum ada Desain Material.
Kabar baiknya, kini kita
bisa pertimbangkan Desain Material.
Inilah yang dilakukan Clara
dan timnya di London.
Kami juga sedang
membuat animasi
dengan kolaborasi yang kuat
dalam toolkit UI Compose lainnya.
Kami berharap ini akan jadi
lebih mudah dan hebat
dibandingkan yang sudah ada.
Alat dan Compose.
Ini juga serupa.
Saat kami membuat toolkit UI
awal, yang sudah ada itu,
kami tidak terlalu berinteraksi
dengan tim fitur
karena tim fitur
masih sedikit.
Jadi, banyak fitur yang
dibuat setelah UI ada.
Jadi, editor visual,
yang Anda lihat di keynote.
Kami ingin mengubahnya.
Dan Anda baru melihat bahwa
kami membuat hal-hal seperti
pratinjau langsung yang sekarang
bisa disusun,
seiring upaya membuat Compose itu sendiri.
Kami menerapkan Kotlin.
Kami umumkan bahwa kami
ingin menggunakan Kotlin dulu.
Jadi kami jelaskan
tentang Kotlin dulu.
Dan rasanya bagus jika
kami melakukan
apa yang kami sarankan kepada Anda.

English: 
ADAM POWELL: Aw.
ROMAIN GUY: I like hearts.
Anyway, so now we're in
the Material Design world.
The existing UI toolkit was
built before Material Design
was a thing.
So the good news now, we
can take Material Design
into account.
This is what Clara and
her team do in London.
And we also are
building animations
in strong collaboration with the
rest of the Compose UI toolkit.
So we expect it's going to
be easier and more powerful
than it was in the existing one.
Tools plus Compose.
Same thing.
When we built the initial UI
toolkit, the existing one,
there was not that much
interaction with the tools team
because the tools
team was very small.
So a lot of the tools
came after the fact.
So the visual editor,
the [INAUDIBLE]
that you saw in the keynote.
And we want to change that.
And you just saw that
we're building things
like live previews that are
composable right now, as we're
building Compose itself.
We adopted Kotlin.
We announced that we
want to go Kotlin first.
So that would be
one thing for us
to tell you to go Kotlin first.
And we thought that
maybe it was a good idea
to do what we say
that you should do.

Korean: 
오
저는 하트가 좋아요
우리는 현재 머리티얼 디자인
세계에 들어와 있습니다
기존 UI 툴킷은
머티리얼 디자인이 주목받기 전에
구현되었습니다
좋은 소식은 이제 머티리얼 디자인을
고려할 수 있다는 점이죠
클라라 씨가 이끄는 팀이
런던에서 이 일을 하고 있습니다
저희는 Compose UI
툴킷의 나머지 팀과
적극 협력하여
애니메이션을 구현하고 있습니다
그래서 기존 것보다 사용이 더 쉽고
성능은 더 향상될
것이라고 예상하고 있습니다
도구와 Compose 역시
마찬가지입니다
기존 툴킷인 최초의
UI 툴킷을 구현했을 때
도구팀의 규모가 매우 작았기 때문에
도구팀과의 교류가 많지 않았습니다
이후에 도구가 엄청 많이 늘어났죠
비주얼 에디터는
키노트에서 보셨을 겁니다
저희는 이걸 바꾸고자 합니다
저희가 Compose를
구현하고 있는 동시에
지금 구성 가능한
라이브 프리뷰와 같은 것을
구현하고 있다는 것을 확인하셨을 겁니다
저희는 Kotlin을 도입했습니다
Kotlin으로 먼저 전환할
것이라고 말씀드렸었는데요
이와 관련해서 말씀드릴 내용은
Kotlin으로 먼저 전환하시라는 것입니다
그리고 저희가 말씀드리는 내용을
따르시길 권장드립니다

Portuguese: 
Eu curto corações.
Agora estamos no mundo do
Material Design.
O Toolkit atual é anterior ao
Material Design.
A boa notícia é que podemos
considerar o Material Design.
É isso que Clara e equipe fazem
em Londres.
E estamos criando animações
com a colaboração
de toda a equipe do
toolkit de IU do Compose.
Esperamos que fique
mais fácil e eficiente.
Ferramentas e Compose, a mesma coisa.
Quando construímos o toolkit inicial,
não havia interação
com a equipe de ferramentas
porque ela era bem pequena.
Então várias ferramentas vieram depois.
O Visual Editor, o MotionLayout
que viram na apresentação principal.
E queríamos mudar isso.
Como viram, estamos criando elementos
como prévias em tempo real combináveis
enquanto criamos o Compose.
Adotamos o Kotlin.
Anunciamos prioridade para Kotlin.
Gostaríamos que vocês
também priorizassem Kotlin.
E pensamos que fosse boa ideia
fazer o que dizemos.

Korean: 
Compose가 Kotlin으로
회귀하고 있습니다
Kotlin은 실제로 저희가
Compose에서 하는 많은 작업을
가능하게 합니다
저희의 API 설계 방식은
Kotlin 덕분에 가능합니다
예를 들어 저희는 람다에 크게 의존합니다
코루틴과 같은 흥미로운 기능을
사용하려는 계획도 있습니다
아담 씨는 코루틴을
Compose 전체에 추가하는 것만
기다리고 있습니다
결국 저희가 가장 많이
신경을 쓰는 부분은
호환성입니다
여러분에게 앱 전체를 다시
코딩하라는 의미가 아닙니다
여러분이 Compose를 도입하고자 하고
프로덕션에 활용할 준비가 완료되면
저희가 Instant Run
작업에서 그랬던 것처럼
모든 코드를 지우고
처음부터 다시 시작하지 않으셔도 됩니다
다음 활동이나 부분을 코딩하시거나
일부 맞춤 뷰를
재사용하실 수 있으면 됩니다
기존 뷰의 경우, 일부는
저희도 다시 코딩하지
않을 가능성이 있습니다
서피스 뷰나 웹 뷰 같은 것들 말이죠
새로운 웹 뷰를 코딩하고 싶으신 경우
와서 저희를 좀 도와주세요
하지만 저희는 하지 않으려고 합니다
저희는 기존 것을 사용하려고 합니다
네
마지막으로, 이것이
Compose 기술 스택의
모습입니다
한쪽에는 빌드 시간 스택이 있습니다

Spanish: 
Así que, Compose está volviendo a Kotlin.
De hecho, Kotlin desbloquea mucho
de lo que hacemos en Compose.
La manera en que diseñamos la API
es posible gracias a Kotlin.
Dependemos de los lambdas, por ejemplo.
Planeamos usar funciones divertidas,
como las corrutinas.
Adam está editando el código
para agregar corrutinas en todo Compose.
Por último, la compatibilidad
es algo que nos interesa mucho.
No les pedimos que reescriban toda su app.
Si quieren adoptar Compose
cuando esté en producción,
no esperamos que borren todo el código
como hicimos para Instant Run
y que comiencen de cero.
Queremos que puedan
escribir su próxima actividad
o su próximo fragmento
o que puedan reutilizar algunas
de sus vistas personalizadas.
Es probable que ni siquiera nosotros
reescribamos las vistas existentes,
como la vista de superficie o la vista web…
Si alguno quiere escribir
una nueva vista web
puede ayudarnos.
Pero no haremos eso.
Por lo que usaremos la existente.
Bien.
Por último, así es como se ve
la pila técnica de Compose.
En un lado tenemos la pila de compilación.

English: 
So Compose is
returning to Kotlin.
And Kotlin actually
unlocks a lot of the things
that we do in Compose.
The way that we design the API
is possible thanks to Kotlin.
We rely heavily on
lambdas, for instance.
And we plan on using fun
features like co-routines.
Adam is chomping at the
bits to add co-routines
all over Compose.
And finally,
compatibility is something
that we deeply care about.
We are not asking you to
rewrite your entire app.
If you want to adopt Compose,
once it's ready for production,
we don't expect you to
just delete all the code,
like we did for Instant Run
and to start from scratch.
We want you to write
your next activity,
or your next fragment,
or to be able to reuse
some of your custom views.
And chances are that some
of the existing views,
we won't even rewrite ourselves.
So things like surface
view or web view.
If any of you wants to
write a new web view,
please come help us.
But we're not going to do that.
So we're going to use
the existing [INAUDIBLE]..
All right.
And finally, this is what the
technical stack of Compose
looks like.
So on the one side, we
have the build time stack.

Chinese: 
所以 Compose 使用 Kotlin
而 Kotlin 会解锁很多 Compose 里的东西
有了 Kotlin 我们才能按照现有的方式来设计 API
比如 我们大量使用了 lambda
而且 我们打算使用协程 (coroutine) 实现一些有趣的功能
Adam 现在正忙着把协程添加到 Compose 里面去
最后 我们非常在意兼容性的问题
我们并不是要大家重写整个应用
如果你想要使用 Compose 
当准备好进入生产环境的时候
我们并不需要你像 Instant Run 里所做的那样
删除所有的代码 再从头开始
我们想让你写下你的下一个 Activity 或 Fragment
或是重新使用你的某些定制视图
就连我们自己都可能不会重写部分现存的视图
比如表面视图或者网页视图等等
如果有谁想要写一个新的网页视图的话
请来帮帮我们
但我们不会这么做的 我们会使用现有的
最后 这是目前的 Compose 技术栈的样子

Indonesian: 
Jadi, Compose kembali
ke Kotlin.
Dan Kotlin membuka
banyak hal yang
kami buat di Compose.
Kami bisa mendesain API dengan
cara ini berkat Kotlin.
Kami sangat bergantung pada lambda
misalnya.
Kami berencana menggunakan fitur
asyik seperti rutinitas bersama.
Adam sedang berupaya untuk
menambahkan rutinitas bersama
di seluruh Compose.
Pada akhirnya,
kompatibilitaslah
yang sangat kami perhatikan.
Kami tidak meminta Anda menulis
ulang seluruh aplikasi.
Jika ingin menerapkan Compose,
saat siap produksi,
kami tidak meminta Anda
menghapus semua kode,
seperti yang kami lakukan pada
Instant Run, dan memulai dari nol.
Kami ingin Anda menulis aktivitas
atau fragmen Anda selanjutnya,
atau bisa memakai lagi
tampilan kustom Anda.
Kemungkinan, beberapa
tampilan yang sudah ada
tak perlu ditulis ulang sendiri.
Hal-hal seperti tampilan di permukaan
atau tampilan web.
Jika ada yang ingin menulis
tampilan web baru,
ayo bantu kami.
Tapi kami tidak akan melakukannya.
Kami akan menggunakan
yang sudah ada.
Oke. Akhirnya,
inilah tampilan tumpukan teknis
Compose.
Di satu sisi, kami harus
membuat tumpukan waktu.

Portuguese: 
Então o Compose está de volta ao Kotlin,
e essa linguagem libera
muitos recursos no Compose.
O design das APIs
é possível graças ao Kotlin.
Usamos muito lambdas, por exemplo.
E queremos usar recursos legais
como as corrotinas.
Adam não vê a hora de
adicionar corrotinas em todo o Compose.
E, por fim,
compatibilidade é muito importante.
Não vamos pedir que reescrevam seus apps.
Se quiserem usar o Compose
quando pronto para produção,
não esperamos
que excluam todo o código
como fizemos com o Instant Run
e comecem do zero.
Queremos que escrevam
a próxima atividade
ou fragmento ou que possam
reutilizar visualizações personalizadas.
Talvez algumas das visualizações atuais
nem sejam reescritas,
como a SurfaceView ou WebView.
Se tiverem interesse em
escrever uma nova WebView,
venham nos ajudar.
Mas não faremos isso.
Vamos usar as existentes.
Beleza.
Esta é a pilha técnica do Compose.

Japanese: 
ComposeをKotlinに戻します
Kotlinにより
自由度が大きく向上します
例えばAPIの設計方法や
ラムダ式の多用などです
またコルーチンなどにも対応する予定です
コルーチンへの対応は
チームとしても大望の変化です
最後は互換性です
非常に重要な分野です
アプリ全体を書き直す必要は
生じません
正式版のComposeを採用すると
コードをゼロから...とはなりません
Instant Runの際とは違います
次のアクティビティや
次のフラグメントを記述して
カスタムビューを一部
再使用可能にします
既存のビューの一部は
変更されないでしょう
SurfaceViewやWebViewなどです
新しいWebViewの作成...
私たちはやりません
ですから既存のビューを使用します
最後に
Composeの技術的スタックの説明です
左はビルドタイムアプローチです

Chinese: 
左边是构建环境 运行在你的主机上
我们使用的是轻微修改过的 Kotlin 编译器
我们和 JetBrains 团队紧密合作
并添加了几个编译器扩展
我们用这些扩展来启用我们的 Compose 编译器插件
这很有意思 因为就在上周 人们还看到
我们为 Compose 增加了 Maven 工件支持
人们开始使用它们 并且觉得它们能用
而我们却告诉他们 不 没有用
我们尚未发布对应的编译器 现在还得等等
它看起来能用 是因为语法是纯粹用 Kotlin 写成的
它只会调用功能 但响应性能不佳 有些令人失望
我们还有 Android Studio 
在运行时方面 底部的 Compose 运行时
是专门处理代码树的 它知道该如何制造出代码树
它不了解 UI 工具箱
所以 我们可以重复利用它 去做一些 UI 之外的事情
此外 我们还有 UI 核心 UI 基础 以及各种 widget
差不多就这些
下面 Clara 会告诉大家 
在你编写代码的时候 Compose 是如何运作的

Korean: 
머신에서 실행되는 호스트에 있죠
그래서 저희는 Kotlin 컴파일러의
약간 수정된 버전을 사용합니다
이를 위해 JetBrains와 긴밀하게 협업합니다
JetBrains와의 협업을 통해
컴파일러 확장을 몇 개
추가한 바 있습니다
이 확장을 통해
Compose 컴파일러 플러그인이
사용 가능해집니다
지난주에
Maven for Compose에서
저희 아티팩트를 보시고
많은 분들이 사용하기 시작하셨습니다
그리고 좋다
효과가 있다라고 하셨지만
우리는 그렇지 않다고 말씀드렸죠
필요하신 컴파일러가
아직 출시되지 않았거든요
그래도 안 믿는 분도 있지요
작동이 되는 것처럼 보이는
이유는 구문이 순수하게
Kotlin이기 때문입니다
함수를 호출만 하는 거죠
아쉽게도 반응성이 그다지 좋지 않습니다
어쨌든 저희에게는
Android 스튜디오도 있습니다
런타임 측면에서는
하단에 있는 Compose가
트리를 다루는 런타임입니다
트리 생성 방법을 알고 있죠
UI 툴킷에만 관여합니다
이것을 UI 외의 작업에
재사용할 수 있습니다
이제 UI 코어, UI 기초, 위젯까지
다 있네요
이게 전부입니다
이제 클라라 씨가 코드 작성 시
Compose의 실제 작동 방법에
대해 말씀드리겠습니다
감사합니다
[박수]

Spanish: 
Está en el host que se ejecuta en su equipo.
Usamos una versión algo modificada
del compilador de Kotlin.
Trabajamos estrechamente con JetBrains.
Con ellos, agregamos algunas extensiones
del compilador, y las usamos
para habilitar el complemento
del compilador de Compose.
Es gracioso, porque la semana pasada
vieron que teníamos los artefactos
en Maven para Compose.
Comenzaron a usarlos.
Y decían: "Oh, genial, funciona".
"No funciona.
"Necesitan el compilador que no se publicó".
"Sí, funciona".
Parece que funciona
porque la sintaxis es puramente Kotlin.
Invoca funciones.
Pero no tenía mucha reacción, una pena.
En fin, también tenemos Android Studio.
Luego, tenemos el tiempo de ejecución.
Compose está al final del tiempo de ejecución
y se encarga de los árboles.
Sabe cómo producirlos.
No sabe sobre el kit de herramientas de IU.
Podríamos reutilizarlo
para hacer otras cosas que no sean IU.
Luego tenemos el núcleo de IU,
que son las bases,
y, por último, todos los widgets más arriba.
Básicamente, eso es todo.
Ahora Clara les contará
cómo funciona Compose cuando escriben código.
Gracias.

Indonesian: 
Itu di host yang berjalan
di perangkat Anda.
Kami menggunakan versi compiler
Kotlin yang sedikit dimodifikasi.
Kami bekerja dengan JetBrains,
dan hanya menambahkan beberapa ekstensi
compiler hasil kolaborasi dengan mereka.
Kami menggunakan ekstensi itu
untuk mengaktifkan plugin compiler
Compose.
Jadi ini lucu, karena minggu
lalu, orang-orang
melihat bahwa kami punya
artefak Compose di Maven.
Mereka mulai memakainya
dan bilang, "Bagus.
ini berfungsi."
Kami bilang, "Tidak.
Anda perlu compiler yang
belum kami rilis."
Kenapa sepertinya berfungsi?
karena sintaksnya murni Kotlin.
Jadi, fungsinya terpicu.
Tidak benar-benar reaktif.
Lalu kami juga punya
Android Studio.
Di sisi runtime, Compose
pada dasarnya adalah
runtime yang menangani
struktur,
dan tahu cara
membuat struktur.
Yang diketahuinya cuma
toolkit UI.
Jadi kami dapat memakainya lagi
untuk selain UI.
Lalu ada inti UI,
fondasi UI,
dan semua widgetnya.
Begitulah kira-kira.
Sekarang, Clara akan menjelaskan
cara kerja Compose
saat Anda menulis kode.
-Terima kasih.

Portuguese: 
De um lado, a pilha de compilação
no host executado na máquina.
Usamos uma versão
levemente modificada do Kotlin Compiler.
Trabalhamos com o JetBrains.
Adicionamos umas extensões do Compiler
com colaboração deles.
E as usamos para ativar
nosso plug-in do Compose Compiler.
É engraçado... Semana passada,
viram que colocamos os artefatos
no Maven do Compose.
E começaram a usar.
Disseram: "Legal funciona!",
e nós: "Não funciona".
Precisamos do Compiler
que ainda não saiu.
Insistiram
que funciona.
Parece funcionar
porque a sintaxe é puro Kotlin.
É só invocar funções.
Não estava nada reativo,
o que é chato.
E temos o Android Studio.
No lado do ambiente de execução,
o Compose, embaixo,
é um ambiente
que processa árvores.
Sabe produzir árvores.
Não conhece nada além do toolkit.
Não podemos reutilizar
para outras coisas além da IU.
Depois, temos o núcleo e a base da IU.
E, em cima, todos os widgets.
É basicamente isso.
Clara vai falar sobre como o Compose
funciona quando você escreve código.
Obrigada.

Japanese: 
ローカルマシンがホストになります
Kotlinコンパイラを
若干変更したものを使用します
JetBrainsと連携し
いくつかのコンパイラ拡張を追加しました
Composeのコンパイラプラグインを
実現しています
先週Composeのアーティファクトが
Mavenにあるのを見た開発者は
使い始めて
「動作してる」と言いました
未公開のコンパイラが必要なので
それは勘違いです
動作したように見えた理由は
シンタックスがKotlinだからです
関数を呼び出しているだけで
反応しませんでした
とにかく
皆Android Studioを使っています
右のランタイムアプローチでは
ツリーの作成方法を理解する
ランタイムが一番下です
UIツールキットとは無関係なので
UI以外にも利用できます
その上には UI Core、UI Foundation
ウィジェットがあります
次は クララの番です
コードを記述する際の
Composeの実際の機能を説明します

English: 
So that's on the host
that runs on your machine.
So we use a slightly modified
version of the Kotlin compiler.
So we work closely
with JetBrains.
We just added a couple compiler
extensions in collaboration
with them.
And we use those extensions
to enable our Compose compiler
plugin.
So it's funny, because
last week people
saw that we had the artifacts
on Maven for Compose.
And people started using them.
And they're like, oh, great.
It works.
We're like, no, it doesn't work.
You need the compiler that
we haven't released yet.
Like no, it works.
The reason it seems to work
is because the syntax is just
pure Kotlin.
So it's just invoking functions.
It was just not very reactive at
all, which is kind of a bummer.
Anyway, and so we also
have Android Studio.
And then on the runtime side,
so Compose at the bottom
is a runtime that
just deals with trees.
It knows how to produce trees.
It doesn't know
anything but UI toolkit.
So we could reuse it to
do other things than UI.
Then we have the UI
core, the UI foundations,
and, finally, on
top, all the widgets.
So that's pretty much it.
And now Clara will tell you
more about how Compose actually
works when you write code.
CLARA BAYARRI: Thank you.
[APPLAUSE]

Indonesian: 
Maaf.
Lanjutkan tepuk tangannya.
Saya ingin menjelaskan
beberapa hal
yang perlu dpahami
untuk benar-benar
bisa memanfaatkan Compose,
yaitu konsep dasarnya.
Yang pertama adalah
fungsi composable .
Roman sudah menyebutkannya
beberapa kali.
Fungsi composable
adalah fungsi biasa,
yang mengambil masukan,
lalu menentukan UI yang ditampilkan
berdasarkan masukan itu.
Jadi fungsi ini mengubah data aplikasi
menjadi hierarki UI.
Membuat fungsi yang bisa
disusun sangatlah mudah.
Misalnya, kita punya composable
sambutan.
String-nya berupa nama.
Lalu kita hapus sebuah elemen teks
yang menggunakan string itu.
Teks adalah salah satu komponen
yang akan kami sediakan.
Ini contoh
tampilan teks.
Ini akan menampilkan teks
di layar.
Yang menarik adalah karena
ada runtime
dan compiler di belakang,
kapan pun masukan diubah,
misalnya nama yang
ingin diubah,
kami yang akan mencari tahu
perubahannya,
dan menjalankan kembali fungsinya,
dan menemukan apa yang harus
diubah di hierarki UI.
Anda hanya perlu jelaskan
apa yang ingin dilihat.
Dan kami tangani sisanya.

Japanese: 
ありがとう
おっと 拍手がまだでした
Composeを扱う際に
理解しておくべき事を説明します
基本のコンセプトです
まず コンポーズ可能な関数です
先ほど何度か話に出ましたね
コンポーズ可能な関数は 単なる関数です
入力を基に UIでの表示内容を決定します
アプリケーションデータを
UI階層に変換するとも言えます
コンポーズ可能な関数の作成は
実に簡単です
たとえばここにGreeting関数があり
nameをStringとします
ここでは 文字列から
テキスト要素を出力します
Textは
提供予定のコンポーネントです
TextViewと同等で
画面にテキストを表示します
ここで たとえば渡すnameなどの
入力を変更した場合
ランタイムとコンパイラが
変化を特定して関数を再度呼び出します
UI階層で必要な変更が分析され
特定されます
つまり 表示したい内容を記述するだけで
後はお任せです

Spanish: 
Lo siento.
Este es tu aplauso.
Les hablaré de algunos conceptos básicos
que deben comprender
para poder usar Compose.
El primero es las funciones componibles.
Sé que Romain mencionó esto algunas veces.
Pero son simplemente funciones.
Es una función que toma una entrada
y decide qué IU mostrar
en función de esa entrada.
De alguna manera,
transforma los datos de su aplicación
en la jerarquía de IU.
Crear una función componible es muy fácil.
Consideren esta función componible de saludo.
Toma una string como nombre
y decide emitir un elemento de texto
que usa esa string.
El texto es uno de los componentes
que proporcionaremos.
Es el equivalente a una vista de texto.
Muestra texto en la pantalla.
Lo interesante es que,
como tenemos el tiempo de ejecución
y el compilador detrás,
cuando cambian la entrada,
por ejemplo, si cambian el nombre que pasan,
podremos ver qué cambió,
volver a invocar la función
y descubrir qué debemos cambiar
en la jerarquía de la IU.
Ustedes describen lo que quieren ver,
y nosotros nos encargamos del resto.

English: 
Sorry.
Get your applause.
I want to walk you
through some of the things
that you need to
understand to really
be able to play with Compose,
some of the basic concepts.
The first one is
composable functions.
I know Romain has kind of thrown
this term out a few times.
But a composable function
is just a function.
It's a function that
takes some input,
and just decides what UI to
show based on that input.
So in a way it transforms
your application data
into your UI hierarchy.
Creating a composable
function is very, very easy.
So, for example, we have
this greeting composable.
It takes a name as a string.
And it just decides
to emit a text
element that uses that string.
Text is one of the components
that we will provide for you.
It is the equivalent
of a text view.
So it shows a text
on the screen.
The interesting thing here is
because we have the runtime
and the compiler behind us,
whenever you change that
input-- so say the name you're
going to pass through changes--
well, then we take
care of figuring out
what changed,
re-invoke the function,
and figure out what we need
to change in the UI hierarchy
for you so at any point
you are just describing
what you want to see.
And we'll take care of the rest.

Portuguese: 
Desculpe.
Roubei seus aplausos.
Quero explicar alguns pontos
que precisam entender
para usar o Compose,
alguns aspectos básicos.
O primeiro são
funções combináveis.
Sei que Romain usou esse termo
algumas vezes.
Mas uma função combinável
é só uma função.
Ela recebe uma entrada
e decide o que é exibido na IU
com base nessa entrada.
Ela transforma os dados do
seu aplicativo na sua hierarquia de IU.
É muito fácil criar uma
função combinável.
Por exemplo,
temos esta combinável "greeting".
Ela usa um nome como string.
E decide emitir
um elemento de texto que usa essa string.
"Text" é um dos componentes
que vamos fornecer a vocês,
é equivalente a uma TextView.
E mostra um texto na tela.
Como temos o ambiente de execução
e o Compiler no apoio,
sempre alterar a entrada, como o nome,
notamos o que mudou,
invocamos a função de novo
e vemos o que mudar na hierarquia de IU.
Então, o tempo todo,
você só descreve o que quer ver.
E fazemos o resto.

Korean: 
잠깐만요
박수 받으셔야죠
저는 Compose를 제대로 이용하기 위해
파악해야 하는 내용과 기본 개념을
설명드리겠습니다
첫 번째는 composable 함수입니다
로만 씨도 이 용어를
몇 번 언급하셨습니다
composable 함수는
말 그대로 함수입니다
입력을 처리하고 입력된 것을 기반으로
어떤 UI를 표시할지 결정하죠
애플리케이션 데이터를 UI 계층으로
변환하는 역할을 합니다
composable 함수는
아주 쉽게 생성할 수 있습니다
예를 들어 여기 인사말
composable 함수가 있습니다
이 함수는 문자열로 이름을 취합니다
그리고 해당 문자열을
사용하는 텍스트 요소를
표시할지를 결정합니다
텍스트는 저희가 제공하는
구성요소 중 하나입니다
이는 텍스트 뷰에 상응하는 것입니다
그래서 화면에
텍스트를 표시해 줍니다
흥미로운 점은
런타임과 컴파일러가 있으므로
입력을 변경할 때, 가령
이름을 변경하는 경우
저희는 무엇이 변경되었는지 파악하고
함수를 다시 호출한 뒤
UI 계층 내에서 무엇을
변경해야 하는지 파악합니다
따라서 보고자 하는 것을
그저 설명만 하면
됩니다
나머지는 저희가 처리합니다

Chinese: 
谢谢 抱歉 等掌声结束
我想为大家讲解一些 Compose 的基本概念
第一就是组合式 (Composable) 方法
我知道 Romain 已经多次提及了这个词
但是组合式方法依然是方法
这个方法需要一定的输入
并决定根据这些输入应该显示什么 UI
所以 可以说它把你的应用数据转变成了 UI
创建组合式方法是非常简单的
比如这个 @Composable 方法 Greeting
它接收一个字符串的 name
并生成一个包含这个字符串的结果文本
而文本正是我们要提供给你的组件之一
它相当于文本视图 会在屏幕上显示文本
有趣的是 因为我们有运行时和编译器在后面支持
所以 无论你在何时更改输入内容 比如更改 name
我们就会负责找出改变发生的位置
重新调用相关方法
找出我们应该在 UI 中改变什么元素
所以 无论何时 你只需要描述出你想看到什么
其余的事情就可以交给我们

Indonesian: 
Misalnya, kita ingin buat
artikel berita.
Beberapa composable
bisa dihilangkan
dalam fungsi composable.
Jadi, kita bisa hilangkan
judul, subjudul, dan tanggal.
Dan kita fokus 
membuat artikel berita.
Cara ini bisa digunakan.
Tapi kemudian
Anda akan perlu
pendapat tentang bagaimana
cara menampilkan UI.
Karena jika hanya itu,
inilah yang Anda dapatkan,
tidak seperti yang diinginkan.
Di sinilah konsep nomor
dua, tata letak, diperlukan.
Kami membuat banyak
tata letak yang bisa langsung digunakan
agar Anda bisa menempatkan
item di layar
sebanyak yang Anda mau.
Misalnya, kita bisa menggabungkan
tiga teks itu di satu kolom.
Kolom setara dengan
tata letak linear vertikal.
Kita tempatkan semuanya saling
bertumpukan.
Dan ini akan terlihat
lebih seperti keinginan kita kan?
Ada judul, subjudul,
dan tanggal.
Developer Android
masih terbiasa
untuk bisa menyesuaikan
banyak hal.
Mungkin Anda berpikir,
"Ini bagus sih, tapi
teks saya terlalu dekat
dengan pinggir layar."
Jadi kita bisa lebih lanjut
menambahkan ruang.
Dan ini akan
membuat ruang di sekitarnya

English: 
Say, for example, we want
to build a news story.
We can actually omit
several composables
within a composable function.
So we can omit, say, a
title, subtitle, and a date.
And we're just going to
build our news story.
This is absolutely fine.
But you will find
you kind of need
to have an opinion on how
you want your UI to show.
Because if you just do
this, you will end up
with something like this, which
is not really what you wanted.
So this is where concept
number two, layouts, come in.
We are building out a
bunch of layouts for you
out of the box to make sure
that you can place things
on screen as much as you want.
So, for example, we can wrap
those three texts in a column.
Column is the equivalent of
a vertical linear layout.
So we'll just place everything
one on top of the other.
So then suddenly this looks more
like what we were expecting.
Right?
So we have our title,
subtitle, and date.
Still, Android
developers are used
to being able to
customize a lot of things.
You'll be like, ah,
you know, this is nice,
but my text is really stuck
to the side of the screen.
So we can go a bit
further, add some spacing.
And what that will do is just
create the spacing around it
that we need to make
it look a bit better.

Portuguese: 
Por exemplo,
queremos criar uma notícia.
Podemos emitir várias combináveis
numa função combinável.
Podemos emitir um título,
um subtítulo e uma data.
E vamos apenas criar a notícia.
Tudo bem.
Mas é preciso dizer
como a IU será exibida.
Porque se fizer só isso,
vai acabar com algo assim,
o que não é legal.
Aqui entra o segundo conceito, layouts.
Estamos criando layouts
prontos para usar
para garantir que vocês possam
colocar na tela quantos itens quiserem.
Por exemplo, podemos juntar os
três textos em uma coluna.
A coluna equivale a um
layout linear vertical.
Estamos colocando
uma coisa em cima da outra.
E aí vai ficando mais parecido
com a expectativa.
Temos título, subtítulo e data.
Mas desenvolvedores Android
costumam personalizar várias coisas.
Isso até que é legal,
mas o texto está bem perto da borda.
Podemos adicionar espaçamento.
O que isso faz é criar o espaçamento
em volta para deixar mais bonito.

Chinese: 
比如 我们想构建一个新故事 (NewStory)
我们可以在组合式方法内生成多个 composable 
比如我们可以生成标题 副标题 日期等
然后我们就可以构建我们的新故事了
这完全没有问题
但是大家可能会发现 你们会需要了解
你们希望 UI 以怎样的方式展现出来
因为 如果你这样做的话
你会得到这样的结果 并不是大家所希望的
这时就要讲讲第二个概念了 也就是布局
我们为大家构建了很多直接可用的布局
这样大家就可以在屏幕上放置自己想要的任何东西
例如 我们可以把这三段文本封装进一个列里
列 相当于垂直线性布局
我们把所有东西都这样堆叠起来
然后 突然之间 结果就变得符合我们的期望了
这样一来 标题 副标题 日期都齐了
Android 开发者历来喜欢定制很多东西
你们可能会觉得 这个虽然不错
但是我的文本会被挤在屏幕的边角上
所以我们可以再进一步 添加一些留白
这样可以在它周围创造出一些空间
让视觉效果更好一些

Korean: 
예를 들어 뉴스 기사를
작성한다고 가정하겠습니다
composable 함수 내의
구성 가능 항목 몇 개를
생략할 수 있습니다
예를 들어 제목, 부제목,
날짜를 생략할 수 있습니다
그리고 뉴스 기사를 작성합니다
여기에는 아무런 문제가 없습니다
그런데 UI 표시 방식을
결정해야 할 필요에 직면합니다
이 상태로 그대로 진행할 경우
이처럼 원하지 않았던
결과를 얻게 되기 때문이죠
그래서 여기에서 바로
두 번째 개념인 레이아웃이 필요합니다
원하는 대로 화면에 배치할 수 있도록
즉시 사용 가능한 수많은 레이아웃을
마련하는 중입니다
예를 들어 저희는 한 열에 있는
텍스트 세 개를 줄바꿈할 수 있습니다
열은 수직 선형 레이아웃에 해당합니다
이제 하나하나 층별로 배치되는 거죠
그러면 저희가 원했던 것에 가깝습니다
그렇죠?
이제 제목, 부제목, 날짜가 생겼습니다
여전히 Android 개발자들은
많은 것들을
커스터마이징하는 데 익숙합니다
이거 좋은데? 하면서 말이죠
그런데 텍스트가 화면 한쪽에
바짝 붙어있네요
여백을 좀 추가해야겠네요
주변에 여백을 생성하고
좀 더 보기 좋게 만듭니다

Japanese: 
たとえばニュース記事を作成する場合
コンポーズ可能な関数内で
いくつかの要素を除外できます
たとえば
タイトルやサブタイトルや日付です
そしてニュース記事を作成します
まったく問題ありません
でもUIの表示方法について指示がないと
画面が真っ白です
これはひどいですね
ここで第２のコンセプト
つまりレイアウトが登場します
すぐに使える数多くのレイアウトの中から
好きなように画面要素を配置できます
たとえば３つのテキストを
columnにまとめられます
これは垂直のLinearLayoutと同等です
すべて上下に並べて配置します
すると 求めていた表示になります
タイトル、サブタイトル
日付が表示されました
Android開発には
カスタマイズが必須ですね
テキストが画面の端まであるので
スペースを追加しましょう
Spacingにより
周囲にスペースができました
見た目が改善しました

Spanish: 
Supongamos que queremos compilar una noticia.
Podemos omitir varios elementos componibles
dentro de una función componible.
Por ejemplo, un título,
un subtítulo y una fecha.
Entonces, compilaremos nuestra noticia.
Esto está muy bien.
Pero verán que necesitan
una opinión acerca de cómo quieren
que se vea su IU.
Porque si usan esto,
terminarán con algo como esto
que no es realmente lo que querían.
Aquí aparece el segundo concepto: el diseño.
Estamos creando algunos diseños para ustedes
para que puedan colocar todo lo que quieran
en la pantalla.
Por ejemplo, podemos agrupar
esos tres textos en una columna.
La columna es el equivalente
a un diseño lineal vertical.
Colocaremos uno encima del otro.
De pronto, se ve similar
a como lo esperábamos.
¿Bien?
Tenemos el título, el subtítulo y la fecha.
Los desarrolladores de Android
están acostumbrados
a poder personalizar muchas cosas.
Ustedes dirán: "Esto es lindo,
"pero el texto está atascado
a un lado de la pantalla".
Entonces, podemos avanzar
y colocar algunos espacios.
Crearemos el espacio necesario alrededor
para que se vea un poco mejor.

Portuguese: 
Até agora,
construímos toda essa IU com uma função.
Indo além,
a coluna não é feita só de texto.
Sei que usei três textos aqui.
Mas podemos inserir qualquer coisa.
Podemos mostrar uma imagem
usando uma função combinável de imagem
e construir a IU assim.
Ah, sim.
Desculpe.
Fornecemos vários layouts prontos.
Pronto.
"Row", que posiciona itens na horizontal.
"Column", que posiciona na vertical.
Fáceis de entender.
E há coisas mais avançadas,
como o "Flex" que apresentamos
e acredito que seja novo no Android.
E estamos criando mais.
Bem mais para vocês testarem.
E estamos trabalhando no
"ConstraintLayout".
Mas ainda não está pronto.
Esperem que já vem.
Então, criamos um layout.
Mas vocês querem
que criemos componentes, certo?
O Compose tem componentes integrados
que ajudam vocês a começar.

English: 
So until now, we've
built this entire UI
just as like one function.
Right?
Going a bit further, column
doesn't just take text.
I know I used three
text as an example.
But we can throw
anything in there.
So, for example, we can
just display an image
by using an image
composable, and then
build up our UI in this way.
Huh.
Oh, yes.
Sorry.
We're providing a bunch
of layouts out of the box.
There you go.
We have row, which will
place things horizontally.
We have column, which will
place things vertically.
Those are easy to understand.
We have more advanced things.
For example, we've
introduced flex, which
I believe is new to Android.
We're building a bunch more.
There's a bunch more in there
that you can go and play with.
And we are working
on ConstraintLayout.
But it's just not there yet.
So look forward to that coming.
And then, well,
we've built a layout,
but really what you want is for
us to build components for you.
Right?
So Compose comes
with a bunch of built
in components that should
make it really easy for you
to get kickstarted.
First of all, we've
partnered very heavily

Korean: 
지금까지 전체 UI를 하나의 함수처럼
구현했습니다
그렇죠?
하나 더 말씀드리자면
열은 텍스트만 취하지 않습니다
텍스트 세 개를 예시로 들었지만
무엇이든 입력할 수 있습니다
예를 들어
image composable 함수를 사용하여
이미지만 표시할 수도 있고
UI를 이러한 방식으로
빌드해 나갈 수 있습니다
어?
아, 네
죄송합니다
저희는 즉시 사용 가능한
수많은 레이아웃을 제공하고 있습니다
됐군요
행을 통해 항목을
가로로 배치할 수 있습니다
열을 통해서는 항목을
세로로 배치할 수 있습니다
이해하기 쉽죠
이제 심화 내용입니다
예를 들어 flex를 도입했는데요
Android에 처음 추가된 것 같습니다
저희는 더 많은
레이아웃을 만들고 있습니다
활용하실 수 있는
레이아웃이 엄청나게 많습니다
ConstraintLayout도
만드는 중입니다
아직 출시가 되지 않았지만
곧 출시되길 기대합니다
레이아웃을 만들었는데
진짜 원하시는 것은
구성요소 구현일 것입니다
맞나요?
Compose에는 순조로운 시작을 위해
기본 제공되는 여러 구성요소가
있습니다
저희는 머티리얼팀과

Indonesian: 
sesuai keinginan kita untuk
membuatnya tampak lebih baik.
Jadi, telah membuat seluruh UI
ini seolah satu fungsi saja.
Benar kan?
Lebih jauh, kolom bukanlah
sekadar mengambil teks.
Tiga teks tadi hanya contoh.
Kita bisa masukkan apa saja.
Misalnya, kita bisa
tampilkan gambar
menggunakan image composable,
lalu buat UI dengan cara itu.
Oh, iya.
Maaf.
Kami menyediakan banyak
tata letak yang siap pakai.
Itu dia.
Ada baris, yang menata
item secara horizontal.
Ada kolom, yang menata
item secara vertikal.
Mudah dipahami.
Ada juga yang lebih rumit.
Misalnya flex,
yang saya yakin
masih baru di Android.
Kami membuat banyak lainnya.
Ada banyak lainnya yang bisa Anda
pakai dan sesuaikan.
Kami juga mengerjakan
ConstraintLayout.
Tapi belum selesai.
Tunggu saja kedatangannya.
Meski sudah
membuat tata letak,
sebenarnya Anda ingin
kami membuat komponennya, kan?
Compose dilengkapi
dengan berbagai
komponen internal yang akan
memudahkan Anda
memulai.

Japanese: 
このように UI全体を
１つの関数として作成できます
さらにcolumnが扱うのは
テキストだけではありません
例は３つのテキストでしたが
何でも扱えます
たとえば画像コンポーザブルを使用して
画像を表示し
UIをビルドできます
あれ？
すみません
すぐに使用できるレイアウトを
多数用意しています
例えば 水平配置用のRowと
垂直配置用のColumnです
他にも より高度な
Flexを導入しました
これはAndroidでは初となります
さらに多くを構築中です
ConstraintLayoutも
構築中です
ご期待ください
さて レイアウトの次は
コンポーネントの構築です
Composeでは 組み込みコンポーネントが
多数用意されています

Spanish: 
Hasta ahora, compilamos toda esta IU
como una función.
¿Verdad?
La columna no acepta texto.
Sé que usé tres textos como ejemplo
pero podemos tirar todo ahí.
Por ejemplo, podemos mostrar una imagen
con un componible de imagen
y luego compilamos la IU de esta manera.
Oh.
Ah, sí.
Lo siento.
Incluimos algunos diseños listos para usar.
Ahí está.
La fila pondrá los elementos horizontalmente.
La columna los colocará verticalmente.
Es fácil de entender.
Hay elementos más avanzados.
Por ejemplo, incorporamos flex
que creo que es algo nuevo en Android.
Estamos compilando algunos más.
Hay muchos más elementos que pueden probar,
y estamos trabajando en ConstraintLayout.
Pero todavía no llegamos a eso.
Esperamos verlo pronto.
Una vez compilado el diseño
lo que quieren es que creemos componentes.
¿Verdad?
Compose incluye un montón de componentes
que deberían facilitarles el comienzo.

Chinese: 
到目前为止 我们把整个 UI 当作一个方法来构建
然后 列 并不只能放文本
我知道 我使用了三段文本来举例
但是 其实向其中加入任何东西都是可以的
例如 我们可以使用图像 composable 显示一些图像
然后按照这种方式来构建我们的 UI
哦 忘了一件事 我们提供了很多开箱即用的布局
我们有 行 它会把内容按照水平方向排列
我们还有 列 它会把内容按照竖直方向排列
这些都很好理解
我们还有一些高级东西
例如 我们推出了 Flex
这也是 Android 体系首次推出这个
我们正在构建更多的新功能 供大家使用
我们还在努力改进约束布局
但目前还在研发中 敬请期待
我们构建了布局 但大家真正想要的是
让我们为大家构建组件
Compose 内置了大量组件 可以帮助大家轻松起步

Spanish: 
Primero, nos asociamos
con el equipo de Material Design.
Porque queremos asegurarnos
de que esté disponible de inmediato.
Por lo que comenzamos
a crear componentes de Material.
Todavía no están todos allí.
Pero el equipo estuvo trabajando
para poder crear esas hermosas IU.
Ya contamos con botones,
casillas de verificación
y elementos más complejos.
Barras de apps, paneles laterales.
Algunas se están creando.
Llegaremos allí.
Pero ya cuentan con las piezas básicas
para compilar una app de muestra.
Supongamos que queremos
compilar esta tarjeta de Material
en función del ejemplo
que teníamos antes con la imagen
y los tres textos.
Tomaremos el código que teníamos.
No cambié nada.
Lo colocamos en una tarjeta.
Podemos darle forma a la tarjeta
porque, al ser de Material,
pueden elegir cómo se verá el borde.
Por ejemplo, quiero bordes redondeados.
Podemos diseñar el estilo
para que se vea mejor que antes.
Dirán que estamos profundizando
en el estilo de texto.
Eso es un poco raro.
Volvamos a las especificaciones de Material.

English: 
with the Material team.
Because we want to make sure
Material is out of the box
just there for you.
So we started creating
the Material components.
They're not all there yet.
But the team has already
been hard at work to be able
create those beautiful UIs.
And we already have things
like buttons, checkboxes,
and a bit more complex things.
App bars, drawers.
Some of these pieces
are in their influx.
We'll get there.
But you already have
the basic pieces
to build something
like a sample app.
So say we want to build
this Material card,
building up on the example
we had before with the image
and the three texts.
Well, we'll take the
code we've had before.
I haven't changed anything.
We wrap it in a card.
And we can give a
card a shape, cause
this is a material thing
that you can choose what
your corner should look like.
So, for example, I want
rounded corners on my card.
We can style the text to look
prettier than it was before
with the three same styles.
And you'll say, here you're
reaching into a theme text
style.
This looks a bit weird.
So let's take a step back
to the Material spec.

Japanese: 
マテリアルチームと緊密に連携しました
マテリアルを簡単に使えるよう
マテリアルコンポーネントを作成しました
一部はまだ未完成ですが
美しいUIの作成に役立ちます
ボタンやチェックボックス
アプリバーやドロワーなど
複雑なものもすでにあります
Influxも追加予定です
サンプルアプリなどの
ビルドに必要なものは揃っています
このマテリアルカードを
作成してみます
先程の画像と３つのテキストで
構築されています
先程と同じコードを使います
カードに収めます
カードの形状を指定できます
角の見た目を選択できる
マテリアル要素です
例えば角丸にしてみます
同じ３つのスタイルを使用して
テキストの表示を
より美しくできます
themeTextStyleを使用します
あれ？と思うかもしれません
マテリアルの仕様に戻りましょう

Portuguese: 
Cooperamos
com a equipe do Material Design.
Queremos garantir que
o Material Design esteja pronto para uso.
Começamos a criar
os componentes do Material Design.
Ainda não estão todos aí.
Mas, com muito trabalho,
a equipe criou essas IUs lindas.
Já temos botões, caixas de seleção
e outros itens mais complexos.
Barras e gavetas de apps.
Algumas peças já estão prontas.
Chegaremos lá.
Já há peças básicas
para criar um app de amostra.
Digamos que queremos
criar este card no Material Design,
aproveitando o exemplo anterior
da imagem e dos três textos.
Vamos usar o código anterior.
Não mudei nada.
Vamos unir em um card.
E vamos dar forma a ele porque é possível
escolher a aparência dos cantos.
Digamos que eu queira
bordas arredondadas.
Podemos estilizar o texto para
deixar mais bonito com os três estilos.
Estou chegando a um themeTextStyle,
talvez pareça estranho.
Vamos voltar
à especificação do Material Design.

Korean: 
긴밀히 협력하고 있습니다
즉시 사용 가능한
머티리얼을 제공하기
위해서입니다
그래서 저희는 머티리얼
구성요소를 만들기 시작했습니다
아직 완성되지는 않았습니다
하지만 멋진 UI를 만들기 위해
팀에서 노력을 기울이고 있습니다
이제 버튼, 체크박스 그리고 좀 더 복잡한
앱 바, 창 등이
준비되었습니다
이 중 일부는 도입 중에 있습니다
향후 완료될 예정입니다
하지만 일단 샘플 앱 같은 걸 만드는 데 필요한
기본 요소는 갖춰졌습니다
이제 머티리얼 카드를 만들 건데요
이전에 사용한 이미지와 텍스트 세 개를
활용하겠습니다
이전에 사용했던 코드도 활용합니다
아무것도 바꾸지 않았습니다
카드에 적용하겠습니다
카드의 모양을 정할 수 있습니다
모서리 모양을 선택할 수 있는
머티리얼이기 때문입니다
모서리를 둥글게 만들고
싶다고 가정하겠습니다
스타일 세 개로 이전보다 보기 좋게
텍스트 스타일을 바꿀 수 있습니다
테마 텍스트 스타일도 손볼 수
있습니다
이건 좀 이상해 보이네요
그럼 이제 머티리얼 사양을 살펴보겠습니다

Indonesian: 
Pertama, kami bekerja
sama dengan tim Material.
Karena ingin memastikan Material
ini langsung bisa
Anda pakai.
Jadi kami mulai membuat
komponen Material.
Belum semua yang tersedia.
Namun tim sudah bekerja
keras agar dapat membuat
UI yang cantik itu.
Dan kami juga punya
tombol, kotak centang,
dan komponen rumit lainnya,
Seperti panel aplikasi,
dan panel samping.
Beberapa item masih
dalam influks.
Akan segera siap.
Tapi Anda sudah bisa
mendapatkan item dasar
untuk membuat yang
seperti contoh aplikasi.
Katakanlah kita ingin membuat
kartu Material ini,
mulai buat dengan 
gambar dan tiga teks
seperti contoh tadi.
Tinggal ambil kode yang kita punya tadi.
Saya belum mengubah apa pun.
Kita gabungkan dalam sebuah kartu.
Dan kita bisa memberikan bentuk
pada kartu itu,
karena inilah sifat material.
Kita bisa pilih tampilannya.
Misalnya, saya ingin kartu
bersudut bundar.
Kita dapat memformat teks
agar lebih cantik dengan
tiga gaya yang sama.
Saat mencapai gaya teks bertema,
Mungkin Anda merasa agak aneh.
Jadi mari mundur ke
spesifikasi Material.

Chinese: 
首先 我们与 Material 团队深度合作
因为我们想要确保 Material 开箱即可用
所以我们开始创建 Material 组件
虽然还没有全部完工
但团队已经在努力工作 创建美丽的 UI
而且现在已经完成了按钮 勾选框 
以及比较复杂的一些组件
比如应用栏 抽屉菜单等
不少组件已经在完成的路上了
现在已经有了基本的组件 可以用来构建示例使用了
我们想在之前提到过的范例的基础上
利用图片和三段文本构建这个 Material 卡片
我们会使用之前的代码 不加改动
我们把它封装在这个卡片里
我们可以给卡片规定一个形状 
因为 你可以根据 Material 的原则
设置圆角尺寸
例如 我想让我的卡片拥有圆角
我们可以更改文本的样式 让它更加美观
大家可以看到 这里实现了一个主题文本样式
看起来有点怪
我们来退回一步 回到 Material 规范

English: 
So in the Material spec
there's a definition
of all the typographies that
you could define in your app.
So how you define all the
styling of your entire app.
There's a pre-set amount of
textiles that you could use,
just like they have a color
system and a shape system.
We've built this out
of the box for you.
So if you buy into
the Material system
we have a Material
theme composable
that allows you to configure
all of the colors, all
of the typography, all of the
shapes you need for your app.
And then when you put
this in your hierarchy,
any other Material
component you're using
will know how to read all these
values by default so you don't
have to actually style them.
Similarly, you can
reach into these values.
And that's what I'm
doing in this example.
So I'm saying, out
of these three texts,
I'm reaching into
the style and saying
I want H6, subtitle
one, and body one.
It's a very easy way to style if
you've set up all your styling
for your app correctly.
And finally, to
finish the app, I
can add a row with
a couple of buttons.
Again, we've provided the
material implementations
of buttons.
So material defines three
different kinds of buttons.
There is contained,
outline, and text buttons.
And you will find that we
keep the same terminology

Korean: 
머티리얼 사양에서는
앱에서 사용할 수 있는
모든 글꼴을 확인할 수 있습니다
이렇게 앱 전체의
스타일을 결정할 수 있습니다
색상 시스템과 모양 시스템이 있듯이
사정 설정된 분량의
텍스트 스타일도 있습니다
즉시 사용 가능하도록 만들었습니다
머티리얼 시스템에 관심이 있으시다면
앱에 필요한 모든 색상, 글꼴
모양을 구성할 수 있는
MaterialTheme
구성 가능 항목을 활용하실 수 있습니다
이를 계층 구조에 배치하면
사용 중인 다른 머티리얼 구성요소가
기본적으로 이 모든 값을
읽는 방법을 파악하기 때문에
스타일을 직접 손보실 필요가 없습니다
이러한 값들을 수정하실 수도 있습니다
예시로 보여드리듯이 말이죠
이 세 가지 텍스트 중에
스타일을 먼저 작업하여
H6, 부제목, 본문 스타일을
적용한다고 가정하겠습니다
앱의 스타일 설정을 제대로 완료하면
스타일을 지정하기 매우 쉽습니다
이제 앱을 완성하기 위해
버튼이 있는 열을 추가하겠습니다
버튼을 구현하기 위한
머티리얼이 제공됩니다
머티리얼은 세 종류의 버튼을 지정합니다
채움 버튼, 테두리 버튼
텍스트 버튼이 있습니다
무언가를 쉽게 찾을 수 있도록
저희는 동일한 용어를

Indonesian: 
Di spesifikasi Material,
ada definisi
semua tipografi yang dapat
Anda definisikan di aplikasi.
Jadi bagaimana Anda mendefinisikan
gaya aplikasi Anda.
Ada sejumlah teks yang sudah
ditetapkan yang bisa dipakai,
ada sistem warna dan
sistem bentuknya.
Kami membuatnya agar 
siap pakai.
Jadi jika Anda masuk ke
sistem Material,
ada tema Material
composable
yang memungkinkan Anda
mengonfigurasi semua warna,
tipografi, dan bentuk yang Anda
perlukan untuk aplikasi.
Saat diterapkan ke hierarki,
komponen Material lain
yang Anda gunakan akan
mengetahui cara membaca semua
nilai ini secara default, jadi Anda
tak perlu memberi gaya.
Anda juga dapat mengakses
nilai ini.
Itulah yang saya lakukan
dalam contoh ini.
Jadi, dari tiga teks ini,
saya akan
mengubah gayanya dan
menentukan bahwa
saya ingin H6, subjudul satu,
dan bodi satu.
Mengubah gaya sangat mudah
dilakukan jika Anda menyiapkan
semua gaya untuk aplikasi dengan benar.
Terakhir,
untuk menyelesaikan aplikasi,
saya bisa tambah
beberapa baris tombol
Sekali lagi, kami telah sediakan
implementasi material tmobolnya
Material mendefinisikan tiga
jenis tombol.
Ada tombol tertampung, tombol
outline, dan tombol teks.
Anda bisa lihat kami
menggunakan istilah yang sama

Japanese: 
ここでは アプリで定義可能なすべての
タイポグラフィが定義されています
アプリ全体のスタイルの定義です
使用できるテクスタイルが
事前に決まっています
カラーシステムや
シェイプシステムのようにです
これらは 簡単に使えます
マテリアルシステムの
MaterialThemeでは
アプリに必要なすべての色
すべてのタイポグラフィ
すべての形状を設定できます
これを階層に入れると
他の既存の
マテリアルコンポーネントは
最初からこれらの値を理解するので
スタイルは不要です
これらの値は 簡単に適用できます
この例では ３つのテキストに
h6 subtitle1 body1
のスタイルを適用しています
アプリのスタイルを
すべて適切に設定していれば
非常に簡単なスタイルの方法です
最後に
Rowでボタンを追加します
ボタンのマテリアルも
用意されています
マテリアルでは ３種類のボタン
Contained、Outlined、
Textが定義されています

Chinese: 
在 Material 中 有一个说明
它定义了你在应用中可能定义的所有字体
那么你要如何定义整合应用内部各处的字体呢
你可以使用一些预设的字体样式
它们有自己的颜色系统和形状系统
我们把它们做成了开箱即用的状态
如果你采用了 Material 体系
我们就会提供 MaterialTheme composable
可以让你配置所有颜色 所有字体和形状
然后 当你把它们放进 UI 后
你在使用的其他 Material 组件都会自动掌握
读取这些数值的方法 所以你无需再安排它们的样式
此外 你还可以获取这些数值
我在这个示例中所做的正是如此
我的指令是 在这三段文本中 我获取这些数值
然后请求 H6 副标题1 主体1
如果你为应用设置好了所有的样式 设定样式就会很容易 
最后 为了完成应用 我可以添加一个行 其中带有几个按钮
我们提供了 Material 风格的按钮实现
Material 会定义三种不同的按钮
包含式 边框式 以及文本式
你会发现 我们使用的是同样的命名规则 简化了搜索

Spanish: 
Allí hay una definición
de todas las tipografías
que podrían definir para su app.
¿Cómo se define el estilo de toda su app?
Pueden usar varios estilos
de texto predefinidos
y también tienen un sistema de color
y un sistema de forma.
Integramos estas funciones para ustedes.
Si los convence el sistema de Material
tenemos un componible de tema de Material
que les permite configurar los colores
toda la tipografía,
y todas las formas para su app.
Luego, colocan todo en la jerarquía
y cualquier otro componente
de Material que utilicen
sabrá cómo leer estos valores
de manera predeterminada
y no tendrán que configurar su estilo.
De igual modo, pueden llegar a estos valores.
Es lo que hago en el ejemplo.
De estos tres textos, busco el estilo
y digo que quiero H6
subtítulo 1 y cuerpo 1.
Es una forma muy simple de cambiar el estilo
si configuraron el estilo
de su app correctamente.
Por último, para finalizar la app
puedo agregar una fila con algunos botones.
También proporcionamos
las implementaciones de Material
de los botones.
Material define tres tipos de botones:
contenidos, con contorno y de texto.
Verán que mantenemos la misma terminología

Portuguese: 
Nela, há uma definição
das tipografias que um app pode ter.
Como você define
o estilo de todo o app.
Há um conjunto predefinido
de estilos de texto para usar,
e também sistemas de cores e formas.
Criamos isso para uso imediato.
Então, se seguirem
o sistema do Material Design,
temos uma combinável
MaterialTheme
que permite configurar todas as cores,
toda a tipografia e as formas que
o app precisa.
E, quando vocês colocam na hierarquia,
outros componentes usados
saberão ler esses valores por padrão,
então não é preciso estilizá-los.
Também é possível chegar a esses valores.
É o que estou fazendo neste exemplo.
Nesses três textos,
vou até o estilo e digo
que quero "H6", "subtitle1" e "body1".
É um jeito fácil de estilizar se tiver
definido o estilo do app corretamente.
E para finalizar o app,
posso adicionar uma linha
com uns botões.
Fornecemos as implementações
do Material Design para botões.
O Material Design
define três botões diferentes.
São os botões contidos,
circunscritos e de texto.

Portuguese: 
Mantivemos a terminologia
para facilitar a localização.
Botões contidos, circunscritos
e de texto estão disponíveis.
Todos os componentes do
Material Design que fornecemos
foram criados na API pública
das camadas inferiores.
Então o Compose UI Core
fornece uma base para nós.
E construímos tudo em cima dessa base.
Tentamos não usar APIs privadas.
Isso significa que o Material Design
é uma amostra de como
construir componentes.
Esperamos que
sirvam de amostras.
São bem úteis.
E ao mesmo tempo
pode haver código
que vocês queiram
ver como fizemos e usar.
Tentamos dividir em várias camadas
porque vocês podem
decompor tudo em mais funções
e garantir que há o máximo
possível de itens reutilizáveis.
Como parte disso,
criamos esse nível base no meio.
A ideia é que há muito material
que não é específico ao design.
Vai haver vários gestos,
acessibilidade 
implementada para criar um botão.
Então podemos colocar o botão
no Material Design.
E podemos colocar
os elementos internos do botão na base.

Chinese: 
所以我们提供了包含式 边框式 以及文本式按钮
我们提供的所有 Material 组件
都是纯粹用公共 API 在下面的层级之上构建完成的
Compose UI 核心为我们提供了一些基础
我们在这个基础上逐层添加了其他所有东西
我们试着不去使用私有 API 来走捷径
也就是说 Material 应该是一次展示
让你学习如何构建组件
我们希望它们能够成为样本
它们是非常有用的控件
但同时 它也应该是可读 可分析的代码
并且能够用来作为构建新应用的参照物
我们还试着把所有东西分解为多个层级
让大家能够加入更多的功能
确保有足够多的可重复利用元素可供大家使用
所以 我们在中间创建了一个基础层级
主要思路是 有很多 Material 不一定是专属于设计领域的
我们会实现很多手势和可访问性内容来完成一个按钮
然后把成品按钮放进 Material
再把按钮的内容放进基础

Japanese: 
見つけやすいように
同じ名前が使われています
Contained、Outlined
Textボタンです
提供する
すべてのマテリアルコンポーネントは
下位レイヤのパブリックAPIに基づいています
基盤となるCompose UI Coreの上に
すべて構築しています
プライベートAPIで
チートしないようにしています
つまり マテリアルはコンポーネントを
ビルドする際の見本だと言えます
いずれも便利なコンポーネントですが
コードを読んで理解できることも重要です
また 複数のレイヤに分割しました
できる限り多くの関数に分解することで
再使用できる要素が増えるからです
その一環としてFoundationレベルを
中間に作成しました
マテリアルは デザインだけに
限った話ではないからです
ボタン関連のユーザー補助
多くのジェスチャーもあります
マテリアルに実際のボタンを配置し
ボタンの内部はFoundationに
配置すれば

English: 
to make it easy to find things.
So we have contained
buttons, outline buttons,
and text buttons available.
So all of the
Material components
we provide we've built purely
on the public API from layers
below us.
So Compose UI core provides
some foundation for us.
And we've built everything
layered up on top of that.
So we've tried to not cheat
with any private APIs.
This means that Materials
should be a showcase of how
you can build components.
We're hoping they're samples.
Right?
They're very useful components.
But at the same time,
it should be code
that you can go in, read,
and see how we've done it,
and take those
examples for yourself.
We've also tried to
break everything down
into multiple layers, because
you can break everything
into more and more
functions, to make
sure there's as many
reusable bits in there
as possible for everyone.
And as part of that, we've
created this foundation level
in the middle.
The main idea there is, there's
a lot of material that is not
necessarily design specific.
There'll be a bunch of gestures,
accessibility that we've
implemented to do a button.
So we can put the actual
button in Material.
But then we can
put the internals
of the button in foundation.

Indonesian: 
agar lebih mudah ditemukan.
Jadi tombol tertampung,
tombol garis luar,
dan tombol teks sudah tersedia.
Semua komponen Material
yang kami sediakan,
hanya dibuat dengan
API publik dari lapisan
yang ada di bawah.
Inti UI Compose memberikan
beberapa fondasi bagi kami.
Dan kami membuat semuanya
berlapis di atasnya.
Jadi kami mencoba untuk tidak
berbuat curang dengan API pribadi.
Artinya, Material bisa jadi
sebuah bukti bahwa
Anda bisa membuat komponen,
semoga berupa sampel yang bermanfaat.
Tapi sekaligus
juga harus berupa kode
yang bisa Anda baca dan periksa.
Ambilah contoh untuk Anda.
Kami juga coba
kelompokkan semuanya
jadi beberapa lapisan, karena
apa pun bisa dikategorikan
ke dalam lebih banyak
fungsi, untuk memastikan
ada sebanyak mungkin bit yang
dapat dipakai lagi untuk semua orang
Kami membuat level fondasi ini
ditengah-tengah
Ide utamanya adalah ada
banyak material yang
tidak spesifik pada desain.
Akan ada berbagai macam gestur,
aksesibilitas yang telah kami
implementasikan ke tombol.
Jadi kami dapat menerapkan
tombol asli di Material.
Namun kami bisa
letakkan bagian internal
tombol dalam fondasi.

Korean: 
반복해서 사용합니다
채움 버튼, 테두리 버튼
텍스트 버튼이 있습니다
저희가 제공하는 머티리얼 구성요소는
하위 계층의 공개 API로만
구현하였습니다
Compose UI 코어는
기반을 제공합니다
그 위로 모든 것이 층층이 구현됩니다
비공개 API로 꼼수를
쓰지 않으려 한 것이죠
이는 머티리얼을 통해
구성요소의 구현 방식을
확인할 수 있어야 함을 의미합니다
참고할 만한 예시가 되리라 생각합니다
그렇죠?
이것들은 매우 유용한 구성요소입니다
하지만 동시에
들어가서 읽고 어떻게
진행되었는지 확인하고
예시로 삼을 수 있는 코드가 되어야 하죠
저희는 모든 것을
레이어로 쪼개려고 했습니다
모든 것들을 함수로 잘게 쪼갤수록
모든 사람들이 활용할 수 있는
재사용 가능한 부분이 최대한 많이
생기기 때문입니다
그렇기 때문에 저희는 이 기반 수준을
중앙에 만들었습니다
핵심 논리는 디자인으로
국한된다고 보기 어려운
머티리얼이 많다는 것입니다
버튼을 위해 다양한 제스처와 접근성이
구현됩니다
머티리얼에서 실제 버튼을
구현할 수 있습니다
하지만 그리고 나서 기반에서
버튼의 내부 속성을 구현할 수 있습니다

Spanish: 
que permite encontrar todo más fácil.
Entonces tenemos botones contenidos,
con contorno y de texto.
Todos los componentes de Material
que proporcionamos
están compilados en la API pública
de capas inferiores.
El núcleo de IU de Compose
nos ofrece algunas bases.
Compilamos todo
en capas por encima de esas bases.
Intentamos no hacer trampa con API privadas.
Significa que los elementos de Material
deberían demostrar
cómo pueden compilar componentes.
Esperamos que sirvan de muestra.
Son componentes muy útiles.
Al mismo tiempo, debería ser código
que pueden consultar para ver cómo lo creamos
a fin de tomar esos ejemplos para ustedes.
También tratamos
de desglosar todo en varias capas
así pueden desglosar en varias funciones
y tener tantas piezas reutilizables
como sea posible.
Como parte de eso,
creamos este nivel base en el medio.
La idea es que hay mucho material
que no es específico del diseño.
Hay varios gestos y
funciones de accesibilidad
que implementamos para crear un botón.
Entonces, podemos poner el botón en Material,
y sus componentes internos en la base.
Para que todos los gestos,

English: 
So all the gestures,
accessibility,
other things that we've
built that are not
UI so that you don't have
to start from scratch.
You can already
start from that layer
and just build your UI on top.
And then no matter how many
components we give you,
there's always going
to be custom views
that you'll want to do.
There's always going to
be that designer that
asks for a very strange thing
that we had never anticipated.
So in the existing toolkit,
you have to extend a view.
You have to take care
of a bunch of things.
It's a lot of work to
create a custom view.
In Compose, it's
extremely simple.
You just have to
create a function.
And there's some
building blocks that you
can do to help you build
up that custom view.
The two basic ones
are draw and layout.
So draw will give you a handle
into doing any kind of custom
coding that you want.
Say, for example, we
want to do a checkbox.
And a checkbox is just
a square with rounded
corners and then a checkmark.
Right?
So let me walk you through
the code to do this,
cause it's quite simple.
To draw the box,
we open a draw tag.
We get access to a
canvas and the sizes
we've been measured to.

Korean: 
따라서 모든 제스처, 접근성 등
저희가 구현한 것들은
UI가 아니기 때문에
처음부터 시작하실 필요가 없습니다
이제 여러분은
해당 레이어에서 시작하여
그 위에 UI만 구현하면 됩니다
그리고 저희가 제공하는
구성요소의 수와 무관하게
작업할 만한 맞춤 뷰가
늘 제공될 것입니다
저희가 전혀 예상하지 못했던
독특한 것을 요청하는
디자이너는 늘 있으니까요
그 경우 기존 툴킷에서는
뷰를 확장하셔야 합니다
신경 써야 할 것들이 많습니다
맞춤 뷰를 생성하기 위해
할 작업이 많습니다
Compose에서 매우 간단합니다
함수를 생성하기만 하면 되니까요
맞춤 뷰를 구현하는 데 도움이 되는
요소가 있습니다
그중 기본 요소 두 가지는
그리기와 레이아웃입니다
그리기를 사용하면 원하는
모든 맞춤 코딩 작업을
관리할 수 있습니다
체크박스를 예로 들겠습니다
체크박스는 모서리가 둥근 사각형이고
체크 표시가 있습니다
그렇죠?
여기에 필요한 코드를 설명하겠습니다
매우 간단합니다
박스를 그리려면 그리기 태그를 엽니다
캔버스와 계산된 크기에
액세스합니다

Portuguese: 
E todos os gestos, acessibilidade,
outros elementos que não são IU,
para não precisar começar do zero.
É possível começar dessa camada
e criar sua IU em cima.
E não importa
quantos componentes fornecemos,
vocês vão querer
criar visualizações personalizadas.
Sempre vai ter o designer
que pede aquele item estranho.
No toolkit atual,
é necessário estender a visualização.
Fazer várias coisas.
Personalizar dá trabalho.
No Compose, é supersimples.
Basta criar um função.
E há elementos básicos
para criar uma visualização personalizada.
Os dois básicos são "Draw"e "Layout".
"Draw" ajuda a criar todo tipo
de código personalizado que quiser.
Se quisermos criar uma caixa de seleção,
que é apenas um quadrado
com borda arredondada e uma marca.
Vou mostrar o código para fazer isso.
É bem simples.
Para desenhar a caixa,
abrimos um tag "draw".
Acessamos uma tela
e os tamanhos que medimos.

Indonesian: 
Hal-hal selain UI
seperti gestur dan aksesibilitas
dibuat agar Anda tak perlu
mulai dari nol.
Mulai saja dari lapisan itu
dan buat UI di atasnya.
Berapa banyak pun
komponen yang kami berikan,
akan selalu ada tampilan kustom
yang bisa disesuaikan.
Akan selalu ada
desainer yang
meminta hal yang sangat aneh
yang tak pernah kami antisipasi.
Jadi, di toolkit yang sudah ada,
Anda harus memperluas tampilan.
Anda harus mengatur
berbagai hal.
Membuat tampilan kustom
tidak mudah.
Tapi Compose membuatnya mudah.
Cukup buat fungsi.
Ada beberapa hal yang bisa
dilakukan untuk
membuat tampilan kustom.
Dua blok dasarnya adalah
gambar dan tata letak.
Gambar memungkinkan Anda
membuat berbagai kode
kustom yang diinginkan.
Misalnya, membuat
kotak centang.
Kotak centang hanyalah
kotak dengan pojok
membulat dan tanda centang.
Benar?
Mari saya pandu Anda
membuat kodenya,
karena ini cukup sederhana.
Untuk menggambar kotak,
kita harus membuka tag gambar.
Kita mendapatkan akses ke
kanvas dan ukuran
yang telah kita tetapkan.

Spanish: 
las funciones de accesibilidad
y otras funciones compiladas
que no son IU no se tengan que crear de cero.
Pueden comenzar desde la capa
y compilar la IU encima.
Sin importar cuántos componentes les demos
siempre habrá vistas personalizadas.
Siempre habrá un diseñador
que pida algo muy extraño
que no se nos ocurrió antes.
En el kit de herramientas ampliado,
pueden ampliar una vista.
Deben tener presentes algunas cosas.
Lleva mucho trabajo
crear una vista personalizada.
En Compose, es muy simple.
Solo tienen que crear una función.
Pueden usar algunos bloques predefinidos
que los ayudarán a crear
esa vista personalizada.
Las dos básicas son dibujo y diseño.
Dibujo les permitirá crear
todo el código personalizado que deseen.
Supongamos que queremos
crear una casilla de verificación
que es un cuadrado con bordes redondeados
y una marca de verificación.
Veamos el código de esto
porque es muy simple.
Para dibujar el cuadro,
abrimos una etiqueta de dibujo.
Accedemos a un lienzo y medimos los tamaños.

Japanese: 
ジェスチャーやユーザー補助などの
UI以外の要素を
ゼロから作る必要はありません
すでに用意されているレイヤの上に
UIをビルドできます
どれだけコンポーネントがあっても
カスタムビューの需要はあります
私達が予期していなかった
不思議な内容を求める
デザイナーが出てきます
既存のツールキットでは
ビューを拡張するなど
多くの作業が必要です
カスタムビューの作成は大変ですが
Composeなら簡単です
関数を作るだけです
カスタムビューの構築を支援する
構成要素も用意されています
基本の２つは DrawとLayoutです
Drawはあらゆるカスタムコードに
対応するハンドルです
たとえばチェックボックスです
構成要素は 角丸の四角形と
チェックマークです
このコードを説明します
非常にシンプルです
Drawタグを開くと
キャンバスとサイズに
アクセスできます

Chinese: 
这样一来 所有的手势和可访问性支持等等
我们构建的不属于 UI 的东西就都可供使用了
大家不用再从头做起
你可以从那个层级开始 在其基础上构建你的 UI
此外 无论我们给你提供多少组件
你总是会想制作一些定制组件出来
总是会有一些设计师提出一些让我们无法预料的东西
在现有的工具箱里 需要先扩展某个视图才行
必须关心一大堆东西 
做很多工作 才能创建出定制视图
而在 Compose 中 就非常简单了
只要创建功能即可
还有一些构件可以用来构建定制视图
其中最基础的两个是“绘制”和“布局”
“绘制”会提供一个方法 用来控制定制代码
比如 我们想要制作一个勾选框
而勾选框就是一个带圆角和对勾的框体
我来让大家看看它的代码是怎样的 相当简单
绘制框体 只需打开“绘制” tag
访问 canvas 以及我们测量好的尺寸

English: 
So we can easily
calculate, how much do we
want our square to be?
Apply the rounded corners,
and then just draw the square.
Same for the checkmark.
We'll open a draw.
We have access to the
canvas and the sides.
We can calculate the three
points that make a checkmark,
and then just draw
those on the screen.
So surprisingly simple.
The next part is layout.
Of course, we will try to
provide as many layouts
as we can out of the box.
There will be always
something that you want
to do that is extremely custom.
Well, you can reach down
into the layout component.
I've tried to show
here an example.
The most simple
example I could find
is a stack or a frame layout.
Right?
Like stacking things
one on top of the other.
So you will create a function
that takes a bunch of children
that it needs to place.
We open a layout tag.
We get access to
these children that
are measurable pieces, all
the constraints we have.
And then we just have to
go through two easy steps.
We measure each of the
children to make sure we
know what size they want to be.
And then we decide what
size we want to be.
So, for example, in
a stack I'll probably

Indonesian: 
Jadi banyaknya kotak yang diinginkan
bisa dihitung dengan mudah.
Terapkan sudut membulat,
lalu gambar kotaknya.
Begitu juga tanda centangnya.
Kita buka gambar,
dapatkan akses
ke kanvas dan sisinya.
Kita bisa perkirakan tiga titik
yang membentuk centang,
lalu gambarlah di layar.
Mudah sekali kan?
Selanjutnya,
kami berusaha menyediakan
sebanyak mungkin tata letak siap pakai.
Selalu akan ada yang ingin
dilakukan secara kustom.
Anda bisa mengakses
komponen tata letak.
Saya tunjukkan contoh
paling sederhana yang bisa saya temukan
adalah tumpukan atau tata letak
frame.
Seperti menumpuk sesuatu
di atas sesuatu yang lain.
Buat fungsi
yang memerlukan banyak
turunan.
Kita buka tag tata letak.
Kita dapatkan akses ke
turunan ini yang
dapat diukur, semua
batasan yang kita punya.
Lalu, kita hanya perlu
melakukan dua langkah mudah.
Ukur tiap turunan ini
untuk memastikan bahwa
kita tahu ukurannya.
Lalu tentukan ukuran
yang diinginkan.
Misalnya, di sebuah
tumpukan, saya ingin

Japanese: 
必要な四角形のサイズを
簡単に計算できます
角丸を適用して四角形を描写するだけです
チェックマークも同じことです
Drawを開き
キャンバスとサイズにアクセスし
チェックマークの３点を計算して
画面に描写するだけです
驚くほど簡単ですね
次はレイアウトです
すぐに使えるレイアウトが
多く用意されていますが
特別なレイアウトが必要な場面もあります
Layoutコンポーネントを使用します
例を示します
最も単純な例は
StackまたはFrameレイアウトです
上に積み上げる形です
配置する子を受け持つ関数を作成します
Layoutタグを開きます
測定可能な子とすべての制約に
アクセスできます
２つの簡単な手順を踏みます
子をそれぞれ測定し
必要なサイズを確認します
次に全体のサイズを決定します
たとえばスタックでは

Chinese: 
这样就能轻松计算出框体的大小
应用圆角 然后绘制出框体即可
对勾也是一样 我们打开“绘制”
访问 canvas 和尺寸
计算好构成对勾图案所需的三个点
然后在屏幕上把它画出来
非常的简单
下一个部分是布局
当然 我们会努力提供尽量多种类的开箱即用布局
我们知道大家会不断提出非常个性化的定制要求
现在大家可以深入布局组件
我试着在这里展示一个例子
我能找到的最简单例子是栈或框布局
一层层地堆起来
你会创建出一个内含很多子项目的方法 它们都需要设置位置
我们打开布局 tag
访问这些可测量的子项以及所有的约束条件
然后我们只需进行简单的两步
我们测量每个子项 了解它们的尺寸需求
然后我们确定自己的尺寸需求
例如 在栈中 我大概是想要
子项的最大尺寸值 确保它们都能放进来

Spanish: 
Así podemos calcular
el tamaño de nuestro cuadrado,
aplicamos los bordes redondeados,
y luego dibujamos el cuadrado.
Lo mismo para la marca de verificación.
Abrimos un dibujo.
Accedemos al lienzo y al tamaño.
Podemos calcular los puntos
que crean una marca de verificación
y dibujarlos en la pantalla.
Sorprendentemente simple.
Lo siguiente es el diseño.
Intentaremos incluir tantos diseños
como sea posible.
Si quieren algo extremadamente personalizado,
pueden ir al componente de diseño.
Traté de mostrarles un ejemplo aquí.
El más simple que encontré
es una pila o un diseño de marco.
¿Bien?
Para apilar cosas una sobre otra.
Creamos una función
que lleve a varios elementos secundarios
al lugar necesario.
Abrimos una etiqueta de diseño.
Accedemos a estos elementos secundarios
que son piezas medibles
y a todas las limitaciones que tenemos,
y luego seguimos dos simples pasos.
Medimos cada uno de los elementos,
para conocer el tamaño que deseamos,
y decidimos qué tamaño tendrá.
Por ejemplo, en una pila
querremos la cantidad máxima

Korean: 
그렇기 때문에 원하는 사각형 크기를
쉽게 계산할 수 있습니다
둥근 모서리를 적용하고 사각형을 그리세요
체크 표시도 마찬가지입니다
그리기를 엽니다
캔버스와 크기에 액세스할 수 있습니다
체크 표시를 구성하는 세 점을 계산하고
화면에 그리기만 하면 됩니다
놀랄 정도로 쉽죠
다음은 레이아웃입니다
저희는 즉시 사용할 수 있는 레이아웃을
최대한 많이 제공하려고 합니다
개인 취향을 충실하게
반영하고 싶은 경우가
늘 있을 것입니다
그때 레이아웃
구성요소를 활용하시면 됩니다
그래서 예시를 찾아봤는데요
제가 찾은 가장 간단한 예시는
스택 또는 프레임 레이아웃입니다
그렇죠?
한 개씩 층층이 쌓는 방식입니다
그래서 배치해야 할 하위 요소가 많은
함수를 생성합니다
레이아웃 태그를 엽니다
측정 가능한 하위 요소와
모든 제약 사항에 액세스할 수 있습니다
그런 다음 간단한 두 단계만 거치면 됩니다
하위 요소 각각을 측정하여
원하는 크기를 정확하게 파악합니다
그리고 원하는 크기를 결정합니다
예를 들어 스택에
하위 요소의 최대값을 적용하여

Portuguese: 
E podemos calcular facilmente
o tamanho do nosso quadrado.
Aplicamos as bordas arredondadas
e desenhamos o quadrado.
Mesma coisa para a marca.
Abrimos um "draw".
Acessamos a tela e os lados.
Podemos calcular os três pontos
que formam uma marca
e então desenhamos.
Surpreendente de tão simples.
A próxima parte é o layout.
Vamos fornecer o máximo
de layouts prontos para vocês.
Mas sempre há algo superpersonalizado
que vocês queiram.
Vocês podem usar o componente "layout".
Tentei mostrar um exemplo aqui.
O mais simples que achei.
Um layout de pilha ou frame.
Empilhar coisas,
umas sobre as outras.
Então criaremos uma função que
posiciona elementos filhos necessários.
Abrimos uma tag "layout".
Acessamos esses filhos,
que são peças mensuráveis,
todas as restrições que temos.
E aí só precisamos seguir duas
etapas simples.
Medimos cada filho para
saber o tamanho desejado.
E decidimos o tamanho que queremos.
Por exemplo, em uma pilha,

Indonesian: 
agar jumlah maksimum
turunan semuanya pas.
Lalu, saya tempatkan masing-masing
di koordinat 0,0,
karena begitulah
tumpukan itu.
Lalu, kita akan
mendapatkan efek
seperti ini.
Dan Romain yang akan melanjutkan.
-Oke.
Jadi apa yang kita punya sekarang?
Seperti yang sudah disampaikan,
pratinjau developer baru dirilis.
Namanya 0.1.0-dev02.
Jadi jika pratinjau ini tidak terlalu
jelas, ini memang
belum siap diproduksi.
Namun saya ingin menunjukkan
beberapa kode dan demo.
Jadi tolong alihkan
ke mesin demo.
OK.
Salah satu aplikasi sederhana
yang kami miliki adalah JetNews.
Anda bisa melihatnya
di emulator.
Di situ bisa dilihat apa saja
yang sudah bisa dibuat saat ini.
Adai daftar scroll
horizontal dan vertikal.
Tumpukan teknis sudah
tingkat lanjut.
Anda bisa melakukan banyak pengaturan tata
letak dan pengubahan gaya teks yang rumit.
Ini adalah aplikasi yang sangat menarik
untuk disimak.
Ini bukan aplikasi sungguhan.
Tidak tersambung
ke basis data dan web

Japanese: 
子がすべて収まるサイズが必要です
(0,0) 座標にそれぞれ配置します
その結果エフェクトは
このようになります
ロマンに引き継ぎます
基調講演でご紹介した通り
開発者プレビューを最近リリースしました
0.1.0-dev02です
念のため明確にしておきますが
これは正式版ではありません
ただしコードとデモをお見せします
デモマシンに切り替えます
JetNewsという単純なアプリがあります
右に表示されています
現状でも ここまで構築できます
水平と垂直スクロールリストが
あります
テックスタックはすでに高度です
複雑なテキストレイアウトとスタイルを
多く適用できます
本物のアプリではないため

Chinese: 
然后我会把它们都放在 0，0 这个坐标上
因为 栈就会这么做
然后 我们会得出这样的效果
下面话筒交回 Romain
好 今天讲点什么呢？
正如我在主题演讲中提到的
我们刚刚发布了开发者预览版
名叫 0.1.0-dev02
如果大家看不清的话 我给大家念一遍
它现在还没有针对生产环境准备好
不过我想展示一些代码 以及一段演示
请切换到演示机 好
Jetnews 是我们想要展示的简单应用之一
大家可以在右侧的模拟器上看到它
它会让你了解到 现在你可以做什么
我们有水平滚动列表 竖直滚动列表
文本栈看起来已经相当先进了
可以做大量的复杂文本布局和风格定制
这个应用很有意思
它还不是真实的应用 
没有连接到数据库和网络服务
这是为了演示所需的简洁性

Korean: 
모두 적합한지 확인하고 싶을 수 있습니다
이때 하위 요소 각각을
0, 0 좌표에 위치시킵니다
그게 스택이기 때문이죠
그러면 이러한 효과가
생깁니다
이제 로만 씨에게 넘기겠습니다
좋습니다
저희가 오늘 준비한 것은 무엇일까요?
아까 키노트에서 언급했듯이
저희는 0.1.0-dev02라는
개발자 프리뷰를 발표했습니다
무슨 의미인지 모르시겠다고요?
아직 출시 준비가 안 되었다는 의미입니다
코드를 소개하고 시연을 해보겠습니다
데모 머신으로 전환해 주시겠어요?
좋습니다
간단한 앱으로
JetNews라는 것이 있습니다
에뮬레이터 오른쪽에서
확인하실 수 있습니다
현재 구현 가능한 것들에 대한
좋은 아이디어를 얻으실 수 있습니다
가로 스크롤 목록과 세로 스크롤 목록이
있습니다
기술 스택은 이미 꽤 발전했습니다
그래서 복잡한 텍스트 레이아웃
및 스타일 구성 작업을 할 수 있죠
이러한 점에서 아주 흥미로운 앱입니다
실제 앱은 아닙니다
샘플 앱을 간결하게 유지하기 위해

Spanish: 
de elementos secundarios,
para asegurarnos de que quepan.
Luego se coloca cada uno
en la coordenada 0, 0
porque eso es lo que haría una pila.
Terminaremos con un efecto similar a esto.
Volvemos con Romain.
Bien.
¿Qué tenemos hoy?
Como mencioné antes,
lanzamos la vista previa de desarrollador.
Se llama 0.1.0-dev02.
Por si no es claro,
todavía no está lista para producción.
Pero quiero mostrarles
parte del código y una demostración.
¿Podemos cambiar al equipo de demostración?
Bien.
Una de las apps de muestra se llama JetNews.
Pueden verla a la derecha en el emulador.
Les da una idea
de lo que pueden compilar actualmente.
Tenemos listas de desplazamiento horizontal,
listas de desplazamiento vertical.
La pila técnica ya está bastante avanzada.
Pueden hacer ediciones de diseño
y estilo de texto bastante complejas.
Esta es una app interesante de ver.
No es una app real.
No está conectada a una base de datos

Portuguese: 
quero o máximo de filhos
para garantir que todos caibam.
Vou colocá-los na coordenada 0,0
porque é o que uma pilha faria.
Acabamos com um efeito assim.
Vou passar para Romain.
Tudo bem.
O que temos hoje?
Como mencionei na abertura,
lançamos a prévia 0.1.0-dev02.
Se ainda não ficou claro,
não está pronta para produção.
Mas quero mostrar um pouco
de código e uma demonstração.
Por favor,
a máquina com a demonstração.
Beleza.
Um dos apps mais simples
que temos é o JetNews.
Vocês podem vê-lo
no emulador à direita.
Ele fornece uma ideia
do que se pode criar hoje.
Listas de rolagem
horizontal e vertical.
A pilha técnica já está bem avançada.
Dá para criar
muitos layouts e estilos complexos.
É um app bem interessante de observar.
Não é um app real.

English: 
want the maximum of the children
to make sure they all fit.
And then I'll place them
each at the 0, 0 coordinate,
cause that's what
a stack would do.
So then we'll end
up with an effect
that is something like this.
Hand it over to Romain.
ROMAIN GUY: All right.
So what do we have today?
Like I mentioned in
the keynote, we just
released our developer preview.
It's called 0.1.0-dev02.
So if it's not clear
enough, it is not
quite ready for production.
But I want to show you
some code and a demo.
So if you can switch to
the demo machine, please.
All right.
So one of the simple apps
we have is called JetNews.
You can see it on the
right in the emulator.
So it gives you a good
idea of the kind of things
you can already build today.
We have horizontal scrolling
lists, vertical scrolling
lists.
The tech stack is
already pretty advanced.
So you can do a lot of complex
text layouting and styling.
So this is a very
interesting app to look at.
It's not a real app.
It's not connected to a
database or web service

English: 
to keep the sample
simple, but it's
a very good example of how
to create your own widgets
and to use the existing widgets.
So what I wanted to show
you is what you see here.
So yesterday I built this
little to-do list app.
So I've got the old [INAUDIBLE]
icon in the bottom right.
And when you click on it, I
just want to add list items.
And each list item will
have a little bookmark icon
that I want to be
able to toggle.
So the way it works
here, [INAUDIBLE]
is a simple data
class in Kotlin.
Is the text big
enough, by the way,
on the screen for everyone?
All right.
I'll assume it's a yes.
So we have a data class.
It's immutable.
Everything's a vowel.
And you can see that night time
can be a favorite, and just
a description and an ID.
Then the actual
model for the app
is just this empty
list of to-do items.
And it's going to be
an immutable list.
And I wrapped it
into this object.
That's probably not how you
would do it in a real app,
like using an object like
this as a global object.
But I used this at
@Model annotation.
And an at @Model basically
turns this object
into an observable object.

Chinese: 
不过它很好地说明了应该如何创建自己的 widget
如何使用现有的 widget
我想向大家展示的东西就在这里
昨天 我构建了这个日程提醒应用
我把这个旧版的红色标志放在右下角
点击它 应用就会添加列表项
每个列表项都会有一个小小的书签标志
这个标志可以被点击打开和关闭
它的原理是一个简单的 Kotlin 数据类
顺便问一句 文本的字号够大吗 看得见吗
好 我就假定大家都能看清
我们有一个不可变的数据类
所有东西都是 val 
有 favorite 此外还有描述内容 (content) 和 ID
然后 这个应用的模型就是这个空的日程提醒项列表
这会是一个不可变的列表
我把它封装为这个对象
大家在真实的应用中估计也会这么做
把类似这样的对象当作全局对象来运用
我用 @Model 注解使用它
@Model 的功能大致上是
把这个对象转化为可观察对象

Spanish: 
o a un servicio web, para que sea simple,
pero es un buen ejemplo
de cómo crear sus propios widgets
y usar los widgets existentes.
Quería mostrarles es lo que ven aquí.
Ayer compilé esta app de lista de tareas.
Tenemos el viejo ícono
en la parte inferior derecha.
Al hacer clic en él,
quiero agregar elementos a la lista.
Cada uno tendrá un ícono de favorito
que quiero poder activar.
Aquí creé una clase
de datos simple en Kotlin.
¿El tamaño del texto en la pantalla
está bien para todos?
Bien.
Supongo que eso es un sí.
Tenemos una clase de datos.
Es inmutable.
Todo es un valor.
Pueden ver que un elemento puede ser favorito
y agregar una descripción y un ID.
El modelo de la app
es esta lista vacía de elementos.
Será una lista inmutable.
La coloqué dentro de este objeto.
Es probable que, en una app real,
no usen un objeto así, como global.
Pero usé esto en la anotación @Model.
En @Model, se convierte este objeto
en un objeto observable.

Portuguese: 
Não é conectado a um banco de dados
ou serviço da Web para simplificar,
mas é um exemplo de como criar
seus widgets e usar os existentes.
Queria mostrar o que veem aqui.
Ontem criei este app de lista de tarefas.
Com o velho ícone FAB
no canto inferior direito.
Quando clico, adiciono itens na lista.
E cada item terá
um pequeno ícone de favorito
que pode ser ativado.
Como funciona aqui,
meu modelo de dados
é uma classe de dados simples no Kotlin.
O tamanho do texto está bom
na tela para todo mundo?
Beleza.
Vou entender que sim.
Temos uma classe de dados.
É imutável.
Tudo é vogal.
E você pode ver que um item
pode ser um favorito,
e há uma descrição e um ID.
O modelo real do app
é uma lista de tarefas vazia.
Vai ser uma lista imutável.
Eu uni neste objeto.
Não é assim que seria feito
num app real,
usar um objeto como esse
como um objeto global.
Mas usei essa anotação @Model.
E @Model basicamente
transforma esse objeto em um observável.

Japanese: 
データベースやウェブサービスとは
接続されていません
でも独自ウィジェットの作成や
既存ウィジェットの使用方法の良い例です
お見せしたいのはこれです
昨日このto-doリストアプリを
ビルドしました
右下に見慣れたアイコンがあります
クリックするとリストアイテムを追加します
各リストアイテムには
トグル可能な
ブックマークアイコンが付きます
ここで使っているのは
Kotlinの単純なデータクラスです
画面の文字が見えますか？
大丈夫そうですね
不変のデータクラスがあり
すべてvalです
あとは FavoriteとIDと説明です
実際のアプリのモデルは
今は空の
to-doアイテムリストです
不変のリストになります
このオブジェクトにラップしましたが
正式なアプリでは
グローバルオブジェクトとして
使用しないでしょう
@Modelアノテーションを使用しました
@Modelはオブジェクトを
監視可能なオブジェクトにします

Korean: 
데이터베이스나 웹 서비스에 연결하지 않았습니다
하지만 위젯을 생성하는 방법과
기존 위젯을 사용하는 방법을
확인할 수 있는 좋은 예입니다
그래서 이것을 보여드리고 싶었습니다
어제 만든 할 일 목록 앱입니다
오른쪽 하단에 기존 아이콘을 사용했고요
클릭하면 목록 항목을 추가할 수 있습니다
목록 항목 각각에는 북마크 아이콘이 있고
토글할 수 있습니다
지금 보이는 것은
Kotlin의 간단한 데이터 클래스입니다
그런데 화면의 글씨가
다들 잘 보이시나요?
좋습니다
잘 보이시는 것 같군요
데이터 클래스가 있습니다
수정할 수 없습니다
문제는 없어 보이고요
즐겨찾기로 지정 가능하고
설명과 ID가 있습니다
앱의 실제 모델은
할 일 항목의 빈 목록입니다
이제 수정 불가능한 리스트가 됩니다
이것을 이 객체에 포함시켰습니다
실제 앱에서는 이와 같은 객체를
전역 객체로 사용하지는
않으실 겁니다
하지만 저는 이 @Model
주석을 사용했습니다
@Model은 기본적으로 이 객체를
observable 객체로 전환합니다

Indonesian: 
agar sampel ini tetap
sederhana,
tapi ini amat baik
untuk menunjukkan cara membuat
widget dan menggunakan widget yang
sudah ada.
Yang ingin saya tunjukkan adalah ini.
Kemarin, saya membuat aplikasi
daftar tugas singkat ini.
Saya punya ikon
lama ini di kanan bawah.
Saat diklik, saya
ingin menambahkan item daftar.
Tiap item daftar akan memunculkan
ikon bookmark kecil
yang saya ingin bisa dimunculkan
dan dihilangkan.
Jadi, cara kerjanya
di sini,
adalah class data sederhana
di Kotlin.
Apa semua bisa membaca
teks di layar?
OK.
Saya anggap bisa ya.
Kita punya class data.
Ini tak bisa diubah.
Semua huruf vokal.
Dan Anda bisa lihat bahwa malam
hari adalah yang favorit, dan cuma
deskripsi dan ID.
Lalu model aktual
aplikasi hanyalah
item daftar tugas
kosong ini.
Ini akan jadi daftar
yang tidak bisa diubah.
Saya gabung ke objek ini.
Sebaiknya tidak dilakukan
di aplikasi sungguhan,
yaitu menggunakan objek
seperti ini sebagai objek global.
Tapi saya menggunakannya di
anotasi @Model.
Dan @Model pada dasarnya
mengubah objek ini
menjadi objek yang dapat diamati.

Indonesian: 
Jadi, kapan pun saya mengubah
properti item,
UI akan disusun ulang
secara otomatis.
Adam akan jelaskan lebih lanjut.
Jika ingin tahu lebih banyak,
Dylan akan berbicara besok
tentang cara kerjanya
secara internal dalam compiler.
Ini adalah bagian utama
aplikasi.
Amat serupa
dengan yang tadi kita lihat
di keynote.
Saya punya scroller vertikal
dan kolom.
Saya cuma mengulanginya
di semua item.
Untuk tiap item,
saya membuat baris.
Anda bisa abaikan
parameter tata letak.
Namun ada ikon bookmark ini.
Jadi ini adalah composable
yang saya buat.
Inilah salah satu yang saya
suka dan ingin kita lakukan di Compose,
Kita ingin membuat widget
sendiri dengan sangat mudah.
Sering kali di aplikasi
Android,
kita akhirnya berkutat
dengan file XML yang besar,
karena membuat file XML
sangat merepotkan.
melakukan penyertaan, penggabungan,
dan semua hal itu.
Yang perlu dilakukan
saat pertama kali saya
menulis aplikasi ini,
saya menulis semuanya
ke dalam composable
item ini.
Lalu saat saya melihatnya,
ada composable ikon bookmark.
Saya memilihnya.
Saya mengekstrak metode dengan
refaktor di Intellij.

Chinese: 
无论何时 当我更改项目属性的时候
UI 就会自动重组
Adam 会为大家详细讲解
如果大家想要了解更多详情
Dylan 会在明天的演讲中解释它在编译器内部的工作原理
这是应用的主要部分
与我们之前在主题演讲中见过的类似
我有一个竖直滚动条 有列
我只需要用它们来迭代所有项目
再为每个项目创建一个行
大家可以忽略布局参数
不过这个书签标志是我创建出来的 composable
我最喜欢的 Compose 的一个优点
也是我们最想做到的一件事是
让大家可以轻松地创建出自己的 widget
通常 在 Android 应用中 
我们最后会得到体积很大的 XML 文件
在 findYouById include merge 等操作过程中
这些文件创建起来非常麻烦
而在这里 我当初创建这个应用的时候
把所有代码都写进了这些 composable 里面了
我看到它之后 就有了这个书签标志 composable
我选中它 使用 IntelliJ 中的 refactor 来抽取方法

Korean: 
항목의 속성을 변경할 때마다
UI가 자동으로 재구성됩니다
아담 씨가 자세히 설명해 주실 겁니다
더 자세한 내용에 대해서는
내일 딜런 씨가 강연을 통해 컴파일러에서
어떻게 내부적으로
작동하는지 설명할 예정입니다
이것이 애플리케이션의 주요 부분입니다
키노트에서 살펴본 것과
매우 유사합니다
여기 수직 스크롤러가 있고요
열이 있습니다
모든 항목을 반복합니다
항목 각각에 대해 행을 생성합니다
레이아웃 매개변수는 무시해도 됩니다
하지만 여기 북마크 아이콘이 있습니다
이것이 제가 만든
composable입니다
제가 Compose에서
가장 좋아하는 부분 중 하나이자
정말로 하고 싶었던
일 중 하나를 말씀드리면
저희는 자체 위젯을 쉽게
만들 수 있으면 좋겠다고 생각했습니다
Android 애플리케이션의 경우
대용량 XML 파일을
생성하는 경우가 많습니다
왜냐하면 include 작업, 병합 작업 등
이 모든 XML 파일을
생성하기 위해 많은 작업이
수반되니까요
저는 이 애플리케이션을 처음 작성할 때
모든 것을 구성 가능한
항목으로 작성했습니다
여러분들도 이것만 하시면 됩니다
그리고 나서 이 북마크
아이콘이 구성 가능한 것을 확인하고
그것을 선택했습니다
IntelliJ에서 리팩터를
사용하여 메서드를 추출했습니다

Japanese: 
アイテムのプロパティを変更するたびに
UIは自動的に再構成されます
後でアダムが詳細を説明しますが
明日のセッションでは
内部のコンパイラの仕組みを説明します
ここがアプリケーションの主要部分です
基調講演で見たものと
よく似ています
垂直スクローラと列があります
すべてのアイテムで反復します
各アイテムに行を作成します
レイアウトの値は無視してください
ブックマークアイコンがあります
これが作成したコンポーザブルです
Composeで目指したことは
独自のウィジェット作成を
容易にすることです
アプリでは多くの場合
大規模なXMLファイルができます
それらのXMLファイルの作成には
findViewById、include
mergeなどが必要で 面倒です
ここではItemsコンポーザブルに
すべてを書き込むだけで
いいのです
次にBookmarkIconコンポーザブルを
選択します
IntelliJのリファクタリングを使用して
メソッドを抽出し

Portuguese: 
Então sempre que mudo a
propriedade do item,
a IU é automaticamente recomposta.
E Adam vai falar mais disso.
E se quiserem mais detalhes,
Leland tem uma palestra amanhã
em que explica como funciona no Compiler.
Esta é a parte principal do app.
Parecido com o que vimos
na apresentação principal.
Um botão de rolagem vertical,
uma coluna.
Vou iterar em todos os itens.
E, para cada um, vou criar uma linha.
Ignore os parâmetros de layout.
Mas tenho o ícone de favorito.
Esta é uma função combinável que criei.
E uma das coisas que gosto
na composição
e que queríamos muito fazer
é facilitar a criação dos seus
próprios widgets.
Em aplicativos Android,
é comum ter arquivos XML grandes
porque é muito cansativo criar
todos esses arquivos,
fazer a função "JobID",
as inclusões, a combinação etc.
E aqui tudo que tem a fazer...
Quando escrevi este app,
escrevi tudo nesta combinável de itens.
Depois, com a combinável
de ícone de favorito, eu a selecionei.
Extraí um método usando
uma refatoração no IntelliJ.

Spanish: 
Cuando cambio la propiedad del elemento
la IU se recompone automáticamente.
Adam les contará más acerca de eso.
Si quieren más información,
Dylan dará una charla mañana
en la que explicará cómo funciona
internamente en el compilador.
Esta es la parte principal de la aplicación.
Es muy similar a lo que vimos antes.
Tengo una barra de desplazamiento vertical,
una columna,
itero sobre todos los elementos,
y, luego, para cada elemento, creo una fila.
Puedo ignorar los parámetros de diseño.
Pero tengo este ícono de favorito.
Es un elemento componible que creé.
Es algo que realmente me gusta de Compose.
Era una de las cosas que queríamos hacer.
Queríamos simplificar
la creación de sus propios widgets.
A menudo, en las aplicaciones de Android
terminamos con archivos XML muy grandes
porque es engorroso
crear todos esos archivos XML
con la búsqueda por ID,
las inclusiones, la combinación y todo eso.
Lo único que hice aquí
fue escribir la aplicación
en este componible de elementos.
Cuando vi que tenía
este componible de favoritos
solo lo seleccioné.
Extraje el método mediante
una refactorización en IntelliJ.

English: 
So whenever I change
the item's property,
the UI will re-compose
automatically.
And Adam will tell
you more about this.
And if you want to
know even more details,
Dylan has a talk tomorrow
where he explains how it works
internally in the compiler.
This is the main part
of the application.
So very similar to the
way we saw this earlier
in the keynote.
I have a vertical scroller.
I have a column.
I just iterate
over all the items.
And then for each
item, I create a row.
You can ignore the
layout parameters.
But I have this bookmark icon.
So this is a
composable I created.
And one of the things I
really like about Compose--
and that was one of the
things we really wanted to do.
We wanted to make it easy
to create your own widgets.
Very often in
Android applications
we end up with very
large XML files,
because it's very cumbersome
to create all those XML files,
doing the [INAUDIBLE],, doing
the includes, and the merge,
and all that stuff.
And here all you have
to do is when I first
wrote this application,
I wrote everything
into these items composable.
And then when I saw that, I had
this bookmark icon composable.
I just selected it.
I extracted a method using
a refactor in IntelliJ.

Spanish: 
Luego agregué mi anotación componible.
Eso es todo lo necesario
para crear un componente nuevo.
No tienen que extender la vista del grupo
ni anular métodos.
Luego tengo un pequeño separador
y, por último, el texto
que describe el elemento.
Aquí está el ícono de favoritos.
Aquí pueden ver algo interesante…
¡Uy! Estoy mostrando lo que voy a escribir.
Es mi trampa,
por si me olvido qué voy a hacer.
Mi ícono de favorito es bastante simple.
Es uno de esos elementos de tareas.
Se lee mediante un clic.
Realmente, así se crea
un objeto de escucha de clics.
Adentro, solo tengo esta rama
y, si este elemento es un favorito
quiero mostrar la imagen
que corresponda al estado favorito.
Si no es un elemento favorito,
quiero usar la otra imagen.
Esto demuestra
que no se trata de usar cuatro bucles,
uno por instancia.
Pueden usar cualquier
flujo de control que quieran.
Así, el código es muy fácil de leer.
Pueden hacer este código
de diferentes maneras.
Tengo dos devoluciones de llamadas en la app.
Tengo el interruptor de favorito
para hacer clic en el ícono.
También tengo uno
cuando hacemos clics en los favoritos.
Trataré de escribirlos.

Japanese: 
@Composableを追加します
これだけで
新規コンポーネントを作成可能なのです
グループのビューから拡張し
メソッドを上書きする必要はありません
小さなスペーサーがあり
最後にアイテムを説明するテキストがあります
ブックマークアイコンはここです
…おっと
打ち込む内容がバレてますね
備忘録です
さて
ブックマークアイコンはシンプルです
to-doアイテムの１つを
Clickableで読み取ります
クリックリスナーはこのように作成します
中ではブランチがあり
このアイテムがお気に入りであれば
お気に入りの状態に対応した
アイコンを表示します
お気に入りでなければ
違うアイコンを表示します
独自のインスタンスや
４つのループといった枠組みを超え
あらゆるコントロールフローを使えます
コードが非常に読みやすくなります
このコードは様々な形で記述できます
２つのコールバックがあります
ブックマークアイコンと
お気に入りクリック時の
toggleFavoriteです
記述してみましょう

Chinese: 
再添加我的 @Composable 注解
创建新组件 就只需要做这些而已
不需要再用你的视图做扩展 做方法重载
然后 我添加了一个小小的间隔符
最后 我添加了一段用来描述子项的文本
书签标志在这里
在这里 你可以看到另一个有意思的东西
不小心把我要输入的东西给暴露出来了
这是我为了防止自己临场忘事准备的
我的书签标志十分简单
接收一个 Todo 项目 它可以被 clickable 访问
其实这就是创建 clickListener 的方式
在它内部 我只需进到这个分支并判断
如果这个项目现在是收藏状态
那么我就显示与收藏状态对应的图片
如果它不是收藏状态 我就使用另一个图片
这就表明 它并不是只使用 for loop
而是可以使用任意控制流
从而使代码的可读性大大提升
这段代码也有很多不同的写法
我在这个应用中安排了两个回调
第一个是 在点击书签标志时切换收藏状态
还有一个是在点击 FAB 的时候用的
我来试着写写看

Portuguese: 
E adicionei minha anotação @composable.
E é tudo que precisa para criar
um novo componente.
Não precisa estender da visualização
do grupo e subtituir métodos.
Tenho um pequeno espaçador
e o texto que descreve o item.
O ícone de favorito está aqui.
E aqui há uma coisa interessante...
Opa!
Estou revelando o que vou digitar.
É minha cola caso esqueça o que fazer.
O ícone de favorito é bem simples.
Ele usa um desses itens de tarefa.
É lido por "clickable".
E é assim que você cria
um listener de clique.
Internamente, tenho esse branch
e defino que, se o item é um favorito,
mostro a imagem correspondente ao estado.
Se não for, uso outra imagem.
Isso mostra que não é só
usar quatro loops,
com uma instância para cada
Pode usar o fluxo de controle que quiser.
E isso facilita muito a leitura do código.
E dá para escrever
essa parte do código de vários jeitos.
Então tenho dois callbacks no app.
"ToggleFavorite",
quando clicamos no ícone de favorito.
E um quando clicamos no FAB.
Vou tentar escrevê-los.

Indonesian: 
Lalu menambahkan anotasi
composable.
Itu saja yang Anda perlukan untuk
membuat komponen baru.
Anda tak perlu memperluas
tampilan grup dengan metode
penggantian.
Lalu ada pengatur spasi kecil,
dan akhirnya
teks yang menjelaskan
item tersebut.
Ikon bookmark-nya di sini,
dan Anda bisa lihat
hal menarik lainnya.
Saya akan menunjukkan
apa yang akan saya ketik.
Itu trik saya kalau-kalau
saya lupa apa yang harus dilakukan.
Jadi ikon bookmark saya
cukup sederhana.
Mengambil salah satu
item tugas tersebut.
Dibaca oleh clickable.
Jadi, begitulah cara membuat
pemroses klik.
Saya memeriksa apakah ini item favorit,
dan jika item ini favorit,
saya tampilkan
gambar yang terkait
dengan status favorit.
Jika ini bukan favorit, saya
akan gunakan gambar lain.
Jadi ini bukan hanya
tentang menggunakan empat loop,
satu instance untuk tiap loop.
Anda bisa gunakan segala jenis
alur kontrol yang Anda mau.
Dan membuat kodenya amat
mudah dibaca.
Kode ini bisa dibuat dengan cara lain.
Jadi saya punya
dua callback di aplikasi.
Ada tombol favorit
dan batal, lalu
klik ikon bookmark.
Saya juga akan klik lainnya.
Saya akan coba menulisnya.

Korean: 
그런 다음 add composable
주석을 추가했습니다
이것만 하시면 새로운
구성요소를 생성할 수 있습니다
override 메서드를 통해 그룹 뷰에서
확장하지 않아도 됩니다
여기에는 작은 spacer가 있고요
항목을 설명하는 텍스트가 있습니다
북마크 아이콘은 여기 있습니다
여기 또 흥미로운 게 있는데요
입력하려고 했던 걸 보여드렸네요
잊어버릴까 봐 적어둔 건데 말이죠
이 북마크 아이콘은 아주 간단합니다
할 일 항목 중 하나를 취합니다
clickable 옆에 있는데요
이것이 클릭 리스너를 만드는 방법입니다
여기에서 제가 하는 것은
이 항목이 즐겨찾기로 지정되었다면
즐겨찾기 상태에 맞는 이미지를
표시하도록 하는 것입니다
즐겨찾기 항목이 아니라면
다른 이미지를 사용하고요
이것은 루프당 인스턴스 하나씩 해서
for 루프를 사용하는 것이
전부가 아님을 보여줍니다
원하는 모든 유형의
제어 흐름을 사용할 수 있습니다
그러면 코드를 읽기가 매우 쉬워집니다
이 코드를 다양한
방법으로 활용할 수 있습니다
이 앱에는 콜백이 2개 있습니다
북마크 아이콘을 클릭하려고 할 때
여기 toggleFavorite이 있습니다
여기를 클릭할 때도 마찬가지입니다
이제 이것을 코딩해 보겠습니다

English: 
And then I just added my
add composable annotation.
And that's all you need to
do to create a new component.
You don't have to extend from
view of your group in override
methods.
And then I just have a
small spacer, and finally
the piece of text that
describes the item.
So the bookmark icon is here.
And here you can see
another interesting-- oops.
I'm revealing what
I'm going to type.
That's my cheat in case
I forget what to do.
So my bookmark icon
is pretty simple.
It takes one of
those to-do items.
It's read by a clickable.
So that's how you create
a click listener really.
And inside all I do
is, I have this branch,
and I say, if this
item is a favorite,
then I want to show the
image that corresponds
to the favorite state.
And if it's not a favorite, I
want to use the other image.
So it shows you
that it's not just
about using four loops,
one instance for each.
You can use any kind of
control flow you want.
And it makes the code
extremely easy to read.
And you could do this piece
of code in different ways.
Anyway, so I have two
callbacks in the app.
I have this toggle
favorite, when
we're going to click
the bookmark icon.
And I also have one when
we click the [INAUDIBLE]..
So I'm going to
try to write them.

Chinese: 
当我们添加项目的时候
我就在项目列表中添加新项目
好巧 我的粘贴板中正好准备了这个项目
这样我们就给了你一个默认字符串和一个 ID
如果我重新运行它
你会发现 我一共就只做了这么多
没有做什么 Listener 也没有调用重新布局 
没有请求布局 也没有废除既有的布局
我点击按钮时 列表中会出现新项目
一共就需要做这么多
多亏了这里的 @Model 
我们观察到 项目在变化
现在 我想点击这个小书签开关
我现在点击一下 什么都没发生
我之所以这么做是因为
它属于不可变列表 看看我忘了没有
我输入 map 
实用编程 看起来好高端
来看看

Indonesian: 
Saat kita menambahkan
item, saya akan
mengambil daftar item,
lalu saya akan
menambahkan item baru
yang ada di
papan klip saya.
Yang didapatkan adalah
string default dan ID.
Jadi saat saya menjalankannya,
Anda bisa lihat,
cuma itu yang saya lakukan.
Tanpa pemroses.
Saya tak memanggil tata letak ulang,
meminta tata letak, atau menginvalidasi.
Saat saya klik tombolnya,
item baru muncul di daftar.
Itu saja.
Semua itu berkat @Model
ini di sini
karena kita melihat bahwa
itemnya berubah.
Sakarang saya mau
mengubah-ubah bookmark kecil itu.
Saat diklik sekarang,
tidak ada yang terjadi.
Saya melakukan ini karena
ini adalah daftar
yang tidak dapat diubah.
Coba kita lihat lagi.
Saya akan membuat peta.
Saya merasa keren sekali saat
melakukan pemrograman fungsional.
Mari kita lihat.
Ups.

English: 
So when we add an
item, I'm going
to take the list
of items, and I'm
going to add a new item
that I conveniently
have in my clipboard.
So it will just give you a
default string and an ID.
So if I rerun that--
And you can note,
that's all I did.
Right?
There's no listener.
I don't call re-layout, request
layout, or invalidate it.
And when I click the button, a
new item appears in the list.
And that's all you have to do.
And that's thanks
to this @Model right
here, because we observe
that the items are changing.
But now I want to be able to
toggle those little bookmarks.
Like when I click right
now, nothing happens.
So the way I'm doing
it is because it's
an immutable list--
Let's see if I remember.
So I'm going to do a map.
I feel so fancy when I do
functional programming.
Let's see.
Oops.

Japanese: 
アイテムを追加する場合は
アイテムのリストに対して
クリップボードにある
新たなアイテムを追加します
デフォルトでStringとIDが提供されます
再実行します…
必要なのは これだけです
リスナーや 再レイアウトの呼び出し
レイアウトの要求や無効化なしに
ボタンを押せば
新規アイテムが表示されます
ここまで簡単になったのは
@Modelのおかげでです
アイテムの変更を監視しているからです
次にアイコンをトグルできるようにします
今クリックしても何も起こりません
これを行う方法ですが
不変のリストなので…
ここではMapを使います
関数型プログラミングは洒落た感じがします
it...あれ

Portuguese: 
Quando adicionamos um item,
pego a lista de items
e adiciono um novo item que,
por conveniência,
está na área de transferência.
Vamos atribuir uma string padrão e um ID.
Vou executar de novo.
E vocês podem ver o que fiz.
Não tem listener.
Não chamo ReLayout, RequestLayout
nem invalido.
E quando clico no botão,
um novo item aparece na lista.
E é tudo que tem que ser feito.
E tudo graças ao @Model aqui,
porque observamos que os itens
estão mudando.
Agora quero ativar
esses pequenos favoritos.
Quando eu clico agora,
nada acontece.
O jeito de fazer isso,
como é uma lista imutável...
Vamos ver se me lembro.
Vou fazer um mapa.
Fico me achando quando faço
programação funcional.
Vamos ver.
Opa.

Korean: 
항목을 추가할 때는
항목 목록을 취하고
클립보드에 있는 새로운 항목을
추가합니다
그러면 기본 문자열과 ID가 생깁니다
이것을 재실행하면
확인하실 수 있습니다
그렇죠?
리스너가 없습니다
re-layout을 호출하거나
layout을 요청하거나 무효화하지 않습니다
버튼을 클릭하면
목록에 새로운 항목이 표시됩니다
이렇게만 하시면 됩니다
이 @Model 덕분에
항목이 변경되는 것을 확인할 수 있습니다
이제 이 작은 북마크를 토글하고자 합니다
지금은 클릭해도 아무 반응이 없습니다
왜냐하면 수정 불가능한 목록이기
때문입니다
제가 기억을 하고 있나 보겠습니다
맵 작업을 하려고 하는데요
함수형 프로그래밍을 할 때 신이 납니다
이제 보죠
앗

Spanish: 
Cuando agrego un elemento…
tomo la lista de elementos…
y agrego uno nuevo
que convenientemente tengo en el portapapeles
Les daré una string predeterminada y un ID.
Si vuelvo a ejecutarlo…
Pueden ver que es todo lo que hice.
¿No?
No hay un objeto de escucha.
No llamo al rediseño,
ni al diseño o a su invalidación.
Cuando hago clic,
hay un nuevo elemento en la lista.
Eso es todo lo que tienen que hacer,
gracias a este @Model aquí,
porque observamos que cambian los elementos.
Ahora quiero activar esos pequeños favoritos.
Ahora, cuando hago clic, no pasa nada.
Esto es porque se trata
de una lista inmutable.
Veamos si recuerdo.
Haré un mapa.
Me siento tan extravagante
cuando hago programación funcional.
Veamos.
Vaya.

English: 
It.ID equals the
item we clicked.
ID.
That will return a copy.
And I will do favorites
equals not todo.favorites.
So I'm just toggling
the Boolean.
Otherwise it'll just
leave the item unmodified.
All right.
That should work.
Relaunch the app.
So add a few items.
And now when I click,
it toggles the icon.
Yay!
Ooh.
Hm.
[GROANS]
And that's why
always be prepared.
All right.
I will make it work.
Oh, yeah.
I used the wrong item.
All right.
Add items.

Portuguese: 
"it.id" é igual ao item que clicamos.
"id".
Vai retornar uma cópia.
E vou fazer
"favorite" igual a "!todo.favorite".
Estou ativando o booleano.
Do contrário,
o item não é modificado.
Tudo bem.
Deve funcionar.
Reinicio o app.
Adiciono uns itens.
E agora, quando clico,
o ícone é ativado.
Eba!
E por isso sempre
esteja preparado.
Beleza.
Vou fazer funcionar.
Ah, tá.
Usei o item errado.
Beleza.
Adicionar itens.

Indonesian: 
It.ID setara dengan item
yang kita klik.
ID.
Ini akan menghasilkan salinan.
Dan do favorites setara
dengan not todo.favorites.
Saya akan mengubah
Boolean-nya.
Atau saya akan
membiarkannya.
Oke.
Ini harusnya benar.
Luncurkan ulang aplikasinya.
Jadi tambahkan beberapa item.
Dan saat saya mengkliknya,
ikonnya berubah.
Hore!
Oh.
Hm.
Karena itulah
kita harus selalu siap.
Baiklah.
Saya akan memperbaikinya.
Saya tadi menggunakan item
yang salah.
Tambah item.

Korean: 
It.ID는 우리가 클릭한
항목과 같다고 작성합니다
ID
복사본이 반환됩니다
그리고 favorites가
not todo.favorites와 같다고 입력합니다
지금 부울을 토글하고 있습니다
이렇게 하지 않으면
항목이 수정되지 않습니다
네
이제 작동하겠죠
앱을 재실행합니다
항목을 추가합니다
클릭하면 아이콘이 토글됩니다
네
오
음
[한숨]
이래서 늘 준비를 해야 하죠
네
문제를 해결해야죠
오, 네
잘못된 항목을 사용했네요
네
항목과

Chinese: 
if(it.id == todo.it)
返回一个 copy
(favorite = !todo.favorite)
这里我翻转了一下布尔值
否则这个项就不会更改
好 这样应该就行了
重启应用
添加几个项
现在点击 标志切换了 好！
哦...
看来没白准备 做演示 一定要留好后路 
好 一定行的
原来是项用错了
好 添加项 

Japanese: 
It.ID＝
クリックしたアイテムです
ID
これによりコピーが返されます
favorites＝!todo.favorites
Booleanをトグルします
そうしなければアイテムが変更されません
できました
アプリを再起動します
アイテムを追加します
クリックするとアイコンがトグルされます
できました
おや？あれ？
だから
いつでも準備が必要なのです
ちゃんと動かします
そうか
アイテムが違いました
アイテムを追加し

Spanish: 
It.ID es igual al elemento
en el que hicimos clic.
ID.
Eso mostrará una copia.
Pondré que favoritos
no es igual a todo.favorites.
Activaré el booleano.
De lo contrario,
dejo el elemento sin modificar.
Bien.
Esto debería funcionar.
Reinicio la app.
Agrego algunos elementos.
Cuando hago clic, se activa el ícono.
¡Si!
Oh.
Mmm…
Por eso, siempre hay que estar preparado.
Bien.
Haré que funcione.
Ahora sí.
Usé el elemento incorrecto.
Bien.
Agrego elementos.

Chinese: 
书签
好 可以了
这里的目的是 向大家展示
控制数据 构建逻辑 使其与 UI 互动 是多么的简单
更重要的是 你可以把它们隔开
或者说 比以前的分隔度更高
Adam 会为大家详细介绍 请切换回幻灯片
谢谢
在这部分的演讲中 我们会向大家详细介绍
我们在 Compose 背后的设计思路
让大家了解一下我们在想些什么
除了团队正在进行的 Compose 相关工作
我们还与社区进行了广泛的交流
这里的很多人也许就曾参与过这个对话
我们还对很多早前的用户做了调研
我们优先考虑的 最关心的 最重视的
也是大家即将面对的试用问题 是这样的
请注意 有些东西还没有实现
只是代表了我们面对这些开放式问题的思路
请参与我们的设计流程

Korean: 
북마크를 추가하고
네
됐습니다
이제 작동하네요
데이터를 조작하고
로직을 구현하고
UI와 상호작용하도록 하는 것이
얼마나 쉬운지 알려드리고 싶었습니다
더 중요한 것은 모두 분리하거나
예전에 비해 분리 정도를
강화할 수 있다는 것입니다
아담 씨가 자세히 설명해드릴 예정입니다
슬라이드를 다시 표시해 주시겠어요?
네
이 부분에서는 Compose의 설계에
근간이 된 생각을 조금 소개하고
우리의 계획에 대해 다룹니다
저희는 팀에서 Compose로
하고 있는 작업뿐 아니라
커뮤니티와 대화하는 데에
많은 시간을 할애했습니다
여러분 중에 이러한
대화에 참여하신 분도 있을 것입니다
보다 형식을 갖춘 사용자
연구를 진행하신 분도 계실 거구요
여러분이 테스트하실 때
저희가 가장 관심을 가지는 부분이나
저희가 중요하다고 생각하는 부분을
말씀드리려고 합니다
다만 아직 구현된 것은
아니라는 점에 유의하시기 바랍니다
아직은 명확한 답이 없는 질문들에 대한
저희의 생각일 뿐이니까요
그러니 디자인 과정에 참여해주실 것을

English: 
Bookmark.
Yes.
All right.
Now it works.
So again, the point
here is to show you
how easy it is to
manipulate your data
and to build that logic, and
make it interact with the UI.
And more importantly, you can
keep both kind of separated,
or more separated
than you could before.
But Adam will tell you
a lot more about that.
Can you go back to
the slides, please?
ADAM POWELL: All right.
So this is the part of the talk
where we talk a little bit more
about kind of our design
thinking behind Compose,
and kind of what's on our mind.
So in addition to the team's
ongoing work with Compose,
we've also been
spending a lot of time
talking with the community.
Some of you, have probably
been part of that conversation.
As well as running some
more formal user studies.
And so here are some of
the things that are really
sort of top of mind for us
that we're excited about
or that we think is really kind
of important as you take it
for a test drive.
So be careful that some of
this isn't implemented yet.
This is just kind of how
we're thinking about some
of these open questions.
So please join us
in participating

Portuguese: 
Favorito.
Pronto!
Beleza. Agora funciona.
De novo, o ponto aqui é mostrar
a facilidade de manipular os dados,
criar essa lógica
e fazê-la interagir com a IU.
E o mais importante,
dá para separar as duas coisas
ou mais separadas que antes.
Mas Adam vai falar
muito mais sobre isso.
Podemos voltar aos slides?
Beleza.
Nesta parte da palestra,
falamos um pouco mais
das escolhas de design do Compose
e qual era a ideia.
Além do trabalho atual da equipe
com o Compose,
também passamos um bom tempo
falando com a comunidade.
Alguns de vocês devem ter participado.
E executando estudos
mais formais com usuários.
Aqui estão algumas das nossas prioridades,
coisas que nos animam
ou que achamos que precisam de testes.
Atenção,
alguns ainda não estão implementados.
É só nosso pensamento
sobre umas questões abertas.
Então se juntem a nós
e participem do processo de design.

Spanish: 
Favorito.
Sí.
Bien.
Ahora funciona.
El punto es mostrarles
lo fácil que es manipular sus datos,
compilar esa lógica
y hacer que interactúe con la IU.
Lo más importante
es que se mantienen ambas separadas
o más separadas de lo que podían estar antes.
Adam les contará más acerca de eso.
¿Pueden volver a las diapositivas?
Bien.
En esta parte, veremos
cómo pensamos el diseño de Compose,
nuestras ideas detrás de él.
Además del trabajo del equipo con Compose
pasamos mucho tiempo con la comunidad.
Probablemente, alguno de ustedes
haya sido parte de esa conversación.
También hicimos
otros estudios de usuarios más formales.
Estas son algunas de las cosas
que consideramos más importantes
y que nos entusiasman,
o que creemos que vale la pena que prueben.
Cuidado que algunas
todavía no están implementadas.
Esto es acerca de cómo pensamos
en estas cuestiones.
Pueden acompañarnos

Japanese: 
ブックマークします
よし
ちゃんと動きました
繰り返しますが
ここでのポイントは
データを操作しロジックをビルドし
UIとやり取りさせることが
いかに簡単か という点です
さらに重要なのは 両方を
以前よりも分離できる点です
アダムが詳しく説明します
スライドに戻します
ここからは
Composeの設計思想や
私達の考えを詳しく話します
Composeの現在の取り組みに加え
コミュニティとの対話にも
時間を掛けました
一部の方は対話に参加されたと思います
公式のユーザー調査も実施しました
これからお話しするのは
私達の優先事項であり
ワクワクしている部分です
皆様にとって重要だろうと
考えているものです
一部は未実装ですが
未解決の問題に対する
私達の考えをお見せします
ですから設計プロセスの一部に

Indonesian: 
Bookmark.
Ya.
Sekarang bekerja.
Sekali lagi, ini
untuk menunjukkan
seberapa mudah memanipulasi
data Anda
dan membuat logika, serta
membuatnya berinteraksi dengan UI.
Yang lebih penting, Anda bisa
memisahkan keduanya,
atau lebih terpisah dibanding
yang sebelumnya.
Nanti Adam akan menjelaskannya.
Bisa kembali ke slide?
-OK.
Jadi, inilah yang kita
bicarakan tentang
jenis pemikiran desain
di balik Compose,
dan jalan pikiran kami.
Selain kerja tim yang
masih berlanjut di Compose,
kami juga mencurahkan waktu
untuk berbicara dengan komunitas.
Beberapa dari Anda mungkin
ikut di dalamnya.
Serta beberapa
studi pengguna yang lebih formal.
Inilah beberapa hal
yang menurut kami
sangat menarik atau penting
bagi Anda saat mencobanya
pertama kali.
Jadi, berhati-hatilah karena
beberapa belum diterapkan.
Ini cuma pemikiran kami
tentang beberapa
pertanyaan terbuka ini.
Jadi kami mengajak Anda
berpartisipasi

Spanish: 
y participar en parte del proceso de diseño.
Lo primero que viene a la mente
al comenzar a trabajar con Compose
es el flujo de datos.
Si bien algunas
de las herramientas disponibles
para administrarlo se incorporaron a Compose
en una etapa temprana
o incluso existían de antes,
en el caso de algunos sistemas
estándar funcionales y reactivos
a los que tal vez están acostumbrados,
las prácticas recomendadas
y los materiales de enseñanza
sobre el tema se siguen creando.
Es como que realmente
estamos creando algo nuevo.
Hasta ahora, las bibliotecas de componentes
de la arquitectura Android han sido exitosas.
Prepararon el escenario y generaron patrones
que seguimos usando en el mismo Compose.
Desglosemos algunas de estas ideas
y veamos a dónde nos llevan.
Siguiente.
Allí vamos.
En Google I/O mostramos este diagrama
durante la charla sobre Compose.
Como dije, lo primero que ven
es realmente el flujo de datos.
La forma de la API da forma
a este enfoque de arriba hacia abajo
y en una dirección.
Son funciones llamando a funciones.
Hasta ahora, a la mayoría les gusta.
Siempre es bueno
tener una única fuente de confianza
en su IU.

Chinese: 
大家在开始使用 Compose 时
首先面对的就是数据流问题
一些数据流管理工具很早就出现在 Compose 中
甚至早于 Compose 就已经存在
大家习惯的一些标准功能和响应系统就是例子
这方面的最佳实践案例和教学文档 暂时还没有完成
所以 我们正在构建的这个 绝对是新东西
Android 架构组件代码库迄今为止相当成功
它成为了很好的先例 
我们在 Compose 中也延续了它的模式
下面我们来总结一些思路 看看能导出什么结果
下一张 好
我们在 Google I/O 的 Compose 演讲中
展示过这张图表
如我所说 大家首先遇到的就是数据流
API 的结构多多少少会强制执行这种自上而下的单向数据流
只是功能在调用其他功能而已
迄今为止 大多数人喜欢这种做法
UI 中单一的数据源头是件好事

Indonesian: 
dalam beberapa proses desain.
Jadi, hal pertama yang
akan Anda lihat
saat mulai bekerja dengan Compose
adalah alur data.
Meskipun beberapa fitur
yang tersedia untuk mengelola
alur data tersebut ada di
Compose di awal mula,
atau sudah ada sebelum
ada Compose,
kalau-kalau ada beberapa
fungsi standar dan
sistem reaktif yang mungkin
Anda sudah terbiasa,
praktik terbaik dan materi
pengajaran tentang hal ini
masih dalam pengembangan.
Kami sedang membuat
sesuatu yang benar-benar baru.
Jadi, library komponen
arsitektur Android
sejauh ini selalu berhasil.
Dan penyiapannya bagus,
serta mempertahankan pola
yang terus kami gunakan
di Compose itu sendiri.
Jadi mari kita saring
beberapa ide itu
dan lihat ke mana arahnya.
Selanjutnya. Ini dia.
Jadi, kami menampilkan diagram
ini di Google I/O
saat membicarakan Compose
di sana.
Seperti yang sudah saya katakan,
alur data adalah
yang pertama akan Anda hadapi.
Bentuk API kurang lebih
menerapkan pendekatan alur
data satu arah dari atas ke bawah.
Ini hanya fungsi yang
memanggil fungsi,
yang disukai banyak orang
sejauh ini.
Sebaiknya ada
satu sumber tepercaya di UI Anda.

Portuguese: 
A primeira coisa que chama atenção
quando se começa
a trabalhar com Compose
é o fluxo de dados.
Ainda que algumas ferramentas disponíveis
para gerenciamento de fluxo
sejam parte do Compose
desde o começo
ou já existissem antes dele,
no caso de alguns sistemas
funcionais padrão
e reativos a que vocês podem
estar acostumado,
as práticas recomendadas e materiais
educativos sobre isso
ainda estão em construção.
Estamos realmente criando algo novo.
As bibliotecas de
componentes da arquitetura Android
tiveram muito sucesso até agora.
São uma boa base
e estabeleceram padrões
que continuamos com o Compose.
Vejamos algumas
dessas ideias com mais detalhes
e aonde elas nos levaram.
Próximo.
Aqui está.
Mostramos este diagrama no Google I/O
durante nosso palestra do Compose.
Fluxo de dados é a primeira coisa
com que você se depara.
A forma da API força essa abordagem
de cima para baixo
de uma direção do fluxo de dados.
São funções chamando funções.
E a maioria gosta, até agora.
É sempre bom ter uma única
fonte de verdade na sua IU.

English: 
in some of the design process.
So the first thing that
really kind of hits you
as soon as you start working
with Compose is the data flow.
And while some of the tools
available for managing
that data flow came
into Compose very early,
or they existed
before Compose did
in the case of just some of
the standard functional and
reactive systems that
you might be used to,
the best practices and teaching
materials around all of this
is still kind of a
work in progress.
Like we really are building
something new here.
So the Android architecture
components libraries
have been really
successful so far.
And it set the stage nicely,
and established patterns
that we've continued
with in Compose itself.
So let's go ahead and distill
down some of those ideas
and kind of see
where they lead us.
Next.
There we go.
So we showed this
diagram at Google I/O
during our talk
on compose there.
Dataflow is really the first
thing that you encounter,
like I said.
The shape of the API more or
less enforces this top down,
one way data flow approach.
It's just functions
calling functions.
And most people
like this so far.
So it's always good to have
a single source of truth
in your UI.

Korean: 
부탁드립니다
Compose로 작업을
시작할 때 가장 먼저
데이터 흐름에 직면하게 될 것입니다
데이터 흐름 관리에
사용 가능한 도구 중 일부는
Compose에 일찍 도입되었고
여러분이 알고 계실 수도 있는
표준 기능형 및 반응형 시스템의 경우
일부 도구가 Compose보다
먼저 존재하기도 했지만
이에 대한 권장사항과 교육 자료는
아직 완성 단계에는 못 미쳤죠
여기에서 새로운 것을
구현하고 있는 것처럼 말이죠
Android 아키텍처 구성요소 라이브러리는
지금까지는 성공적입니다
기반이 잘 잡혔고
Compose에서 유지하고 있는
패턴을 확립했습니다
그럼 이제 몇 가지 핵심 개념과
앞으로의 방향에 대해 살펴보겠습니다
다음
여기입니다
Google I/O에서
Compose에 대해 소개하면서
이 다이어그램을 보여드렸는데요
아까 말씀드렸듯이 데이터 흐름에
가장 먼저 직면하게 됩니다
API의 형태로 인해
다소 하향식으로 진행되며
일방향 데이터 흐름 접근 방식입니다
함수를 호출하는 함수에 불과합니다
여기까지는 괜찮으실 겁니다
UI에서 정보의 출처는 하나인 것이
좋습니다

Japanese: 
是非協力してください
Composeを使い始めて最初に気づくのが
データフローです
データフローを管理するための
一部のツールは
当初からComposeにあったものです
標準的な機能と
リアクティブシステムであれば
Compose以前から
存在していました
関連するベストプラクティスと教材は
全面的に刷新中です
Androidアーキテクチャコンポーネント
ライブラリは順調です
良い基盤となりパターンを確立し
Composeにも引き継がれています
そこでの方向性について
ご説明しましょう
こちらです
Google I/Oで
Composeの説明をした際
この図を表示しました
先程言ったように
まず気付くのはデータフローです
APIにより トップダウンで一方通行の
データフローが強制されます
関数が関数を呼び出しているだけです
ほとんどの人が支持しており
UIでの「単一の情報源」ですね

English: 
And it's kind of
frustrating when your views
have a different idea
about the state of your app
than your application model
does, which is definitely
the case when you're
working with views
in the average Android app.
So what do we mean when we talk
about single source of truth
in a UI?
Well, it's about avoiding
conflicts or making sure
that you're not showing
inconsistent data.
But it's also kind of about
who has write permissions
to that state.
So with Compose you
prevent inconsistencies
by having the owner
of a piece of state
pass that state to the
other composable functions
that need it.
So the parameters that we call
our composable functions with,
they have to come
from somewhere.
And the source of that data is
kind of our source of truth,
by definition.
And the interface that we use
to pass those parameters really
kind of determines what
the composable functions
can do with it, just like
with any other function.
So you see access control
layering like this in Kotlin
frequently in the
standard library.
You've got the list
interface here,
which only defines
the read methods.
But the methods to
actually change that state
are defined in mutable list.

Spanish: 
Es frustrante cuando sus vistas
tienen una idea diferente
acerca del estado de su app
del que tiene el modelo de la aplicación,
que es el caso cuando trabajan con vistas
en las apps para Android promedio.
¿Qué queremos decir con
una única fuente de confianza
en la IU?
Se trata de evitar conflictos o de asegurarse
de que no están mostrando datos incoherentes.
Pero también se trata
de quién tenga permisos de escritura
para ese estado.
Con Compose, se evitan las incoherencias
ya que el propietario del estado
pasa el estado
a las demás funciones componibles
que lo necesitan.
Los parámetros con los que se llaman
a las funciones componibles
tienen que venir de algún lado.
Por definición, esa fuente de datos
es nuestra fuente de confianza.
La interfaz que usamos
para pasar esos parámetros
determina qué funciones componibles
pueden usar el estado
al igual que con cualquier otra función.
En Kotlin, el control de acceso
por lo general se ve en capas
en la biblioteca estándar.
Aquí tienen la lista de interfaz
que solo define los métodos de escritura.
Pero los métodos que cambian el estado
se definen en una lista que se puede cambiar.

Japanese: 
アプリの状態に関して
ビューとアプリケーションモデルとの
考え方が一致しないと大変です
平均的なアプリでビューを扱う場合は
まさにそうです
UIの「単一の情報源」の意味ですが
コンフリクトを避ける
つまり一貫性のないデータを
表示しないようにすることです
また それを実現するため
権限を制限することでもあります
Composeでは非一貫性を防ぐため
状態を必要とする別のコンポーズ可能な関数に
オーナーが状態を渡します
コンポーズ可能な関数を
呼び出すパラメータが必要であり
そのデータのソースが
「単一の情報源」です
コンポーズ可能な関数ができることは
パラメータを渡すための
インターフェースによって決まります
他の関数と同様ですね
標準ライブラリにはこのような
Kotlinでのアクセス制御レイヤが
頻繁に見られます
Listインターフェースは
読み取りメソッドのみを定義しますが
状態変更のメソッドは
MutableListで定義されます

Indonesian: 
Agak membingungkan jika
tampilan Anda
memiliki ide lain tentang
status aplikasi
dibandingkan model aplikasinya,
yang biasanya
terjadi dengan tampilan
dalam rata-rata aplikasi Android.
Jadi apa maksudnya
satu sumber tepercaya
untuk UI?
Ini adalah tentang menghindari
bentrokan atau memastikan
bahwa data ditampilkan
secara konsisten.
Namun juga tentang siapa
yang menulis izin
ke status tersebut.
Jadi, dengan Compose,
ketidakkonsistenan dicegah
dengan membuat pemilik
suatu status
meneruskan status tersebut
ke fungsi composable lain
yang memerlukannya.
Parameter yang kita gunakan
untuk memanggil fungsi yang disusun
harus datang dari suatu tempat.
Artinya sumber data
tersebut adalah sumber
tepercaya kita.
Dan antarmuka yang kita gunakan
untuk meneruskan parameter itu
memang menentukan apa yang
dapat dilakukan fungsi
composable tersebut dengannya,
seperti fungsi lain.
Anda bisa temukan kontrol
akses berlapis seperti ini di Kotlin,
sering kali di library standar,
hanya ada daftar antarmuka,
yang hanya mendefinisikan
metode baca.
Tapi metode untuk
mengubah status itu
didefinisikan dalam daftar
yang dapat diubah.

Portuguese: 
E é frustrante quando as visualizações
têm uma ideia diferente
sobre o estado do app
daquela do modelo do aplicativo.
É esse o caso quando você trabalha
com visualizações
em um app Android comum.
O que significa uma
fonte única de verdade na IU?
Trata-se de evitar conflitos
ou garantir consistência dos dados.
E tem a ver também com quem
tem permissão de gravação nesse estado.
Com o Compose, você evita incosistências
fazendo o proprietário do estado
passar esse estado para outras
funções combináveis que precisem dele.
Os parâmetros que usamos para chamar
as funções combináveis
têm que vir de algum lugar.
E a fonte desses dados é
a fonte de verdade por definição.
A interface usada para passar
esses parâmetros
determina o que as funções combináveis
podem fazer, como em outras funções.
Essa criação de camadas
de controle de acesso
é comum no Kotlin
na biblioteca padrão.
Temos a interface de lista aqui,
que define apenas os
métodos de leitura.
Mas os métodos para alterar esse estado
são definidos na lista mutável.

Chinese: 
如果你的视图对你的应用状态的解读和应用模型的解读不同
无疑是相当令人沮丧的
而当你处理普通 Android 应用中的视图时
情况无疑就是这样的
那么 我们所说的“UI 中单一的数据源头”是什么意思呢
意思是 要避免冲突 不要显示不一致的数据
还包括 谁拥有对那个状态的写入权限
在 Compose 的帮助下 
你可以让一段状态的拥有者把状态传递给
其他需要状态的组合方法 以避免出现不一致现象
我们用来调用组合方法的参数 总得有个出处
而这个数据的出处 以其定义而言 也就是我们所说的数据源头
我们用来传递这些参数的接口可以决定
组合方法能用这些参数来做些什么
这一点和其他方法没有区别
所以 在 Kotlin 中的标准代码库里
这样的访问权限控制分层是相当常见的
这里有列表接口 这个接口只定义读取方法
但真正能改变这个状态的方法 是在可变列表中被定义的
就算我有一个可变列表

Korean: 
뷰에서 앱의 상태에 대해
애플리케이션 모델과는
다른 판단을 할 때
난감할 수 있는데요
일반적인 Android 앱에서
뷰를 가지고
작업하시는 경우에 그러합니다
UI에서 정보의 단일 출처란 무엇을
의미하는 걸까요?
바로 충돌을 피하고
일관성 없는 데이터를
표시하지 않도록 하는 것입니다
해당 상태에 대한 쓰기 권한을
누가 가지고 있는가에 대한
것이기도 합니다
Compose를 사용하면 상태의 소유자가
해당 상태를 필요로 하는
다른 composable 함수에
전달하도록 함으로써
비일관성을 방지할 수 있습니다
composable 함수를 호출하는 데
사용하는 매개변수는
다른 곳으로부터 와야 합니다
그리고 해당 데이터의 출처가
정의상 정보의 출처가 됩니다
이러한 매개변수를 전달하는 데
사용하는 인터페이스는
composable 함수가 이를 통해
무엇을 할 수 있는지 결정합니다
다른 함수와 마찬가지죠
Kotlin의 표준
라이브러리에서 이와 같은
액세스 제어
레이어링을 확인할 수 있습니다
read 메서드를 정의하기만 하는
목록 인터페이스가 여기에 있습니다
하지만 실제로 상태를 바꾸는 메서드는
수정 가능한 목록에 정의되어 있습니다

Spanish: 
Incluso si tengo ese tipo de lista
si paso una función
como la llamada doStuff de aquí
como interfaz de lista de solo lectura
puedo estar seguro de que doStuff
no cambiará mis datos por mí.
Desde un punto de vista,
la fuente de confianza
tiene que ver con la persona que tiene acceso
a una referencia que puede cambiar
en esa fuente de confianza
y los tipos de cambios que puede realizar
quien hace la llamada a esa referencia.
Si, de alguna manera,
pueden cambiar los datos reales
¿son una fuente de confianza?
Bueno, algo así.
Usamos lambdas de controlador de eventos
en Compose, porque es una manera
más restringida de expresar
un cambio específico
realizado en un estado
sin dejar de lado las claves del proceso.
Esto es lo que quiero decir.
Podemos mostrarlo mediante vistas
con algunas de las API que conocen.
Aquí solo agregué a la vista
un objeto de escucha de clics.
Dentro de ese objeto,
aprovecho que tengo acceso
a la variable myList
del ejemplo anterior.
Esa es nuestra lista que puede cambiar.
Está dentro de mi alcance léxico.

Chinese: 
如果我把它传递给一个方法
就比如这个 doStuff 方法 并将其作为只读列表传过去
那么我就相当肯定 doStuff 不会
在后面更改我的数据
从特定的视角来看 数据源头取决于
谁能访问到数据源
调用者又能用这个参照做出哪些变动
如果你可以任意改动源头
那么你自己是数据的源头吗？
可以算是吧 
我们在 Compose 中大量使用了
事件管理器 lambda
因为这是一种更受限制的方法
并且可以用来表达非常特定的状态变动
而无需交出钥匙
我的意思是这样的
我们可以使用视图和一些常见的 API 来展示这一点
这里 我添加了一个视图 ClickListener 
在这个 Listener 内部 
我可以访问之前提到过的 myList 这个变量
也就是我们的可变列表
这在我的代码作用域内

Korean: 
수정 가능한 목록이 있다고 해도
이를 읽기 전용 목록 인터페이스로서
do stuff와 같은 함수로 전달합니다
do stuff가 제 데이터를
임의로 변경하지는
않을 것입니다
어떻게 보면 정보의 출처는
해당 출처에 대한
수정 가능한 레퍼런스에 대한
액세스 권한이 누구에게 있는지
그리고 해당 레퍼런스를 통해 호출자가
어떤 변이를 수행할 수
있는지와 관련이 있습니다
내가 원하는 방식으로
정보를 변경할 수 있다면
내가 정보의 출처일까요?
그럴 수 있습니다
그렇기 때문에 이벤트 핸들러
람다를 Compose 전반에서 자유롭게 사용하는데
이 방법이 프로세스의
중요한 정보를 노출하지 않으면서
상태에 가할 수 있는
특정 변이를 표현하는
보다 제한적인 방법이기 때문입니다
이 말의 의미는 다음과 같습니다
이미 익숙하신 일부
API에서 뷰를 사용하여
설명하겠습니다
뷰의 클릭 리스너를 추가했습니다
리스너 내부에서는
이전 예시의 myList 변수에
액세스할 수 있다는 점을
활용하고 있습니다
이는 수정 가능한 목록입니다
제 렉시컬 스코프 내에 있습니다

English: 
So even if I have
a mutable list,
if I pass it to a function like
the aptly named do stuff over
here as the read
only list interface,
I can be reasonably sure that
do stuff isn't going to change
my data out from under me.
So from a certain point
of view, source of truth
has to do with who has
access to a mutable reference
to that source of truth,
and what kind of mutations
a caller can perform
with that reference.
If you can change the truth
in any way that you want,
are you yourself a source of it?
Well, kind of.
So we use event handler
lambdas kind of liberally
throughout Compose, because it's
kind of a more restricted way
to express a very specific
mutation that you can make
to state without actually giving
away the keys in the process.
So here's kind of
what I mean by that.
We can show this just by using
views with some of the APIs
that you're used to.
So here I've just added a
click listener of the view.
And inside that listener,
I'm using the fact
that I have access to
this myList variable
from the example before.
And that's our mutable list.
So that's in my lexical scope.

Japanese: 
例えばMutableListがあり
doStuffという関数に
読み取り専用の
Listインターフェースとして渡しても
doStuffがデータを変更しないことは
明らかです
つまり「単一の情報源」は
情報源に対する可変参照に
アクセスできる対象と
参照によって呼び出し側が変更できる内容を
どう制限するか？です
「単一の情報源」を
好きなように変更できるのであれば
それ自体が情報源なのか？
そうとも言えます
Composeでは
イベントハンドラのラムダ式を多用します
なぜならプロセスでキーを明け渡すことなく
状態の変更をかなり具体的に表現できる
より限定的な方法だからです
どういう意味か例示します
使い慣れているAPIとビューを使用して
表現できます
ビューのクリックリスナーを追加します
リスナー内では
前の例のmyList変数に
アクセスできることを逆手に取っています
それが可変リストです
字句スコープ内にあります

Indonesian: 
Jadi meski punya
daftar yang dapat diubah,
jika saya meneruskan fungsi seperti
do stuff untuk
melakukan hal ini
sebagai antarmuka daftar hanya baca,
saya yakin bahwa do stuff tidak
akan mengubah data saya
di luar pengetahuan saya.
Jadi, dari sudut pandang tertentu,
sumber tepercaya
terkait dengan siapa yang memiliki
akses ke referensi yang dapat diubah
ke sumber tepercaya itu,
dan jenis perubahan yang dapat
dilakukan pemanggil dengan
referensi itu.
Jika Anda bisa mengubah sumber
tepercaya sesuai keinginan,
apakah Anda adalah sumbernya?
Sepertinya begitu.
Jadi, kita gunakan lambda
penangan aktivitas dengan cukup
bebas di Compose, karena
mengekspresikan mutasi
sangat spesifik yang
bisa dibuat untuk menyatakan
tanpa benar-benar
memberikan kunci dalam prosesnya.
Jadi, inilah yang saya
maksudkan.
Kita bisa tampilkan dengan menggunakan
tampilan dengan API
yang biasa Anda gunakan.
Saya hanya akan tambahkan
pemroses klik tampilan.
Di dalamnya saya gunakan fakta
yang bisa saya akses di
variable myList ini
dari contoh sebelumnya.
Dan inilah daftar yang bisa diubah.
Ini yang ada dalam cakupan leksikal saya.

Portuguese: 
Então, mesmo se
eu tiver uma lista mutável,
se passá-la para uma função como "doStuff"
como interface de lista somente leitura,
"DoStuff" provavelmente
não vai mudar meus dados.
De uma certa perspectiva,
a fonte de verdade
tem a ver com quem tem acesso
a uma referência mutável
daquela fonte e com quais tipos
de mutações um caller pode fazer
com essa referência.
Se puder mudar a verdade
como quiser,
você é a própria fonte dela?
Bem, mais ou menos.
Usamos lambdas de
manipulador de eventos livremente
em todo o Compose
porque é uma forma restrita
de expressar uma mutação específica
que pode fazer no estado
sem deixar tudo exposto.
Vou explicar que quero dizer com isso.
Podemos mostrar isso usando visualizações 
com as APIs comuns para vocês.
Aqui, adicionei
um listener de clique na visualização.
Dentro do listener,
tenho acesso a essa
variável "myList" do exemplo anterior.
E essa é nossa lista mutável.
Ela está no meu escopo léxico.

Spanish: 
Puedo capturarla como parte
de un bloque de objeto de escucha
y usarla directamente.
No saqué una referencia que puede cambiar
del fragmento de código.
El bloque donde aparece esto
es el único lugar desde el que
se puede acceder a la lista.
No permití el cambio de maneras incontroladas
al darle una referencia.
Mi vista solo puede decirme
que se produjo un clic,
y yo definí la manera
en que este nivel superior
podrá responder a esos clics
según el nivel de acceso de la capa.
Este es un ejemplo muy simple.
Estamos usando listas.
También hicimos algo de eso
en la demostración.
Sirve para mostrarles
el resto de @Model.
Claramente, harán algo
un poco más sofisticado
que cambios directos en listas.
Pero tengan paciencia.
Un ejemplo más real,
podría ser algo similar a esto.
En este método de vinculación
de vistas de ejemplo
configuro un objeto de escucha
y hago algunas solicitudes a mi app
según los parámetros
que pasé al momento de la vinculación.
Al igual que antes,
con la lista que puede cambiar,
no le digo a los botones
cómo agregar y quitar favoritos.
Definí qué haría un botón vinculado

Japanese: 
リスナーブロックの一部として
直接使用できます
このコードスニペット外に
可変参照をリークしていません
このブロックが現れるのは
可変リストがアクセス可能な場所のみです
参照を提供して 制御できない形で
変更を許可する事態は防いでいます
ビューは
クリックを知らせることしかできません
このレイヤのアクセスレベルに基づき
クリックに対する上位の反応を
定義しています
これは単純な例です
リストだけを使用しており
デモでもお見せした通りです
@Modelの 残りの内容です
実際のアプリでは
リストの直接変更よりも
高度な内容を行うはずです
より現実に近い例は
このようになると思います
このビューバインディングメソッドの
サンプルでは
クリックリスナーを設定します
バインドが発生した際に渡された
パラメータに基づき
アプリに要求します
可変リストと同様に
ボタンにブックマークの追加と削除の方法を
示していません
ボタンにクリックイベントがあった場合の

English: 
So I can capture it as
part of a listener block
and just use it directly.
I haven't actually leaked
a mutable reference
outside of this code snippet.
The block where this
appears is the only place
where mutable lists is
accessible from anything.
I haven't permitted mutation in
any sort of uncontrolled ways
by giving out a reference to it.
So all my view can do is just
tell me that a click happened.
And I've defined how
this higher level
will respond to those clicks,
given this layer's access
level.
So this is a really
simple example.
And we're just kind
of using lists.
And we definitely did
some in the demo as well.
It's sort of a hand
wave for, hey, this
is the rest of the @Model.
I mean, clearly you'll be doing
something a little bit more
sophisticated than direct
mutations on lists.
So bear with us a little bit.
So a more real example might
do something kind of like this.
So in this sort of sample
view binding method,
I'm setting a click listener
and make some requests
to my app based
on the parameters
that I was passed to
when the bind happened.
So just like before
with the mutable list,
I didn't teach buttons how
to add and remove bookmarks.
I defined what a
bound button should

Portuguese: 
Então posso capturá-la como parte
de um bloco de listener e usá-la direto.
Não vazei uma referência mutável
fora do snippet de código.
O bloco onde isso aparece
é o único lugar
em que listas mutáveis são acessíveis.
Não permiti a mutação
de forma descontrolada
ao fornecer a referência.
O que minha visualização faz
é avisar de um clique.
E defini como esse nível superior
vai responder aos cliques,
considerando o nível de acesso da camada.
É um exemplo bem simples.
E estamos só usando listas.
Fizemos isso na demonstração também.
É como se fosse um aviso do tipo
"Este é o resto de @Model".
Óbvio que vocês farão algo
mais sofisticado que mutações em listas.
Mas aguentem um pouco.
Um exemplo mais real pode ser algo assim.
Neste exemplo com o método ViewBinding,
defino um listener de clique
e envio solicitações
ao app com base nos parâmetros
que passei quando o
vínculo aconteceu.
Como antes,
com a lista mutável,
Não ensinei botões a adicionar
e remover favoritos.
Defini o que um botão
vinculado deve fazer

Indonesian: 
Saya bisa rekam sebagai
bagian dari blok pemroses
dan langsung menggunakannya.
Referensi yang bisa diubah
belum bocor ke luar cuplikan kode.
Blok tempat kode ini muncul
adalah satu-satunya lokasi
yang bisa mengakses
daftar yang bisa diubah.
Saya belum izinkan mutasi
yang tak terkontrol
dengan memberi referensi padanya.
Yang bisa dilakukan tampilan saya
hanyalah menunjukkan ada satu klik.
Saya telah definisikan response
level tinggi ke klik,
asalkan ada level akses lapisan ini.
Ini contoh
yang amat sederhana.
Kita hanya menggunakan
daftar.
Dan melakukannya
dalam demo juga.
Semacam menunjukkan
bagian @Model
lainnya.
Sudah pasti 
Anda akan melakukan sesuatu
yang rumit dibandingkan mutasi
langsung pada daftar.
Jadi, bersabarlah.
Contoh yang lebih nyata bisa
jadi dengan melakukan hal seperti ini.
Ini contoh metode
mengikat tampilan,
saya akan tetapkan pemroses klik
dan buat permintaan
ke aplikasi berdasarkan
parameter
yang saya teruskan
saat pengikatan terjadi.
Seperti daftar yang bisa diubah,
saya tidak mengajari tombol
menambah dan menghapus bookmark,
hanya mendefinisikan apa yang
harus dilakukan tombol pengikatan

Chinese: 
所以我可以把它作为 Listener 代码块的一部分
直接使用它
除了这一小段代码 我没有泄露过可变的引用地址
它出现的代码块就是可变列表唯一可访问的地方
我没有给出引用地址
自然没有允许任何非受控方式的更改
我的视图只能告诉我 发生了点击
我已经按照这个视图本身的层级定义好了 
较高层级会对点击做出何种反应
这是一个非常简单的例子
我们只使用了列表
在演示里也使用了一些
就像是我们在挥手说
嘿 @Model 的剩余部分就这些了
显然 你会做的事情 显然要比直接在列表上改动要复杂一些
所以 请再忍受一下
再来举一个更真实的例子
在这个示例视图绑定方法中
我设置了 ClickListener 
基于绑定时的参数向我的应用发出一些请求
正如之前我们对可变列表所做的那样
我并没有去告诉按钮 如何添加和移除书签
我定义的是 绑定的按钮在受到点击时应该如何反应

Korean: 
이것을 리스너 블록의 일부로 캡처하여
직접 사용합니다
이 코드 스니펫 외부로는
수정 가능한 레퍼런스를
유출하지 않았습니다
이것이 표시되는 블록은
어디에서든 수정 가능한 목록에
액세스할 수 있는 유일한 장소입니다
저는 이에 대한 레퍼런스를 제공하여
통제되지 않는 방식의 변이를
허용하지 않았습니다
따라서 제 뷰는 클릭이
발생했다는 사실만 알려줄 수 있습니다
그리고 이 레이어의
액세스 수준을 감안하여
이 상위 수준이 클릭에 반응하는 방식을
정의했습니다
그렇기 때문에
이것은 아주 간단한 예시입니다
목록을 사용하고 있다고 할 수 있죠
시연도 해보았는데요
이는 @Model의
나머지 부분이 무엇인지
알려주는 역할을 합니다
물론 여러분은 분명
목록의 직접 변이보다
더 복잡한 작업을 하게 되실 것입니다
그러니 조금만 더 기다려주세요
좀 더 실제적인 예시는
이런 모양일 겁니다
이러한 샘플 뷰 바인딩
메서드에서는 클릭 리스너를 설정하고
바인드가 발생했을 때 전달받은
매개변수를 기준으로
앱에 요청을 보냅니다
이전의 수정 가능한 목록에서 그랬듯
저는 버튼에 북마크를 추가하고
제거하는 방법을 알려주지 않았습니다
저는 버튼이 클릭 이벤트를 발생시킬 때

Japanese: 
バウンドボタンの動作を定義しました
定義を設定するため
単に字句スコープである
コンテキストバウンドを使っています
これは標準的な内容です
なにが新しいのでしょうか？
これはCompose固有ではありません
しかし この構造を前提として
Composeのコードを
極めて密にできるのです
多くのボイラープレートを除外できることは
良いのですが
その代わり
小さなスペースに圧縮されることで
内容の把握が困難になります
Composeを使用した
同じパターンを見てみましょう
このケースはそこまで小さくなく
そこまで違って見えません
実際のボタンを 実装の詳細と
そのプロパティとして宣言しています
テキストとクリックされた際の反応です
先ほどと同じですね
ここでのシンタックスは興味深いです
先程 状態が下流に
イベントが上流にと言いましたが
テキストとonClickハンドラを
同じ方法でボタンに渡しています
どちらもパラメータです

Spanish: 
cuando el botón obtiene el evento de clics.
Usé el contexto
que estaba disponible cuando lo vinculé.
Ese es el alcance léxico
para formar esa definición.
Esto es bastante estándar.
¿Cuál es la novedad de esto?
Esto no es exclusivo para Compose.
Se trata del marco para lo que sigue
ya que el código de Compose es muy denso.
Creemos que poder quitar
tanto código estándar es genial.
El inconveniente es que,
a veces, las distinciones
de lo que están haciendo
se vuelven muy sutiles
cuando se comprimen
en un espacio tan pequeño.
Veamos el mismo patrón
que vimos con Compose.
En este caso, no es mucho más pequeño.
No se ve tan diferente.
Estamos declarando el botón real
como detalle de implementación
junto con sus propiedades.
Cuál es el texto
y qué sucederá al hacer clic.
Es lo mismo.
Pero aquí la sintaxis es interesante.
Antes dijimos que el estado
fluye hacia abajo y los eventos hacia arriba.
Pero estamos pasando el texto
y el controlador de onClick
de la misma manera.
Ambos son parámetros.

Korean: 
바인딩된 버튼이
해야 할 일을 정의했습니다
그리고 바인딩할 당시
제게 있었던 컨텍스트인
렉시컬 스코프를 활용하여
해당 정의를 만들었습니다
이 모두는 표준적인 것입니다
여기에 새로운 것이 있나요?
이것은 Compose에만
국한된 것이 아닙니다
이것이 함축하는 바는
Compose 코드의
밀도가 매우 높다는
의미입니다
이것의 좋은 점은
많은 상용구 코드를
없애준다는 것입니다
하지만 좁은 공간에 압축되면
하고 있는 작업의 특징이
미미해진다는 단점이 있습니다
이제 Compose를 사용하면서 보았던
동일한 패턴을 살펴보겠습니다
이 경우 실제로
그렇게 작아 보이지 않습니다
그렇게 달라 보이지도 않죠
실제 버튼과 버튼의 속성을
구현 상세로 선언합니다
텍스트가 무엇이고 클릭되었을 때
어떤 일이 발생하는지 등입니다
동일하죠
여기에서 구문이 좀 흥미롭습니다
상태 흐름은 하향이고
이벤트 흐름은 상향이라고 말씀드렸는데
텍스트와 onClick 핸들러를
버튼으로 전달하는 방식이
동일합니다
둘은 모두 매개변수입니다

Indonesian: 
saat tombol ini diklik.
Dan saya menggunakan konteks
yang tersedia buat saya
saat mengikatnya, itu hanya
cakupan leksikal,
guna membentuk definisi itu.
Jadi, ini semua sebenarnya
hal standar.
Apa yang baru di sini?
Maksud saya, ini tidak bersifat unik
hanya ada di Compose.
Tapi bisa terjadi selanjutnya
yang membuat
kode Compose itu benar-benar
padat.
Menurut kami, fitur menghilangkan
boilerplate sangatlah bagus.
namun akibatnya, kadang
perbedaan antara
apa yang Anda
lakukan menjadi agak kabur
jika dimampatkan ke
ruang yang kecil.
Mari kita lihat
pola yang sama
seperti yang kita lihat di Compose.
Dalam kasus ini, sebenarnya
tidak sekecil itu.
Dan tidak tampak beda.
Kita mendeklarasikan
tombol aktual
sebagai detail implementasi,
bersama propertinya.
Jadi apa itu teks dan apa yang
akan terjadi saat diklik.
Itu hal yang sama.
Namun sintaks-nya di sini
cukup menarik.
Tadi disampaikan bahwa status
mengalir ke bawah dan aktivitas ke atas.
Namun kita meneruskan teks dan
penangan onClick
ke tombol dengan cara sama.
Keduanya parameter.

Chinese: 
我还使用了绑定的上下文 也就是语法作用域
来完成这套定义
这些都是标准的东西 有什么新东西呢？
这些东西虽然都不是专属于 Compose 的
但它们为未来的东西提供框架
Compose 代码的密度非常高
我们认为 能移除这么多的样板代码固然是件好事
但代价是 由于代码密度太高
有时你所做的事情的独特性 就不是很容易体现了
下面我们来看看使用 Compose 做出的另一件类似的事情
在这个例子中 代码体积没小多少 看起来没什么差别
我们将实际的按钮及其属性定义为实现细节
也就是 它的文本是什么 被点击后会有何反应
还是一样的东西
但是这里的语法有点意思
我们说过 状态向下流 事件向上流
但我们却使用同样的方式
把文本和 onClick 句柄都作为参数交给按钮
所以在某种意义上讲 事件处理器只是一种

English: 
do when the button
raises a click event.
And I used the context
that was available to me
when I bound it-- that's
just the lexical scope--
to form that definition.
So this is all pretty
standard stuff.
So what's actually new here?
I mean, this isn't
unique to Compose here.
But it's kind of
the framing for what
comes next, which is that
Compose code is really, really
dense.
We think that this
is pretty great
that you can remove
so much boilerplate,
but the trade off for that is
that sometimes the distinctions
of what you're really
doing become kind of subtle
when it's compressed
into such a small space.
So let's look at
the same pattern
that we just saw using Compose.
In this case, it's not
actually that much smaller.
It doesn't look
that much different.
We're declaring
the actual button
as an implementation detail,
along with its properties.
So what its text is and what'll
happen when it's clicked.
Same thing.
But the syntax here is
kind of interesting.
We said before that state
flows down and events flow up.
But we're passing both text
and the onClick handler
to button in the same way.
They're both parameters.

Portuguese: 
quando iniciar um evento de clique.
E usei o contexto disponível
quando vinculei,
que é só o o escopo léxico,
para formar essa definição.
Coisa bem básica.
Qual a novidade aqui?
E não é só para o Compose aqui.
Mas é a preparação
do que vem em seguida,
que é o código do Compose, bem denso.
É legal porque é possível
remover muito código padrão,
mas, em troca, as distinções
do que você faz ficam sutis
quando comprimidas
em um espaço tão pequeno.
Vejamos o mesmo padrão usando o Compose.
Neste caso, não é muito menor.
Não parece muito diferente.
Estamos declarando o botão real
como um detalhe de implementação
com as propriedades dele.
O texto dele e o que acontece
quando for clicado.
Mesma coisa.
Mas a sintaxe aqui é interessante.
Vimos que o estado vai para baixo
e os eventos para cima.
Mas estamos passando "Text"
e o manipulador "onClick"
para o botão do mesmo jeito.
Eles são ambos parâmetros.

Japanese: 
イベントハンドラは下流にフローする
状態とも言えます
この状態は ブックマークボタンが作成し
所有しています
ちなみにボタンは
呼び出し可能で曖昧なトークンです
クリックされると
関連するブックマークを
追加や削除するよう
ブックマークまたは
他のオブジェクトに要求します
ローカルデータベースによる支援や
APIのバックエンドの呼び出しなどが
可能になります
UIのコンテキスト外で
偽装やテストが可能です
しかしここでは
UI自体とブックマーカーとのやりとりを
操作されるUIの構造と共に
１カ所で定義しています
従ってブックマーカーには
クライアントに適切な動作を
明示できます
「単一の情報源」は保持されています
これは「単一の情報源」の一面ですが
Composeのような
宣言型UIフレームワークの本当の価値は
経時変化に対応できる点です
時間や経時変化が
関係している場合も
コードが明快であれば助かります

Portuguese: 
Manipuladores de eventos são apenas
outro estado que flui para baixo.
É um estado que
o botão de favorito criou e que é dele.
O botão é só um token opaco
que pode ser invocado.
Quando clicado, faz uma solicitação
ao objeto de favorito ainda não definido
para adicionar ou remover
o favorito associado.
O favorito pode ficar
em um banco de dados local,
chamadas de API para algum back-end,
qualquer coisa.
Posso simular ou testar isso fora
do contexto da minha IU.
Mas defini como a IU
interage com o favorito em um lugar aqui,
com a estrutura da IU que é manipulada.
O favorito pode ser escrito para
expor operações apropriadas
para clientes como este.
A única fonte de verdade é preservada.
Esse é um snapshot da verdade.
Mas o real poder de um
framework de IU declarativo
como o Compose é que pode
acompanhar mudanças no tempo.
Seria legal se meu código
fosse sempre simples assim,
mesmo depois de um tempo
e quando há mudanças.

Chinese: 
普通的向下流动的状态
这是由书签按钮创建出来 并归其所有的状态
至于按钮 它只是一个可被调用的不透明标记而已
当它被点击时 我们会向这个尚未定义的书签或对象发出请求
要求它添加或删除相关书签
书签背后的数据也许是本地数据库 API 后端调用等
我可以在我的 UI 的语境之外用假数据或测试数据
但我在这里定义了 UI 应该如何与书签互动
我还定义了被操控的 UI 的结构
所以 我们可以让书签来展示出
它允许的操作选项 正如这里演示的一样
所以 这里保留了单一数据来源
这只是数据来源处理方法的一小部分
Compose 这样的声明式 UI 框架的真正力量是
无论你今后做出什么改动 它都能跟得上
所以 如果我的代码一直都这么简单直接 
即使不断改动也仍然如此 那就太好了
我们已经通过演示 看到了一些这方面内容

Spanish: 
De alguna manera, los controladores
de eventos son otro tipo de estado
que fluye hacia abajo.
Es un estado creado por el botón de favoritos
y que le pertenece.
En cuanto al botón
se puede invocar este token opaco.
Cuando se hace clic en él,
hacemos una solicitud
a este objeto o favorito
que no está definido aún
para que se agregue o se quite
el favorito asociado en respuesta.
El favorito puede estar respaldado
por una base de datos local.
La API llama a un backend.
Puede ser cualquier cosa.
Puedo imitarlo o probarlo
fuera del contexto de mi IU.
Pero yo definí cómo la IU interactúa
con el generador de favoritos aquí
junto con la estructura
de la IU que se está manipulando.
El generador de favoritos se puede exponer
a cualquier operación apropiada
para sus clientes, como esta.
Aquí se conserva
la fuente única de confianza.
Es una sola instantánea de esa verdad.
La verdadera fortaleza
de un marco de trabajo de IU declarativo
como Compose, es que puede
acompañar los cambios en el tiempo.
Sería muy bueno si mi código
fuera siempre así de simple
incluso cuando se involucra al tiempo
y cuando tiene cambios en el tiempo.

Indonesian: 
Dengan begitu, penangan aktivitas
hanya jenis status lain yang
mengalir ke bawah.
Ini adalah status tombol bookmark.
Jadi, selama tombol dilibatkan,
ini hanyalah token buram
yang dapat dipicu.
Saat diklik, kita
membuat permintaan
ke bookmark ini atau objek
yang belum didefinisikan di sini
untuk menambah atau menghapus
bookmark terkait
sebagai respons.
Pembuat bookmark
dapat dicadangkan oleh database lokal.
API memanggil beberapa back end.
Apa saja,.
Saya bisa buat tipuannya atau
mengujinya di luar konteks UI.
Tapi saya akan definisikan
interaksi UI itu
dengan pembuat bookmark
di satu tempat di sini,
bersama dengan struktur UI
yang sedang dimanipulasi.
Jadi, pembuat bookmark bisa ditulis
untuk mengekspos operasi apa pun
yang sesuai dengan kliennya
seperti yang ini.
Satu sumber tepercaya di sini
dipertahankan.
Itu adalah screenshot
sumber tersebut.
Tapi, kehebatan framework
UI deklaratif yang sesungguhnya,
seperti Compose, adalah bisa
menyesuaikan perubahan seiring waktu.
Akan menyenangkan jika kode saya
sesederhana ini, meski
ada komponen waktu dan
perubahan seiring waktu.

Korean: 
그렇기 때문에
이벤트 핸들러는 하향 흐름을 보이는
또 하나의 상태라고 할 수 있습니다
북마크 버튼이 생성하고 이를 소유하는
상태죠
그렇기 때문에 버튼에 관한 한
호출할 수 있는 것은 이
불투명한 토큰밖에 없습니다
이것을 클릭하면
여기에 아직 정의되지 않은
북마크나 객체로 요청을 보내어
관련 북마크를
추가하거나 삭제하도록
합니다
따라서 북마크 도구는
로컬 데이터베이스의 지원을 받을 수 있습니다
API는 일부 백엔드로 호출합니다
뭐든 상관없죠
저는 제 UI의 문맥 밖에서
위조하거나 테스트할 수 있습니다
하지만 저는 UI 자체가 여기 한 공간에서
북마크 도구와 상호 작용하는 방법과
조작되는 UI의 구조를 정의했습니다
따라서 북마크 도구는
이러한 클라이언트에 적절한
모든 작업을 노출하도록
작성될 수 있습니다
따라서 정보의 단일 출처가 보존됩니다
이는 정보의 단일 스냅숏입니다
하지만 Compose와 같은
선언적 UI 프레임워크의 진짜 강점은
시간이 지나면서 발생하는
변화를 계속 파악한다는 것입니다
시간과 시간에 따른 변화라는
변수에도 불구하고
코드가 늘 명확하다는 건 큰 이점입니다

English: 
So in a way, event handlers
are just another kind of state
that flows down.
It's a state that the
bookmark button created
and that it owns.
So as far as button
is concerned,
it's just this opaque
token that can be invoked.
So when it is clicked,
we make a request
to this bookmark or object
that's not yet defined here
to please add or remove
the associated bookmark
in response.
So the bookmarker might be
backed by a local database.
API calls to some back end.
Really whatever.
I can fake it or test it
outside the context of my UI.
But I've defined
how the UI itself
interacts with the
bookmarker in one place here,
along with the structure of the
UI that's being manipulated.
So bookmarker can be written to
expose whatever operations that
are appropriate to its
clients like this one.
So the single source of
truth here is preserved.
So that's a single
snapshot of that truth.
But the real power of a
declarative UI framework
like Compose is that it can
keep up with changes over time.
So it'd be really nice
if my code was always
this straightforward, even
when time is involved,
and when changes over
time is involved.

Japanese: 
ここまでのデモで
その点も少し確認できました
監視可能なデータの変化に基づき
UIを更新したい場合でも
Composeはそれに対応しています
先ほどのデモで見ましたが
＠Modelでクラスをアノテーションすると
Composeはプロパティの変化を検知します
なぜ新機能を追加したのか？
監視可能なコンストラクタが
すでに多くあるのに
新機能を追加する
メリットはなんでしょうか
その答えは
このように記述できるコードの
わかりやすさと
実際の使い勝手にあると思います
少しLiveDataを説明します
UI構築に役立つプロパティがあるからです
LiveDataは
単一のデータホルダーです
更新されると通知します
UIでは
最新の値のみが重要です
LiveDataは値をまとめて
最新のみを保持します
イベントを逃すことはありません
イベントはストリームされておらず
最新の状態しかありません
この点について@Modelは同様に動作します

Indonesian: 
Kita sudah melihatnya sedikit
dalam demonya sejauh ini.
Jika Anda ingin memperbarui UI
sebagai respons perubahan,
Anda harus membuat data
dapat dilihat.
Dan Compose siap melakukannya.
Seperti dalam demo,
saat menganotasikan class dengan @Model,
Compose akan mengetahui
kapan propertinya berubah.
Tapi kenapa kita tambah
sesuatu yang baru?
Ekosistem Android punya
banyak konstruksi yang bisa dilihat.
Apa manfaatnya menambahkan
sesuatu yang baru?
Kami rasa jawabannya
adalah kemudahan
pemahaman jenis kode
yang dapat ditulis dengan cara ini
dan ergonomik dari penggunaannya.
Mari kita bahas
data live sedikit.
Karena data live punya properti
rapi untuk membuat UI.
Secara fundamental, data live
adalah pemegang nilai tunggal.
Saya akan sampaikan
jika ada perubahan.
Untuk tujuan kita dalam UI,
hanya nilai terbarulah yang penting.
Data live akan
menggabungkan nilainya
dan hanya mempertahankan yang terbaru.
Tak ada peristiwa yang terlewat.
Tidak ada arus peristiwa.
Hanya ada status terbaru.
Dan @Model bertindak serupa
dalam hal ini.

English: 
So we saw a little bit of
that in the demo so far.
So if you want to update the
UI in response to changes,
well, you need your
data to be observable.
And Compose is ready for that.
We saw in the demo that when
you annotate a class with @Model
that Compose will know
when its properties change.
But why did we add
something new here?
The Android ecosystem has a
lot of existing observable
constructs.
So what gains do we
get from this that
justify adding something new?
Well, we think that the answer
lies somewhere between the ease
of understanding
of the kind of code
that we can write this
way, and also just
kind of the ergonomics of
actually using it in practice.
So let's talk about
live data for a moment.
Because it really has some neat
properties for building UI.
Fundamentally, live data
is a single value holder.
It'll tell you
when it's updated.
So for our purposes in a UI,
only the latest value matters.
Live data will
conflate its values
and only keeps the latest one.
There's no such thing
as missing an event.
You don't actually
have an event streamed.
There's only the latest state.
And @Model behaves much in
the same way in this regard.

Chinese: 
如果你想让 UI 能响应变动
那么你的数据就需要是可观察的
而 Compose 已经为此做好了准备
我们在演示中看到 
当你使用 @Model 来为一个类加上注解的时候
Compose 会知道它的属性何时改变
但是 为什么我们要添加新东西呢？
Android 生态系统已经有很多现存的可观察做法了
那么 我们添加新东西 得到什么好处了吗？
我们认为 这样写出来的代码比较好理解
在实践中这样做 更利于提高效率
现在我们来谈谈 LiveData
因为它的一些优秀属性非常适合用来构建 UI
从根本上讲 LiveData 是一个单一值容器
它会告诉你它何时被更新了
关于 UI 我们认为只有最新的数值才重要
LiveData 会合并变化值 确保只记录最新的值
不用担心“错过一个事件”这回事
没有事件流这回事 只需要考虑最新状态就行
@Model 的行为大致也是如此

Spanish: 
En la demostración, vimos algo de eso.
Si quieren actualizar la IU
en respuesta a cambios,
los datos deben ser observables.
Compose está listo para eso.
En la demostración vimos que,
para una clase anotada con @Model,
Compose sabe cuándo cambian las propiedades.
Pero, ¿agregamos algo nuevo?
El ecosistema de Android
tiene muchas construcciones observables.
¿Cuál es la ganancia como para justificar
agregar algo nuevo?
Creemos que la respuesta está
entre la facilidad de comprensión
del tipo de código
que podemos escribir de esta manera
y la ergonomía al ponerlo en práctica.
Hablemos sobre los datos en tiempo real
porque tienen algunas propiedades
para crear las IU.
Fundamentalmente, los datos en tiempo real
son un contenedor de valores únicos
que indican cuándo se actualizan.
En una IU solo importa el valor más reciente.
Los datos en tiempo real unirán sus valores
y solo conservarán los más recientes.
No se perderá ningún evento.
De hecho, no se transmiten los eventos.
Solo está el último estado.
@Model se comporta de manera similar.

Portuguese: 
Vimos um pouco disso na demonstração.
Se quiser atualizar a IU
em resposta a mudanças,
é necessário
que seus dados sejam observáveis.
E o Compose
está pronto para isso.
Vimos na demonstração: quando você
anota uma classe com @Model,
o Compose saberá quando a 
propriedade dela mudar.
Mas por que adicionamos algo aqui?
O ecossistema Android
tem muitas construções observáveis.
O que ganhamos
para justificar algo novo?
Acreditamos que a resposta está entre
a facilidade de entender o tipo de código
que podemos escrever assim
e a ergonomia de usar isso na prática.
Vamos falar do LiveData.
Ele tem propriedades legais
para construção de IU.
Basicamente, LiveData é
um detentor de valores únicos.
Ele avisa
quando os valores são atualizados.
Para nossos objetivos em uma IU,
só os valores mais recentes importam.
O LiveData combina os valores
e só mantém o último.
Não existe a perda de um evento.
Não há um stream de eventos.
Só há o último estado.
E @Model se comporta
da mesma forma nesse sentido.

Korean: 
시연에서 이 점을 확인할 수 있었습니다
변경사항에 따라
UI를 업데이트하고자 하실 때는
데이터가 관찰 가능한 것이어야 합니다
Compose는 이를 지원할
준비가 되어 있습니다
시연 중에 우리는 @Model로
클래스를 주석 처리하면
Compose에서 속성 변경 시점을
알게 된다는 사실을 확인했습니다
그런데 여기에 왜
새로운 것을 추가했을까요?
Android 생태계에는
기존 observable 구조가
많습니다
새로운 것의 추가를 정당화할 만한
어떤 이점이 있을까요?
이에 대한 답은
이러한 방식으로 작성한 코드를
쉽게 이해할 수 있다는 것과
코드를 실제로 사용할 때의 편의성
사이에서 찾을 수 있습니다
그래서 잠시 라이브 데이터에
대해 말씀드리겠습니다
라이브 데이터에는
UI 구현을 위한 유용한 속성이 있습니다
근본적으로 라이브 데이터는
단일 값을 가집니다
이를 통해
업데이트 여부를 확인할 수 있습니다
UI의 목적을 고려하면
최신 값만 중요하죠
라이브 데이터는 값을 결합한 뒤
최신 값만 유지합니다
이벤트를 놓치거나 하는 일이 없죠
이벤트가 스트리밍되지도 않습니다
최신의 상태만 존재하죠
이러한 점에서 @Model도
동일한 방식으로 작동합니다

Indonesian: 
Mari kita lihat lagi contohnya,
seperti kode bookmark
di demo sebelumnya.
Jika Anda menggunakan
komponen arsitektur Android,
model tampilan,
dan data live,
mungkin Anda pernah lihat ini.
Model tampilan seperti hub
untuk berbagai data
yang dapat dilihat,
beserta operasi untuk
meminta perubahan
atas data tersebut.
Kita bisa merefleksikan jenis
struktur yang sama dengan @Model,
tapi bisa dilihat ada
yang berbeda di sini.
Metode hasBookmark yang
kita gunakan dalam contoh
sebelumnya tidak
menghasilkan data
live dipetakan dan
harus dilihat satu per satu,
dan hanya mengakses
status objek internal.
Daftar bookmark-nya
bahkan tidak publik.
@Model mengembalikan
pembacaan normal
properti objek yang terjadi
dalam suatu cakupan khusus
menjadi langganan yang dapat
dilihat meskipun pembacaan itu
terjadi jauh di bawah
tumpukan panggilan.
Jika saya memanggil hasBookmark
melalui fungsi pembantu lainnya
yang diekstrak dalam refaktor
atau semacamnya,
meskipun dalam class yang
berbeda,
ini masih berfungsi.
Kita tak harus mengubahnya
jadi stream

Chinese: 
现在我们再来看另一个例子
有点像是之前提到过的书签代码
如果你在工作中遇到过 
Android 架构组件 视图模型和 LiveData
那么你可能已经见过类似的东西了
视图模型变成了沟通各种可观察数据的枢纽
同时 一些操作请求更改这些数据
我们也可以使用 @Model 来表达类似的结构
但是如你所见 还是有一些不同之处
我们在之前的例子中使用的 hasBookmark 方法
并没有返回单独可见的映射后的 LiveData
而只是在访问内部对象的状态而已
书签列表本身甚至都不是公开的
@Model 将一切在特定范围内正常读取对象属性的行为
变成了可观察的订阅
即使读取行为发生在调用栈几层之下的地方
如果我用反射出来的 helper 方法调用了 hasBookmark
即便是在另一个类里 仍然能够奏效
我们无需把它在每步都变成一个数据流或 LiveData 映射

Korean: 
이전에 보셨던 북마크 코드와 유사한
예시를 보겠습니다
Android 아키텍처 구성요소, 뷰 모델,
라이브 데이터를 다루신 적이 있다면
이와 비슷한 것을 보신 적이 있을 겁니다
뷰 모델은
다양한 observable 데이터와
해당 데이터에 대한
변경을 요청하는 작업에 대한
허브가 됩니다
따라서 @Model을 통해
동일한 구조를 반영할 수 있는데
여기에서 좀 다른 점이 보일 것입니다
저희가 전에 예시로 사용했던
hasBookmar 메서드는
개별적으로 관찰되어야 하는
매핑된 라이브 데이터를 반환하지 않습니다
내부 객체의 상태에 접근만 할 뿐입니다
북마크 목록도
공개되어 있지 않습니다
@Model은 읽기가 호출 스택의
몇 레이어 아래에서 발생하더라도
특정 범위 내에서 발생하는
객체 속성의 모든 정상적인 읽기를
observable
서브스크립션으로 전환합니다
hasBookmark를
리팩터링 등에서 추출한
다른 helper 함수로 호출했다면
완전히 다른 클래스에서 그랬다고 하더라도
여전히 작동할 것입니다
과정의 모든 단계마다
스트림이나 라이브 데이터 매핑으로

Spanish: 
Veamos un ejemplo
como el de código de favoritos que ya vimos.
Si trabajaron con componentes
de arquitectura de Android,
modelos de vistas y datos en tiempo real,
tal vez vieron esto antes.
El modelo de vista
se convierte en el concentrador
de varios datos observables diferentes
junto con algunas operaciones
para solicitar cambios a esos datos.
Con @Model, podemos reflejar
el mismo tipo de estructura
pero pueden ver que hay algo diferente.
El método hasBookmark
que usamos en el ejemplo anterior
no muestra datos en tiempo real asignados
que deben poder observarse
de manera individual.
Solo accede al estado interno del objeto.
La lista de favoritos no es pública.
@Model convirtió todas las lecturas normales
de las propiedades del objeto
que suceden dentro de un alcance especial
en suscripciones observables,
incluso si la lectura se produce
en capas inferiores a la pila de llamada.
Si llamara a hasBookmark
mediante otra función asistente
que extraje en una refactorización o similar,
incluso en una clase diferente,
esto podría funcionar.
No es necesario
convertirlo en una transmisión
o en datos en tiempo real en cada paso.

English: 
So let's take another
look at an example,
kind of like the bookmarks
code from before.
If you've worked with Android
architecture components, view
model, and live
data, you've probably
seen something like this before.
The view model sort
of becomes this hub
for a bunch of different
observable data,
along with some operations
to request some changes
to that data.
So we can reflect the same
sort of structure with @Model,
but you can see something
kind of different here.
So the hasBookmark method
that we used in the example
before, it isn't
returning a mapped
live data that has to be
individually observed.
It's just accessing the
internal object's state.
The list of bookmarks
itself isn't even public.
@Model has turned
any normal reads
of the object's properties that
happen within a special scope
into observable subscriptions
even if that read
happens layers down
the call stack.
If I called hasBookmark through
some other helper function
that I extracted in a
refactoring or something
like that, even in a
completely different class,
this would still work.
We don't have to
turn it into a stream

Portuguese: 
Vamos ver outro exemplo,
como o código de favorito mostrado antes.
Se trabalhou com componentes da
arquitetura Android,
ViewModel e LiveData,
já viu algo assim antes.
O ViewModel virou um hub
de vários dados observáveis diferentes
com algumas operações para
solicitar mudanças nesses dados.
Então podemos refletir a mesma
estrutura com @Model,
mas você pode ver algo
diferente aqui.
O método "hasBookmark" que usamos antes
não retorna um LiveData mapeado
que tem que ser
observado individualmente.
Está acessando apenas
o estado interno do objeto.
A lista de favoritos
não é nem pública.
@Model transformou todas as
leituras normais
das propriedades do objeto
realizadas dentro de um escopo especial
em inscrições observáveis,
mesmo se a leitura
acontecer camadas abaixo
na pilha de chamadas.
Se chamasse "hasBookmark"
por outra função auxiliar
que extraí
em uma refatoração ou algo do tipo,
mesmo em uma classe diferente,
isso ainda funciona.
Não temos que transformar em stream
ou mapeamentos de LiveData a cada etapa.

Japanese: 
別の例を見ていきましょう
前のブックマークに似ています
ViewModelやLiveDataを
扱ったことがあれば
目にしているかもしれません
ViewModelは監視可能なデータと
データへの変更を要求する操作の
ハブのような存在です
@Modelでも
同様の構造にできますが
状況は異なります
先程の例のhasBookmarkメソッドは
監視する必要がある
マッピングされたLiveDataを
返していません
内部オブジェクトの状態に
アクセスしているだけです
リストはパブリックですらありません
@Modelは
特別なスコープで発生する
オブジェクトのプロパティの通常の読み値を
監視可能なサブスクリプションに
変換できます
コールスタックの下位で発生した
場合でも対応します
リファクタリングで抽出した
他のヘルパー関数などを通じて
hasBookmarkを呼び出した場合
完全に違うクラスでも
機能するはずです
各ステップで
ストリームやLiveDataマッピングに

Chinese: 
我们来回顾一下之前讲过的书签按钮
我们的 UI 可以按照状态和时间快照的方式表达出来
Compose 可以帮助我们管理复杂的订阅操作
即使 @Model 对象在调用栈内部
或对象引用链条内部几层之外的地方
Compose 会自动在组合方法内插入这些可视范围
我们完全不必考虑
下面我们来回顾一下
我们需要可观察数据
Compose 会把 @Model 类作为可用的新工具添加进来
但它真正的优势在于 它带来了一种剖面图般的可视性
我们在应用中需要编写的订阅通道和管理代码数量更少 
而且 其他可观察反应式系统很好用 
如果它们适合你的应用 特别是适合应用中的特定层级
你无需弃用它们
所以 我定义的这个特定层级中的标签
返回 LiveData 来自 hasBookmark 的东西 或流 也就说得通了
这时 我们仍然可以通过使用这种方法

Korean: 
전환할 필요는 없습니다
이전 예시에서 북마크 버튼을 보더라도
상태와 시간의 스냅숏 측면에서
UI가 표현될 수 있음을 알 수 있습니다
그리고 Compose를 사용하면
서브스크립션 전체를 연결할 때의 복잡성을
관리할 수 있습니다
실제 @Model 객체가 호출 스택 전반에서
또는 객체 레퍼런스 체인 전반에 걸쳐
몇 레이어 떨어져
존재하는 경우에도 말이죠
따라서 Compose는
이러한 observable 범위를
composable 함수로
자동 입력하게 됩니다
여기에 대해 생각할 필요도 없죠
이제 정리해보겠습니다
observable 데이터가 필요합니다
Compose에서 @Model 클래스를
사용 가능한 새로운 툴로 추가하게 됩니다
여기서 좋은 점은 일종의
횡단 관측 가능성이 지원된다는 것입니다
이 덕분에 앱에서 써야 하는
연결 및 서브스크립션 관리 코드가
줄어듭니다
하지만 다른 모든
관측 가능한 시스템과 반응형 시스템도
훌륭합니다
하고 계신 작업에
이러한 시스템이 잘 맞는다면
계속 사용하시면 됩니다
애플리케이션의
다른 레이어에 잘 맞는 경우
특히 그렇습니다
따라서 라이브 데이터나 흐름
또는 hasBookmark의 요소를
반환하도록 정의한
이 특정한 레이어에서
북마크 도구에 잘 맞는다면
이와 같은 effect 함수를 사용해서

Portuguese: 
Se olharmos para o botão de favorito
usado antes, veremos que a IU
pode ser expressa em termos
dos snapshots de estado e tempo.
O Compose pode ajudar
na complexidade de juntar as inscrições,
mesmo se os objetos @Model
reais estiverem
a várias camadas de distância
na pilha de chamadas
ou em uma cadeia de referência
de objetos.
O Compose insere automaticamente
esses escopos observáveis
nas funções combináveis.
Não temos que pensar nisso.
Vamos recapitular.
Precisamos de dados observáveis.
O Compose vai adicionar classes @Model
como uma nova ferramenta.
Mas o interessante
é a capacidade de observação transversal.
Escrevemos menos código para gerenciar
inscrições e criar conexões nos apps.
Mas o fato é que todos os outros
sistemas observáveis e reativos são bons.
Não precisa deixá-los de lado
se forem adequados e fizerem sentido
em outras camadas do seu app.
Então, se faz mais sentido que o favorito,
nesta camada que defini, retorne LiveData,
um fluxo ou algo do "hasBookmark",

Japanese: 
変換する必要はありません
先程のブックマークボタンでは
UIを状態と時間のスナップショットで
表現できます
Composeはサブスクリプションを
つなげる複雑な作業を支援します
@Modelオブジェクトが
コールスタックや
オブジェクト参照チェーンをまたぎ
数レイヤ離れていてもです
Composeでは
コンポーズ可能な関数に
監視可能なスコープが
自動的に挿入されるため
私達は意識する必要がありません
要約しましょう
監視可能なデータが必要です
Composeは@Modelクラスを
新規ツールとして追加します
素晴らしいのは
横断的に監視できる点です
プラミングコードや
サブスクリプション管理コードを減らせます
重要な点ですが 他の監視可能で
リアクティブな優れたシステムを
状況に適せば
除外する必要がありません
特にアプリケーションの他のレイヤで
合理的な場合です
それが顕著なのが
このレイヤのブックマーカーです
ここではLiveDataやFlow
hasBookmarkの値を返しています

Indonesian: 
atau pemetaan data live
langkah demi langkah.
Jika kita lihat lagi tombol
bookmark di demo sebelumnya,
kita bisa lihat bahwa UI
bisa diekspresikan
dengan snapshot status dan waktu ini.
Dan Compose membantu
mengelola kerumitan mengatur
langganan ini untuk kita,
meski jika objek
@Model berada
jauh di lapisan lain di tumpukan
panggilan
atau di rantai referensi objek.
Compose akan otomatis menyisipkan
cakupan yang dapat dilihat ini
dalam fungsi composable.
Kita tak perlu
memikirkannya.
Mari kita ringkas semuanya.
Jadi kita memerlukan data yang
dapat dilihat.
Compose akan menambahkan
class @Model sebagai alat baru
untuk kita.
Namun, yang keren
adalah ini
memungkinkan jenis observasi
lintas sektor.
Jadi lebih sedikit kode
pengelolaan langganan
di aplikasi kita.
Tapi, semua sistem reaktif
dan yang dapat dilihat lainnya
ini amat hebat.
Anda tak perlu meninggalkannya
jika merasa cocok untuk Anda.
terutama jika masuk akal
di lapisan lain
dalam aplikasi Anda.
Jadi, bisa juga bookmarker
di lapisan tertentu ini
yang saya definisikan
untuk menghasilkan
data live atau
alur data, atau sesuatu
dari hasBookmark,
jika kita masih dapat

Spanish: 
Si volvemos a mirar el botón de favoritos
vemos que nuestra IU se puede expresar
en términos de estas instantáneas
de estado y tiempo.
Compose puede ayudar a administrar
la complejidad de unir estas suscripciones
incluso si los objetos de @Model
están a varias capas de la pila de llamadas
o de una cadena de referencia de objetos.
Compose insertará automáticamente
estos alcances observables
por nosotros en funciones componibles.
Ni siquiera tenemos que pensarlo.
Recapitulemos sobre eso.
Necesitamos datos observables.
Compose agregará clases de @Model
como una nueva herramienta disponible.
Pero lo bueno es que permite
un tipo de observabilidad interrelacionada.
Podemos escribir menos código
de administración de suscripciones
y de instalación en nuestras apps.
El tema es que todos estos sistemas
observables y reactivos son geniales.
No deben dejarlos de lado
si se ajustan a lo que están haciendo.
En especial, si tiene sentido
para otras capas de su aplicación.
Si tiene más sentido
para el generador de favoritos,
ya que definí que esa capa
muestre datos, flujo en tiempo real
o algo de hasBookmark,
podemos admitir una administración
de suscripciones automatizada

English: 
or live data mappings
each step of the way.
So if we take a look back at
our bookmark button from before,
we see that our UI
can be expressed
in terms of these snapshots
of state and time.
And Compose can help manage
the complexity of wiring
these subscriptions
together for us,
even if the actual
@Model objects might
be several layers away
across the call stack
or across an object
reference chain.
So Compose will automatically
insert these observable scopes
for us in composable functions.
We don't even have
to think about it.
So let's go ahead
and recap on that.
So we need observable data.
Compose will add @Model
classes as a new tool
that we have available.
But the cool thing
about it is that it
allows for the sort of
cross cutting observability.
So we can write less plumbing
and subscription management
code in our apps.
But the thing is is that
all these other observable
and reactive systems are great.
You don't have to
leave them behind
if they're a natural fit
for what you're doing,
especially if it makes
sense in other layers
of your application.
So if it makes more
sense for the bookmarker
at this particular
layer that I've
defined it to return a live
data or flow, or something
from hasBookmark,
then we can still

Portuguese: 
ainda podemos usar gerenciamento
de inscrições automatizado e explícito
com uma função de efeito, como esta.
Mais uma.
Agora sim.
Isso é o que acontece
por trás de algumas coisas.
O que nos resta em relação
ao fluxo de dados
é documentar recomendações
relacionadas à pergunta
que vocês ainda devem estar se fazendo.
Quais dessas ferramentas
devo usar e quando?
Ainda estamos estabelecendo
algumas dessas diretrizes e práticas.
E há mais coisas em andamento.
Ouvi muitas perguntas sobre como
trabalhar com recursos no Compose
e quais são nossos planos.
Vamos falar um pouco disso também.
Esse é o pensamento atual
que pode mudar.
Mas, no momento, é a nossa posição.
Quando se trata de usar
os recursos no toolkit,
aprendemos algumas coisas
no meio do processo.
E esta é importante.
Precisamos evitar muitas sobrecargas.
Alguns de vocês talvez reconheçam isso.

Indonesian: 
mendukung manajemen langganan
otomatis namun eksplisit
dengan fungsi efek, seperti ini.
Ini dia.
Jadi, itu tadi sedikit gambaran
di balik beberapa fungsi.
Selanjutnya terkait alur data,
kami harus dokumentasikan
rekomendasi untuk pertanyaan
yang mungkin Anda punya.
Seperti "fungsi mana yang harus
saya pakai? Kapan?"
Jadi, membuat panduan dan
praktik terbaik seperti ini
memang masih
berusaha kami selesaikan.
Selain itu,
saya dengar banyak pertanyaan
tentang cara menggunakan
resource di Compose,
dan apa rencana kami terkait ini.
Jadi kita sedikit bahas itu juga.
Sekali lagi, ini masih konsep
dan bisa berubah.
Tapi inilah rencana kami saat ini.
Jadi, terkait pemakaian
resource dan toolkit UI,
kami telah
mempelajari beberapa hal.
Dan ini adalah hal yang besar.
Kami perlu menghindari
terlalu banyak overload.
Beberapa dari Anda mungkin tahu
dari mana asalnya.

Japanese: 
このような場合 自動的かつ明示的な
サブスクリプション管理を
次のような効果関数を使用して
サポートできます
以上が 背景情報の包括的な説明です
データフローに関して残っている作業は
皆さんが疑問に思っている推奨事項を
文書化することです
どのツールをいつ使うべきか？
ガイドラインとベストプラクティスの確立は？
答えは策定中です
他の取り組み中の作業ですが
Composeのリソースに関する
質問が多く寄せられており
それについてもお話しします
現時点での考えであり
変わる可能性はありますが
今私達が思い描いている内容です
リソースとUIツールキットの使用に関して
開発の過程で学んだことがあります
重要な内容です
過剰なオーバーロードを
避ける必要があります
ご存知かもしれませんが

Korean: 
자동화되었지만
명시적인 서브스크립션 관리를
지원해드릴 수 있습니다
하나 더 있습니다
네
지금까지 배경 정보를 간단히 설명해
드렸는데요
데이터 흐름과 관련한 과제는
여러분 스스로에게 던지실지 모르는
남아 있는 질문, 즉 이 중 어떤 도구를
언제 사용해야 하느냐에 대한 권장 사항을
기록하는 것입니다
이러한 가이드라인과
권장 사항을 마련하는 작업은
여전히 진행 중입니다
더 많은 작업이 진행 중이죠
Compose에 있는 리소스를 가지고
어떻게 작업하느냐와
어떤 계획을 갖고 있는가에 대한
질문을 많이 받고 있습니다
그래서 이 부분도 다루겠습니다
다시 말씀드리지만
현재의 계획은 바뀔 수 있습니다
하지만 지금 저희가 염두에
두고 있는 것은 맞습니다
리소스와 UI 툴킷 사용의 경우
저희가 지금까지
깨달은 점이 있습니다
중요한 부분입니다
저희는 과부하를 피하고 싶습니다
어떤 분들은 과부하가
어디에서 비롯되는지 아실겁니다

Chinese: 
实现自动的订阅操作 像这样
翻页 好
以上相当于是幕后知识
那么 需要我们处理的数据流问题
就剩下这个之前提到的“推荐哪个”的问题了
也就是 我该使用哪些工具 何时使用？
现在我们还在努力编写指南 搜集最佳实践案例
同样正在制作中的还包括：
很多人问我 如何在 Compose 中处理资源
我们在这方面的计划是什么
那么我们就来谈谈这方面吧
这只是我们目前的想法 可能会改变
不过我们目前确实就是这样想的
使用资源和 UI 工具箱的时候
我们觉得我们一路走来学到了不少东西
而这个东西是其中比较重要的
我们需要避免过多的重载
有些人可能知道它们来自哪里

English: 
support automated but explicit
subscription management
by using an effect
function, kind of like this.
One more.
There we go.
So that's kind of the tour
of the background behind some
of that.
So really what's left
for us around data flow
is kind of documenting
recommendations
for the question
that's kind of left
that you're probably
all asking yourself,
which is which of these
tools should I use when.
So kind of establishing some
of these guidelines and best
practices are still kind
of a work in progress here.
So more things that
are a work in progress.
I hear a lot of
questions about how
to work with
resources in Compose,
and kind of what we
plan to do there.
So let's talk a little
bit about that too.
Again, this is current
thinking, subject to change.
But this is kind of where our
heads are at at the moment.
So when it comes to using
resources and the UI toolkit,
we kind of think
that we've learned
a few things along the way.
And this is kind of a big one.
So really we need to
avoid too many overloads.
Some of you might recognize
where these are from.

Spanish: 
pero explícita, mediante
una función de efecto como esta.
Una más.
Ahí está.
Ese es el recorrido
que hay detrás de todo esto.
Lo que nos queda decir del flujo de datos
es la documentación de recomendaciones
para la pregunta que nos queda
y que probablemente se estén haciendo:
¿cuál de estas herramientas
debería usar y en qué momento?
Todavía estamos trabajando
para establecer lineamientos
y prácticas recomendadas.
También estamos trabajando en otros temas.
Escucho muchas preguntas
acerca de cómo trabajar
con recursos en Compose
y qué planeamos hacer al respecto.
Hablaremos un poco acerca de eso también.
De nuevo, esto es algo actual,
está sujeto a cambios.
Pero es en lo que estamos trabajando.
Cuando se trata de usar recursos
y el kit de herramientas de IU
creemos haber aprendido algo en este tiempo.
Algo importante.
Realmente tenemos que evitar
demasiadas sobrecargas.
Algunos tal vez reconozcan
de dónde provienen.

Japanese: 
画像を設定する方法はとても多くあります
利便性です
非常に便利ですね
ただし実行にあたり
対象のビューが巨大になります
さらにまずいことに
コンポーズ可能な形で
ラップまたは再使用する場合
APIサーフェスの全機能を
反映する必要があります
これは管理しづらく不便です
それを基に構築する場合
さらに厄介です
コンポーズ可能な関数に
オーバーロードを提供する
理由は数多くあります
依存している基盤では
１つのことを行うのに
複数の方法を提供します
そのため すべてをカバーしようと
オーバーロードを増やすと
爆発的に増えます
ですからこれは避ける必要があります
またAndroidのビューが提供するものと
アプリで必要なものの
溝を埋めるライブラリが多くあります
画像読み込みライブラリが良い例です

Indonesian: 
Kami punya banyak cara
untuk mengatur gambar.
-Itu mempermudah.
-Sangat mempermudah.
Namun juga membuat
tampilan jadi begitu berat
saat diimplementasikan.
Yang lebih buruk,
artinya apa pun
yang akan menggabungkan
atau menggunakannya kembali
dalam model composable, harus
merefleksikan seluruh kapabilitas
permukaan API.
Kami tidak menginginkannya.
Amat merepotkan
untuk mengelolanya.
Dan lebih merepotkan lagi
bagi yang ingin menggunakannya.
Ada banyak alasan
untuk menawarkan overload
untuk fungsi composable
milik Anda sendiri.
Dan kami memperburuknya
dengan meminta Anda menggandakannya
untuk menghasilkan kelengkapan ini
karena beberapa hal mendasar
yang Anda andalkan
menawarkan banyak cara berbeda
untuk melakukan satu hal yang sama.
Jadi, itulah yang ingin kami hindari.
Kami juga melihat banyak
library lain
yang tampaknya menjembatani
tampilan Android
dan apa yang diperlukan oleh aplikasi.
Library pemuatan gambar 
adalah contoh yang bagus.

English: 
We have a lot of
ways to set an image.
ROMAIN GUY: It's a convenience.
ADAM POWELL: It's
very convenient.
But the thing is
is that this makes
the view in question
huge in terms
of its own implementation.
But even worse,
it means anything
that tries to wrap
or reuse one of these
in a composable fashion has to
reflect the whole capabilities
of the API surface.
We don't want this.
So it's annoying
for us to maintain.
And it's even more annoying
for anyone who wants
to build something on top.
Now, there are a
lot of reasons why
you might want to
offer overloads
for your own
composable functions.
And we would really be
doing you a disservice
by asking you to multiply that
by the number of overloads
that you might need to cover
for this form of completeness
because some underlying
piece that you're relying on
offered all of these different
ways of doing a single thing.
So that's something that
we'd kind of like to avoid.
So we've also seen a
lot of other libraries
appear to fill the
gaps in between what
Android views offer and
what you need in your app.
So image loading libraries are
a really great example of this.

Korean: 
이미지를 설정하는 방법이 많습니다
편리하죠
매우 편리합니다
하지만 뷰를 구현하는 측면에서
뷰가 너무 커진다는 점이
문제입니다
더 큰 문제는 구성 가능한 방법으로
이 중 하나를 감싸거나 재사용하려면
API 서피스의 모든 기능을
반영해야 한다는 것입니다
이런 방법은 원하지 않습니다
유지보수하기 까다로우니까요
이를 기반으로 무언가를
구현하려는 경우에는
더 성가시죠
자체 composable 함수에
과부하를 제공해야 하는 이유는
많습니다
여기에 완벽한 결과를 위해
필요한 과부하 횟수를
곱해야 한다고 말씀드린다면
정말 민폐일 겁니다
여러분이 의존하고 있는
일부 기본적인 부분이
동일한 작업을 다양하게
할 수 있는 방법을 제공했기 때문입니다
그러니까 이 방법은 피해야겠죠
저희는 또한 수많은 기타 라이브러리가
Android 뷰에서 제공하는 것과
실제로 앱에 필요한 것 간의
차이를 해소하는 것을 보았습니다
이미지 로딩 라이브러리가 좋은 예시입니다

Chinese: 
我们有很多做法来载入图像
只是为了方便而已
非常方便
但问题是 它把我们所讨论的这个视图的实现过程弄得太复杂了
更糟的是 任何试图用组合方法封装或重新使用这些东西的人
必须实现这个 API 全部的功能
这不是我们想要的
维护起来很麻烦
对于那些想在它上面构建东西的人 就更麻烦了
一个人想为自己的组合方法提供重载 原因可能有很多
如果我们让你用这个数字乘以重载次数
从而实现完整性 那我们无疑在帮你的倒忙
因为你依赖的某些基础部件用了各种不同的方式来做到同一件事
所以我们试图避免这个现象
我们还见过很多其他类型的代码库
用来填补 Android 视图能提供的东西
和你在应用中的需求之间的空白
图像加载代码库是一个很好的例子

Portuguese: 
Temos várias formas
de definir uma imagem.
É uma conveniência.
É bem conveniente!
Mas isso deixa a visualização
enorme em termos de implementação.
E o pior, qualquer coisa
que tente unir ou reutilizar uma delas
de um jeito combinável terá que refletir
todos os recursos da superfície da API.
Não queremos isso.
Para nós, é irritante.
E é pior para quem quiser
criar algo com base nisso.
Há muitos motivos
para oferecer sobrecargas
para suas funções combináveis.
E seria um péssimo pedir para
multiplicá-las pelo número de sobrecargas
necessárias para que tudo fique completo
porque alguma parte
subjacente da qual você depende
ofereceu todas essas
formas diferentes de fazer algo.
Isso é algo que queremos evitar.
Vimos outras bibliotecas
surgirem para preencher a lacuna
entre o que as visualizações oferecem
e o que é necessário em um app.
Bibliotecas de carregamento
de imagens são bons exemplos.

Spanish: 
Hay muchas maneras de configurar una imagen.
Es conveniente.
Muy conveniente.
Pero también hace que la vista
en cuestión sea enorme
en términos de su propia implementación.
Incluso peor, significa
que todo lo que intente envolver
o reutilizar una de estas
de manera componible
tendrá que reflejar todas las funciones
de la superficie de la API.
No queremos eso.
Resulta molesto mantenerlo,
y es más molesto aún
para quien quiere compilar algo
sobre esto.
Hay muchos motivos
por los que tal vez quieran
ofrecer sobrecargas
para sus propias funciones componibles.
Los estaríamos perjudicando
si les pidiéramos que multipliquen eso
por la cantidad de sobrecargas
que podrían necesitar para abarcar todo
porque algún bloque subyacente que necesitan
ofrece todas esas maneras diferentes
de hacer una sola cosa.
Eso es algo que queremos evitar.
También vimos que muchas otras bibliotecas
aparecen para llenar los vacíos
entre lo que ofrecen las vistas de Android
y lo que necesitan en su app.
Las bibliotecas de carga de imágenes
son un buen ejemplo de esto.

Korean: 
훌륭한 라이브러리는 엄청나게 많습니다
다양한 이미지 로드 및
캐시 정책이 적용되고
라이프 사이클 등에도 연계됩니다
많은 리소스가 동적이기 때문입니다
웹에서 온 것도 있습니다
디스크 캐시 등 다양한 곳에서
비롯되었을 수도 있습니다
시그널과 같은 적절한
라이프사이클 이벤트에 연계하는 것이
늘 재미있는 건 아닙니다
고쳐야 할 게 많죠
그래서 저희가 제공하는 것에서
정적 리소스에 훨씬 집중함으로써
특별한 유형의 데이터를 만들었습니다
그런데 내부에서 시스템을 바라볼 때
맹점이 생겼습니다
동적 리소스 정책 레이어를 작성하는 것이
훨씬 더 간단해져야 했죠
정적 리소스에도 같은 규칙이 적용돼야 합니다
동일한 공개 API 서비스를 사용해서요
코루틴은 정말 대단합니다
로만 씨는 제가 가끔 얘기를
멈추지 않는다고 말씀하셨는데요
네
맞는 말입니다
물론 당신만 그런 건 아니고요
더 있죠
suspending 코드 생성과 관련해
실험적 컴파일러로 해결할 문제가
몇 가지 있습니다

Japanese: 
良いものがたくさんあります
さまざまな画像の読み込みと
キャッシュのポリシーを適用し
ライフサイクルに紐付けるなどします
これはリソースが動的だからです
ウェブやディスクキャッシュ
その他から来ます
適切なライフサイクルイベントに
シグナルとして紐づけるのは
簡単ではありません
改善の余地が多くあります
私達は 静的リソースに注目しすぎたことで
特権的なデータを作成してしまいました
内部からシステムを見た際の
盲点が生まれたのです
この動的リソースポリシーレイヤの作成は
ずっと明快であるべきです
静的リソースも同様であるべきです
つまり操作に同じパブリックAPIサービスを
使用するということです
コルーチンは素晴らしいです
そろそろ時間ですね
マシンガントークですね
- この後も話が
- ええ
中断コード生成時の
コンパイラの諸問題を解決する
必要があります

Spanish: 
Hay muchas muy buenas.
Aplican distintas políticas de carga y caché
para imágenes,
vinculadas con ciclos de vida, etc.
Pero esto se debe realmente
a que muchos recursos son dinámicos.
Podrían provenir de la Web.
Podrían provenir de la caché de un disco
o de muchos otros lugares.
No siempre resulta divertido
vincularlos con los eventos
adecuados del ciclo de vida.
Hay mucho para corregir.
Nos concentramos tanto en recursos estáticos,
que creamos este tipo de datos privilegiados.
Se creó un punto ciego para nosotros
cuando mirábamos el sistema por dentro.
Debería ser mucho más sencillo
escribir estas capas de políticas
de recursos dinámicos.
Los recursos estáticos
deberían tener las mismas reglas
y operar con las mismas superficies de API.
Las corrutinas son increíbles.
Romain dijo que siempre lo digo.
Sí.
Siempre hablas sobre eso.
No eres el único.
Hay otros.
Tenemos que resolver
algunos problemas
con el compilador experimental

English: 
There's a bunch of
great ones out there.
And they apply different
loading and caching policies
for images, tie into
lifecycle, so on and so forth.
But really this is because a
lot of resources are dynamic.
They might come from the web.
They might come
from a disk cache
or plenty of other places.
And tying into the appropriate
lifecycle events as signals,
it's really not always fun.
There's a lot to get right.
So by focusing so much on static
resources in what we offered,
we kind of created this
privileged type of data.
It created a blind
spot for us when
we were looking at the system
kind of from the inside.
And it should be much more
straightforward to write
these dynamic resource
policy layers.
And static resources should
have to play by the same rules.
So using the same public
API services to operate.
So co-routines are awesome.
Romain mentioned
sometimes I won't shut up.
ROMAIN GUY: Yeah.
You never shut up about it.
You're not the only one.
ADAM POWELL: There are more.
So we still have a
few issues to work out
with the experimental
compiler around generating
suspending code.

Portuguese: 
Há várias ótimas por aí.
E elas aplicam diferentes
políticas de carregamento e cache
para imagens,
vinculação ao ciclo de vida etc.
Mas isso acontece porque vários
recursos são dinâmicos.
Podem vir da Web,
de um cache do disco, de vários lugares.
E ligá-los aos eventos adequados
de ciclo de vida, como sinais,
nem sempre é divertido.
Há muito o que corrigir.
Como focamos muito
nos recursos estáticos em nossos produtos,
criamos esse tipo privilegiado de dados.
Isso criou um ponto cego
quando olhamos o sistema de dentro.
E deveria ser bem mais simples escrever
as camadas de políticas
dos recursos dinâmicos.
Os recursos estáticos
deveriam seguir a mesma regra.
Usar os mesmos serviços de API
pública para operar.
Então as corrotinas são ótimas.
Como Romain falou,
eu não paro de falar isso.
Pois é.
Você nunca para de falar isso.
E não é o único.
Existem mais.
Ainda temos coisas a resolver
no compilador experimental

Chinese: 
当然 例子还有很多
它们使用了不同的图像加载和缓存策略
与生命周期实现捆绑 等等
但其实原因在于 很多资源是动态的
它们可能来自网页 磁盘缓存 等等很多地方
与适当的生命周期事件绑定并将此作为信号
并不是任何时刻都令人愉快的事
需要做对很多事情才行
通过重点关注我们提供的静态资源
我们创建出了这个特殊的数据类型
我们只顾从内部观察系统 而它暴露了我们的盲区
编写这些动态资源策略层 应该会简单很多
静态资源也应该遵循相同的规则
使用相同的公共 API 来操作
Coroutine 很棒
Romain 说过 我一说话就停不下来
是的 你一提到这个就滔滔不绝
不过这么做的可不是只有你一个 
还有别人 
在使用实验性的编译器生成 suspend 方法这个事情上
我们还有一些问题需要解决

Indonesian: 
Ada banyak yang bagus
di luar sana.
Semuanya menerapkan kebijakan
pemuatan dan pembuatan cache yang beda
untuk gambar, terikat ke siklus
hidup, dan lain sebagainya.
Tapi penyebabnya adalah banyaknya
resource yang dinamis,
yang mungkin berasal dari web,
atau cache disk,
atau banyak sumber lain.
Dan terikat ke aktivitas siklus hidup
yang sesuai dalam bentuk sinyal,
tidak selalu baik.
Ada banyak yang harus diperbaiki.
Dengan lebih berfokus pada resource
statis pada cara yang kami tawarkan,
kami membuat jenis data istimewa ini,
yang menciptakan titik buta
bagi kami saat melihat sistem
dari dalam.
Dan akan jadi lebih
sederhana untuk menulis
lapisan kebijakan resource dinamis.
Resource statis harus
digunakan dengan aturan yang sama.
Yaitu menggunakan layanan API
publik yang sama untuk beroperasi.
Rutinitas bersama memang hebat.
Romain kadang bilang bahwa
saya tidak bisa diam.
-Ya.
Anda selalu membicarakan hal itu.
Dan bukan Anda saja.
-Ada lagi.
Masih ada masalah
dengan compiler eksperimental
terkait pembuatan dan suspensi kode.

Portuguese: 
quanto à geração do código suspenso.
Não fizemos muito ainda.
Mas a intenção é padronizar as corrotinas
como primitivo assíncrono para carregar
recursos estáticos ou dinâmicos.
A classe R do Android também
é superconveniente.
Ter vários símbolos com
preenchimento automático
de recursos no app é bem legal.
Queremos manter essa conveniência,
mas eles serem todos ints
não é tão conveniente.
Eu me deparei com isso ontem
na criação da demonstração.
Dava um erro porque os arquivos
PNG e um XML tinham o mesmo nome.
E o ambiente de execução
tentava carregar o XML como bitmap.
-Sim, você se divertiu.
-Levamos 5 minutos para descobrir.
E nós que escrevemos.
Tudo bem.
Acho que dá encaixar
mais um item na lista
se uma certa pessoa der licença.
Criar camadas também é boa ideia.
Quando falamos sobre evitar
erros de tipos, recursos, sobrecargas,
a pergunta que surge é:
por que isso deveria
ser específico do Compose?
Estamos pesquisando se
trabalhar com recursos APK
pode ser melhor com o Compose.

Spanish: 
sobre la generación de código de suspensión.
Todavía no logramos mucho,
pero queremos estandarizar las corrutinas
como primitivo asíncrono
para trabajar con las cargas de recursos
dinámicos o estáticos.
La clase R de Android
también es muy conveniente.
Tener varios símbolos
que completarán automáticamente
los recursos de su app es bastante lindo.
Nos gustaría conservar esa comodidad
pero que sean ints no es muy conveniente.
Me encontré con eso ayer
cuando compilaba la demostración.
Se bloqueó porque tenía
los archivos PNG y un archivo XML
con el mismo nombre.
El tiempo de ejecución tomaba el archivo XML
y trataba de cargarlo como mapa de bits.
Sí.
Te divertiste con eso.
Nos llevó cinco minutos descubrirlo,
y luego lo escribimos bien.
Bien.
Creo que podemos meter
un elemento más en la lista
si no nos interrumpen.
Bien.
Usar capas también es una buena idea.
Porque cuando comenzamos
a hablar acerca de seguridad de tipos
y recursos, y evitar las sobrecargas
aparece la pregunta natural:
¿Por qué debería ser específico de Compose?
Estamos viendo si trabajar
con recursos de APK
podría resultar mejor con Compose o no.

Chinese: 
目前还没有太多的进展
但我们的意图是
将协程作为首选异步机制用于动态和静态资源加载
Android 的 R 类也非常方便
它提供了一些符号 
可以自动补全你应用中的一些资源 非常好
我们想保留这种便利性
但是 同时保留所有 就不是太方便了
昨天演示的时候我就遇到了这个问题
我们遭遇了崩溃 因为我的 PNG 文件和 XML 文件重名
所以 运行环境试图把 XML 文件作为位图来运行
然后就崩溃了
我们花了5分钟时间才解决
真不敢相信这个东西是我们写的
我想 如果大家还在听的话 幻灯片的这页还可以再加上一个项目
分层化也是个不错的想法
我们开始讨论类型安全 资源 避免重载这些话题之后
自然而然地 下一个问题就是 
为什么要把它们限定在 Compose 里？
我们面对的问题其实是 
无论你用不用 Compose
处理 APK 资源的方式还能不能进一步优化

Japanese: 
まだ課題は多いですが
コルーチンを
静的動的両方のリソース読み込みの
非同期プリミティブとして
標準化したいと考えています
またAndroidのRクラスも便利です
アプリのリソースを自動入力する
多くのシンボルは便利です
その利便性は維持したいですが
すべてintでは便利とは言えません
昨日デモをビルドしている時
それに直面しました
同名のPNGファイルと
XMLファイルがあったため
クラッシュしました
ランタイムがXMLを
ビットマップとして読み込もうとして
クラッシュです
苦労してましたね
理解するまで５分かかりました
そして書き直しです
それでは
このリストにもう１つ
追加したい点があります
階層化も素晴らしいアイデアです
型安全性とリソースや
オーバーロードの回避といった分野では
これらはCompose固有なのか？
という疑問が生じます
Composeでも それ以外でも
APKリソースの扱いを
改善できないか考えています

Indonesian: 
Kami belum bisa
menyelesaikan semuanya.
Tapi kami bertujuan
menjadikan rutin bersama
sebagai primitif asinkron
untuk menangani pemuatan resource
statis maupun dinamis.
Jadi, class R Android juga
cukup praktis.
Pelengkapan otomatis simbol
untuk resource
di aplikasi memang bagus.
Kami ingin mempertahankan
kenyamanan itu.
Tapi jika semuanya jadi
integer, tak akan menyenangkan.
-Saya mengalaminya kemarin
saat membuat demo.
Sistemnya crash, karena saya
punya file PNG dan file XML
dengan nama yang sama.
Runtime akan mengambil file XML
dan memuatnya sebagai bitmap.
Dan begitulah.
-Ya. Seru kan?
-Kami butuh lima menit
untuk memahaminya,
sebelum akhirnya bisa menulis.
-Baik.
Saya rasa kita bisa masukkan
satu lagi dalam daftar ini.
Oke.
Pembuatan lapisan
juga menarik.
Karena jika membahas
resource dan keamanan
jenis, dan menghindari overload,
pertanyaan yang umum
adalah kenapa hal-hal ini
harus spesifik untuk Compose?
Kami mencari cara agar
bekerja dengan resource APK
jadi lebih baik, terlepas dari
apakah Anda gunakan Compose.

English: 
So we haven't done a
whole lot here yet.
But our intention is to
standardize on co-routines
as our async primitive for
working with resource loading,
whether that's
static or dynamic.
So Android's R class is
also pretty convenient.
Having a bunch of
symbols that'll
autocomplete for the resources
in your app is pretty nice.
We'd like to keep that
sort of convenience,
but really all of them being
ints is not so convenient.
ROMAIN GUY: And I ran
into that yesterday
while building the demo.
I would get a crash, because
I had the PNG files and an XML
file with the same name.
So the runtime would
pick the XML file
and try to load it as a bitmap.
And blah.
ADAM POWELL: Yeah.
You had some fun with that.
ROMAIN GUY: It took us five
minutes to figure it out.
And we wrote the
god damned thing.
[LAUGHTER]
ADAM POWELL: All right.
I think that we might be able to
squeeze one more into this list
if someone will get
out of the way there.
OK.
So layering is a
pretty great idea too.
Because once we start
talking about type safety
and resources, and
avoiding overloads,
the natural question comes
up, why should any of this
be specific to Compose?
We're really kind of looking at
how working with APK resources
might be made better whether
you're using Compose or not.

Korean: 
아직 해결할 게 많습니다
저희는 동적, 정적에 상관없이
리소스 로딩 작업에 필요한
async primitive로
코루틴을 표준화하고자 합니다
Android의 R 클래스는
매우 편리합니다
앱에 있는 리소스에 대해
자동 완성되는 심벌이
많다는 것이 큰 장점입니다
이러한 편리성을 유지하고 싶지만
심벌이 모두 int라는 점은
그다지 편리하지 않습니다
어제 저도 데모를 구현하다가
느낀 점입니다
PNG 파일과 XML 파일을
동일한 이름으로 설정했다가
오류가 났습니다
그래서 런타임에서 XML 파일을 선택하여
비트맵으로 로딩을 시도했습니다
그랬었죠
네
재미있으셨겠어요
원인을
파악하는 데 5분 걸렸습니다
고생깨나 했죠
[웃음]
알겠습니다
이 목록에 하나 더 추가할 게 있는데요
잠깐만 비켜 주시겠어요?
네
레이어링도 좋은 아이디어입니다
유형 안전성과 리소스
그리고 과부하 피하기에 대해
얘기를 시작한 이상
자연스럽게 제기되는 질문은
이런 점이 왜 Compose에만
해당되는가입니다
저희는 Compose
사용 여부에 상관없이
APK 리소스를 어떻게 활용하는 것이
더 좋은지 살펴보고 있습니다

English: 
And while we're talking
about things that are great,
whether you're using
Compose or not,
let's go ahead and talk a little
bit about view compatibility.
So we like Kotlin itself so
much because you can adopt it
in an existing project at
your own pace incrementally,
just a little bit at a
time, one class at a time,
one test at a time, et cetera.
So we're designing Compose
to be used in the same way.
So if you have an
Android app today,
you probably have a lot of
views with layouts, maybe even
fragments that you've
extensively tested.
So they work.
Even once Compose graduates
to a stable release, rewriting
your existing and working
code upfront probably
doesn't sound so great.
So you don't have to.
So let's take a look at
a couple of the things
that we have in
mind here, and how
this might look once we spend
a little bit more time here.
So the first step
in interop for us
is being able to use just
a little bit of Compose
inside an existing app.
The API for this is about
as simple as it gets.
It's just one annotation.
And this may look familiar
if you saw our talk
from I/O earlier that
you'll be able to annotate
a composable function.
It'll ask the Compose compiler
to generate a view subclass
for you.

Indonesian: 
Jadi selagi kita membahas hal-hal bagus,
mari kita bahas
sedikit tentang kompatibilitas tampilan.
Kami amat menyukai Kotlin karena
bisa digunakan
di proyek yang sudah ada
sesuai kecepatan Anda,
sedikit demi sedikit,
satu demi satu.
Kami desain Compose 
agar bisa digunakan seperti itu.
Aplikasi Android bisa saja
punya banyak tampilan
dengan tata letak, atau
fragment yang sudah diuji
secara ekstensif.
Dan semua berfungsi.
Meski Compose akhirnya dirilis
dalam versi stabil, menulis ulang
kode yang sudah ada dan berfungsi
mungkin terdengar menyusahkan.
Jadi, ini tak perlu dilakukan.
Mari kita lihat beberapa hal
yang kita pertimbangkan,
dan kemungkinan hasilnya.
Langkah pertama
interoperabilitas adalah
kita harus bisa gunakan
sedikit Compose
di aplikasi yang sudah ada.
API untuknya harus
sesederhana mungkin.
Cukup satu anotasi.
Mungkin Anda sudah tahu
jika Anda melihat presentasi
kami di I/O kemarin bahwa
Anda dapat menganotasi
fungsi composable.
Fungsi akan meminta compiler
Compose membuat subclass tampilan.

Chinese: 
谈到这里 我们不妨来了解一下视图兼容性
我们非常喜爱 Kotlin 
因为你可以在现存项目中 按照自己的节奏来采用它 
每次加一点 一个类一个类地加 
一个测试一个测试地加 慢慢增加使用量 
我们设计 Compose 也是为了用于同样的用途
如果你有一个 Android 应用
那么你可能有很多的视图 布局 甚至详细测试过的 Fragment
它们都工作正常
即使有朝一日 Compose 进入了稳定状态
提前重写你的现有代码和工作代码 听起来也不是什么好事
所以 你不必这么做
下面来看一些我们目前构思的内容
看看今后它会变成什么样子
互操作的第一步 
就是只在现存应用的内部使用一点点的 Compose 
相关的 API 简单到不能再简单
只有一个注解
如果你之前在 I/O 大会上听过我们的演讲
那么你可能对它比较眼熟：
你可以注解一个组合方法
它会让 Compose 编译器生成一个视图子集

Japanese: 
ここまではメリットを列挙してきました
次は ビューの互換性です
Kotlinの優れた点は
既存のプロジェクトに
自分のペースで徐々に適用できることです
徐々にクラス単位や
テスト単位などです
Composeも同様に設計しています
現在のAndroidアプリには
レイアウトを含む多数のビューや
テストを重ねたフラグメントがあります
Composeが正式版になっても
既存の機能しているコードを
書き直すのは大変です
その必要はありません
今検討中の内容と
予想される結果を見ていきましょう
互換性の第１ステップは
既存のアプリで少し
Composeを使えることです
このためのAPIは単純です
アノテーション１つだけです
I/Oでの講演で見たもしれませんが
コンポーズ可能な関数を
アノテーションできます
コンパイラにビューのサブクラスの
生成を求めます

Portuguese: 
E como estamos falando de coisas legais
independentemente de usar o Compose,
vamos falar
de compatibilidade das visualizações.
Gostamos muito do Kotlin
porque dá para usar
em um projeto existente
no seu ritmo, gradualmente,
um pouco por vez,
uma classe por vez, um teste por vez etc.
Estamos projetando o Compose
do mesmo jeito.
Os apps para Android hoje
têm várias visualizações com layouts
e fragmentos que testou bastante.
E eles funcionam.
Mesmo quando o Compose chegar
a uma versão estável,
rescrever seu código atual
não parece legal.
Isso não é necessário.
Vejamos algumas ideias nossas
e como ficarão depois de um tempo.
O primeiro passo para interoperabilidade
é usar um pouco do Compose em apps atuais.
A API para isso é bem simples.
É só uma anotação.
E pode ser familiar se assistiu a palestra
do I/O sobre a possibilidade
de anotar uma função combinável.
Ela pede ao Compose Compiler
para gerar uma subclasse "View".

Korean: 
그리고 Compose 사용 여부에 관계없이
장점에 대해 얘기해 봤는데
이제 뷰 호환성으로 넘어갈까 합니다
저희가 Kotlin를 좋아하는 이유는
기존 프로젝트에서 점점 속도를 내면서
조금씩, 클래스 하나씩
테스트 하나씩 진행하면서
도입할 수 있기 때문입니다
그래서 Compose도
이와 동일한 방식으로 설계 중입니다
Android 앱이 있으시다면
레이아웃이 있는 다양한 뷰가 있을 겁니다
폭넓게 테스트한
부분이 있을 수도 있고요
따라서 제대로 작동합니다
Compose가 안정적인
출시 단계로 넘어가더라도
기존 코드나 작업 중인
코드를 다시 작성하는 것이
달갑지는 않을 것입니다
따라서 그러지 않으셔도 됩니다
이제 저희의 계획을 소개하고
시간을 더 투입하면 어떻게 발전될지
말씀드리겠습니다
상호 운용성에서 저희의 첫 번째 단계는
기존 앱에서 Compose를
조금만 사용하게 되는 것입니다
이를 위해 활용할
API는 매우 단순합니다
주석 단 한 개에 불과합니다
Google I/O에서
저희 강연을 보셨다면
익숙하실 건데
composable 함수에
주석을 다실 수 있을 겁니다
그러면 Compose 컴파일러에
뷰 하위 클래스 생성을
요청하게 됩니다

Spanish: 
Mientras, hablamos de cosas que son geniales
usen Compose o no.
Hablemos acerca
de la compatibilidad de vistas.
Nos gusta tanto Kotlin
porque podemos adoptarlo
en un proyecto existente
a nuestro ritmo y de manera incremental
de a poco, de a una clase
de a una prueba, etc.
Diseñamos Compose
para que se use de la misma manera.
Si ya tienen una app para Android
probablemente tengan muchas vistas con diseño,
incluso fragmentos que ya probaron.
Saben que funcionan.
Incluso una vez que Compose
pase a una versión estable,
reescribir de cero
código existente y que funciona bien
probablemente no suene tan genial.
Por lo que no tienen que hacerlo.
Veamos algunas cosas que tenemos en mente
y cómo podría quedar esto
una vez que le dediquemos más tiempo.
El primer paso de interoperabilidad
es poder usar Compose en una app existente.
La API para esto es sumamente simple:
es una anotación.
Puede que les resulte familiar
si vieron nuestra charla de I/O.
Podrán anotar una función componible,
y esta le pedirá al compilador de Compose
que genere una subclase de vista por ustedes

Korean: 
이렇게 하면 매개변수를 사용하는 것과
동일한 방식으로
데이터를 입력할 수 있는
적절한 setter 등이 있는
composable 함수의 인스턴스가 호스트됩니다
이제 기존 뷰 기반의 UI와 함께
Compose를 사용할 수 있습니다
아직 구현된 것은 아니지만
이 방식이 앞으로 대세가
될 것이라고 말씀드릴 수 있습니다
앞으로 가야 할 방향이죠
그렇죠?
가장 마지막에 하는 일에 대해서는
가장 큰 확신을 갖게 됩니다
누군가가 이 일을 시작했고
아직 끝나지는 않았죠
맞습니다
그래서 다음 단계에서는
아무래도 확신이 덜 듭니다
저희가 계속 테스트하고 있는
부분입니다
저희는 다양한
아이디어를 시도하고 있는데요
AOSP에서 확인하실 수 있습니다
Compose를 무작정 시작하신다고 해도
UI에 있는 뷰를 사용해야 하는 경우가
있을 겁니다
Compose 통합을 지원하지
않는 타사의 SDK를
통합하려고 하실 수도 있습니다
그때도 뷰가 필요하게 됩니다
그래서 저희는 최근 Android
스튜디오 빌드에서 보셨을 수도 있는
새로운 뷰 바인딩 기능의 활용을
고려하고 있습니다
혹시 익숙하지 않으실 수도 있는데
이와 비슷한 레이아웃
XML 파일이 있으시다면
뷰 바인딩을 통해 이 기능을 사용하도록 하는
코드를 생성할 수 있습니다
여러분에게 맞게 생성된
유형 안전성 객체를 확보하여

Indonesian: 
Compiler akan jadi host instance dari
fungsi composable itu,
dengan pengatur yang sesuai,
dan seterusnya,
yang bisa Anda gunakan
untuk memasukkan data
sama seperti melalui parameternya.
Ini akan memungkinkan
Compose digunakan bersama
UI berbasis tampilan yang ada.
Cara ini belum diimplementasikan,
tapi kami yakin inilah cara yang tepat
Benar kan?
Kita cenderung meyakini
hal terakhir yang kita lakukan.
-Seseorang mulai mengerjakannya.
Cuma belum selesai.
-Benar.
Langkah selanjutnya
sedikit kurang pasti.
Dan kami akan membuat
prototipenya.
Anda bisa ikuti kami di AOSP
karena kami mencoba
beberapa ide berbeda.
Jadi meski langsung
menggunakan Compose,
Anda mungkin masih perlu
menggunakan tampilan dalam UI itu,
atau perlu
integrasi SDK pihak ketiga
yang belum menawarkan integrasi
Compose,
dan masih ingin menggunakannya.
Jadi, salah satu ide kami adalah
menggunakan fitur pengikatan
tampilan baru di
versi Android Studio terbaru.
Jika belum terbiasa,
dan file XML tata letak Anda
terlihat seperti ini,
pengikatan tampilan akan
menghasilkan kode
sehingga Anda bisa lakukan ini.
Jadi Anda mendapat objek type safe

Japanese: 
コンポーズ可能な関数のインスタンスを
適切なセッターでホストするなどします
パラメータの場合と同様に
データを提供するため使用できます
既存のビューベースのUIで
Composeを使用できます
まだ実装されていませんが
この方向性に自信を持っています
大抵こんな進行ですよね？
最も自信のある部分を
最後に行う
まだ終わっていないだけなのでは？
ですね
次のステップは確実性が落ちます
プロトタイピングです
私達が試す様々なアイデアを
AOSPで確認できます
Composeから始める場合も
ある段階でUIにビューを使う必要が
あるでしょう
Composeの統合に未対応の
サードパーティ製SDKでも
使用可能にしたいです
最近のAndroid Studioビルドで
見たかもしれませんが
新しいビューバインディングの
活用を考えました
簡単に説明します
このようなレイアウトXMLファイルの場合
ビューバインディングは
消費できるコードを生成します
型安全なオブジェクトが生成され

Spanish: 
Esto alojará una instancia
de esa función componible
con los establecedores adecuados y demás
a fin de que puedan usarlos
para introducir datos
al igual que lo harían con los parámetros.
Eso les permitirá usar Compose
con su IU basada en vistas.
Esto todavía no está implementado,
pero creemos
que es la manera correcta de hacerlo.
Suele ser así.
¿Verdad?
Lo último que se hace
es sobre lo que se está más seguro.
Bueno, alguien comenzó a trabajar en esto.
No ha terminado.
Bien.
El próximo paso es un poco menos certero.
Es algo sobre lo que crearemos prototipos.
Pueden seguirnos en AOSP
mientras probamos las diferentes ideas.
Incluso si eligen usar Compose primero
tal vez necesiten
usar vistas dentro de la IU en algún momento.
Tal vez, están integrando un SDK de terceros
que todavía no ofrece
integración con Compose.
Pero igual quieren poder usarlo.
Se nos ocurrió aprovechar
la nueva función de vinculación
de vistas que tal vez vieron
en compilaciones de Android Studio.
Si no la conocen
y tienen un archivo XML de diseño
que se ve así, la vinculación de vistas
generará código
que pueden consumir de esta manera.

English: 
This'll host an instance of
that composable function,
with appropriate setters,
so on and so forth
that you can use to feed
it data in the same way
that you would via
its parameters.
So this will let you use
Compose alongside your existing
view-based UI.
So this still isn't
implemented yet,
but we're pretty confident
that this is the way to go.
And that's kind of the
way that things always go.
Right?
It's the things that you're
most sure about are the things
that you do last.
ROMAIN GUY: Well, someone
has started working on this.
It's just not finished.
ADAM POWELL: Right.
So the next step is a
little bit less certain.
And this is something
that we're going to be
doing some prototyping on.
And you can follow
along with us in AOSP
as we kind of play with
some different ideas.
So even if you dive
into Compose head first,
you'll probably still need
to use views within that UI
at some point.
Maybe you're integrating
a third party
SDK that doesn't offer
Compose integration yet.
You still want to
be able to use it.
So one idea that we've had is
to leverage the new view binding
feature that you might have
seen in recent Android Studio
builds.
So if you're not
familiar with it,
if you have a layout XML file
that looks something like this,
view binding will
generate some code that
lets you consume it like this.
So you get a type safe
object generated for you

Chinese: 
它会 host 一个组合方法实例
并配备适当的 setter 等等
你可以使用它来写入数据
就像通过参数写入数据一样
这样 你就可以和现存的基于视图的 UI 一起使用 Compose 
这个功能还没有实现
不过我们相信 这就是未来的方向
其实大多数事情都是这样的
你最确定的事 就是你上次做过的事
有人已经开始做这件事了 只是没完成而已
好吧
下一步的不确定性就比较大了 还处在原型阶段
大家可以在 AOSP 上关注我们的进展
一起实验各种新奇的想法
即使你义无反顾地加入了 Compose 
有时候 你可能仍然需要在 UI 内部使用视图
也许你的第三方 SDK 暂不提供 Compose 需要整合
这时 你还是想使用它的 我们的一个想法是
利用你可能在最近的 Android Studio 中
见过的新的视图绑定功能
如果你还不熟悉它
如果你的布局 XML 文件看起来像是这样
视图绑定会生成一些代码
让你像这样去使用它们
这样一来 它就为你生成了一个类型安全对象

Portuguese: 
Isso hospeda uma instância
da função combinável,
com setters apropriados, e assim vai.
E você pode usar para alimentar os dados
como faria por meio parâmetros.
Isso vai permitir o uso
do Compose com sua IU
baseada em visualizações.
Isso não foi implementado ainda,
mas estamos certos
que é o melhor jeito.
É como são as coisas.
Aquilo de que mais temos certeza
é o que fazemos por último.
Alguém já começou a trabalhar nisso.
Só não terminou ainda.
Certo.
A próxima etapa é um pouco menos certa.
Vamos criar alguns protótipos.
E vocês podem
acompanhar o processo no AOSP.
Mesmo se mergulhar de cabeça no Compose,
precisará usar
visualizações na IU em algum momento.
Talvez ao integrar um SDK de terceiros
sem integração com o Compose.
Mas seria bom poder usá-lo.
Tivemos a ideia de usar o novo
recurso de vinculação de visualizações,
que pode ser visto nas versões
mais recentes do Android Studio.
Se ainda não conhece,
se tem um arquivo XML de layout como este,
a vinculação gera um código
que permite que você consuma assim.
Temos um objeto livre de erros de tipos

Spanish: 
Obtienen un objeto de seguridad de tipos
generado para ustedes
que pueden usar para vincular valores
y objetos de escucha en el código.
Cuando usen la función desde Compose,
pueden imaginarse que se verá
parecida a esto.
Si bien puede ser bueno
para dar vida a diseños configurados
implica trabajo adicional
si quieren usar vistas personalizadas.
También podríamos
usar el sistema de composición
para administrar una jerarquía de vistas.
El compilador de Compose
y el tiempo de ejecución de composición
se diseñaron
para manipular el árbol de vistas.
Aquí, en lugar de volver a usar diseños,
podríamos usar cualquier
subclase de vista existente
como si fuera nativa de la IU de Compose.
Pero tiene la limitación de que puede hacer
que las cosas se vean demasiado similares.
Hay muchas diferencias en los límites.
Algunas cosas, como editar texto,
tienen muchas trabas cuando se tratan de usar
en este tipo de estilo reactivo
donde la fuente de confianza única
está fuera de la vista.
Las implementaciones de vista existentes
quieren tener su propio estado, básicamente.
Los contratos de diseño funcionan distinto…
Estamos intentando descubrir
cuál es el equilibrio correcto
con algunos de estos temas.
Así que esto,
al igual que otras cuestiones de diseño

Indonesian: 
yang bisa digunakan untuk mengikat
nilai dan pemroses di kode.
Anda bisa bayangkan
perubahan seperti ini
saat menggunakannya
dari Compose.
Meski tampak baik karena
memberi masa hidup pada tata letak
yang sudah ada,
ini jadi kerjaan ekstra
jika hanya satu tampilan kustom
yang diinginkan.
Ide lain adalah 
menggunakan sistem komposisi
untuk langsung mengelola
hierarki tampilan.
Runtime komposisi
dan compiler Compose awalnya
dibuat untuk manipulasi struktur
tampilan secara langsung.
Daripada menggunakan ulang tata letak,
gunakan subclass
tampilan yang sudah ada
seolah-olah itu tampilan
native untuk UI Compose.
Namun, batasannya adalah
beberapa tampilan
jadi terlihat terlalu serupa.
Ada banyak ketidakcocokkan
di bagian batas.
Dan yang paling terlihat
adalah pengeditan teks,
akan ada banyak kekurangan
saat coba digunakan
dengan gaya reaktif ini,
jika satu sumber tepercaya ada
di luar tampilan tersebut.
Jadi, implementasi tampilan
yang sudah ada
masih ingin memiliki statusnya,
kontrak tata letak
bekerja dengan cara lain,
dan sebagainya.
Kami mencoba mencari
keseimbangan terbaik
dengan beberapa hal ini.
Seperti beberapa ruang desain
lain yang sudah kami bicarakan,
ini akan menghabiskan

Chinese: 
你可以使用它来在代码中绑定数值和监听器
可以想像 如果你通过 Compose 来使用它
它就可能会成变成这样
这样也许能一些写好的布局顺利运行
如果你只想使用一个定制视图 
那么它会导致你多做一些工作
另一个想法是 我们可以使用合成系统本身来直接管理视图层级
Compose 编译器和合成运行时
最初设计是用来直接操纵视图树的
这里 我们没有重新使用布局
而是使用了任意现有的视图子类
就好像它们是 Compose UI 原生的那样
但这种方法的局限性在于
它会让多个物体看起来太过相似
边界地带发生了很多错配现象
有些东西 其中最值得一提的是 编辑文本
当你试图按照这种反应式的风格使用它的时候
发生了很多的错误
单一数据源存在于视图之外
现存的视图实现仍然想要拥有它们自己的状态
布局的运作方式各不相同 等等
我们正在尝试找到正确的平衡之道
这个设计 正如我们谈过的其他设计一样

Portuguese: 
que podemos usar para
vincular valores e listeners no código.
É possível transformar
em algo assim com o Compose.
Isso pode ser legal para
desenvolver layouts já definidos,
mas leva a trabalho extra se quiser
usar uma visualização personalizada.
Outra ideia é usar
o sistema de composição
para gerenciar
a hierarquia de visualizações.
O Compose Compiler e o
ambiente de composição
foram projetados para manipular
diretamente a árvore de visualizações.
Aqui, em vez de reutilizar layouts,
posso usar uma subclasse "View" existente
como se fosse nativa da IU do Compose.
A limitação disso é
que as coisas podem ficar muito parecidas.
Há muitas discrepâncias nos limites.
E ações como a edição de texto
são muito capciosas
quando você tenta usar no estilo reativo,
em que a fonte única de verdade
está fora da visualização.
E implementações de visualização atuais
ainda querem manter o próprio estado.
Contratos de layout são diferentes etc.
Estamos tentando encontrar o equilíbrio.
Esses e outros espaços de design
de que falamos vão nos ocupar

Korean: 
코드에서 값과 리스너를
여기에 결합할 수 있습니다
Compose에서 뷰 바인딩 기능을 사용하여
무언가를 전환하는 방식을
여기에서 확인할 수 있습니다
이미 설정한 레이아웃을
사용하게 되는 것은 좋지만
맞춤 뷰를 하나 사용하려면
추가 작업이 필요하기도 합니다
또 다른 아이디어는
구성 시스템 자체를 사용하여
뷰 계층을 직접 관리하는 것입니다
Compose 컴파일러와 구성 런타임은
원래 뷰 트리를 직접 조작하기 위해
설계되었습니다
그래서 여기에서는
레이아웃을 재사용하기보다
기존 뷰 하위 클래스를
마치 Compose UI에
네이티브인 것처럼 사용할 수 있습니다
하지만 상호 구분이
모호해질 수 있다는 제약이 있습니다
경계가 잘 안 맞는 부분이 많죠
특히 텍스트 수정하기의 경우
정보의 단일 출처가
뷰 밖에 존재하는 반응형 스타일에서
기존 뷰 하위 클래스를 사용하려고 하면
문제가 생깁니다
따라서 기존 뷰를 구현할 때는
여전히 상태를 소유해야 합니다
레이아웃 컨트랙트의 작동 방식 또한
다릅니다
그래서 저희는 최적의 균형을
파악하려 하고 있습니다
이전에 말씀드렸던
기타 설계 영역과 마찬가지로
앞으로 몇 주에 걸쳐
상당한 시간을 투입해야 하는

Japanese: 
値やリスナーを
バインドするために使用できます
Composeから使用する場合は
このような変換を想定できます
既存のレイアウトの活用なら良いですが
単一のカスタムビューを使う場合は
追加作業が必要となります
別のアイデアは
システム自体を使用した
ビューレイヤの直接管理です
Composeコンパイラとランタイムの
当初の目的は
ビューツリーを直接操作することです
レイアウトの再使用ではなく
既存のビューのサブクラスを
ComposeのネイティブUIと同様に扱えます
しかし欠点があります
少し見た目が似すぎることです
境界に不一致が多くあります
特にEditTextは
このような単一の情報源がビューの外にある
リアクティブなやり方では
罠が多くあります
従って既存のビュー実装には
状態を所有させる必要があります
レイアウトコントラクトも
動作が異なります
これらの適切なバランスを
見極めようとしています

English: 
that you can use to bind values
and listeners to it in code.
So you could imagine that
turning into something maybe
like this when you
use it from compose.
While this might be nice for
giving life to some layouts
that you've already setup, it
implies some additional work
if you just want to
use one custom view.
Another idea is that we
could use the composition
system itself to directly
manage a view hierarchy.
The Compose compiler
and composition runtime
were originally designed
to manipulate the view
tree directly.
So here, rather than
reusing layouts,
you could use any
existing view subclass
as if it were native
to Compose UI.
But a limitation
that this has is
that it might make things
look a little bit too similar.
There's really a lot of
mismatches at the boundaries.
And some things, like,
most notably, edit text,
comes along with
a lot of gotchas
when you're trying to use it
in this sort of reactive style,
where the single source of truth
lives outside of that view.
So the existing
view implementations
still fundamentally
want to own their state.
And layout contracts
work differently,
so on and so forth.
So we're trying to figure
out what the right balance is
with some of these things.
So this, like some of the other
design spaces that we just
talked about, are
going to be occupying

Spanish: 
sobre las que hablamos,
será lo que nos tenga ocupados
durante las próximas semanas.
Queremos que la interoperación
con su código existente
sea lo más simple posible
y que no los haga crear trabajo adicional
si cambian sus restricciones.
Los mantendremos informados
a medida que continúe el desarrollo.
Seguramente,
ahora se están haciendo otra pregunta.
Ya escucharon lo que podemos hacer.
Y también lo que intentamos hacer.
Pero, ¿cómo hacen para probarlo?
Hoy publicamos un nuevo sitio web.
d.android.com/jetpackcompose.
Actualizamos el contenido
del sitio web de Jetpack Compose
que incluye, por ejemplo,
cómo enviar errores.
Pueden visitarlo.
Como parte del contenido,
publicamos un tutorial
que los guiará
por los principios básicos de Compose
algo así como lo que hicimos hoy
pero con mucho más detalle.
Échenle un vistazo.
Pueden leerlo y todo cobrará sentido.
También pueden descargar
la nueva compilación de Android Studio
que admite Jetpack Compose.
Debería estar disponible pronto, creo.
Lo siento.
También obtendrán una nueva plantilla…
La está subiendo ahora.
…para la actividad de Compose
que configurará todas sus dependencias
y todo lo demás.

Korean: 
부분입니다
저희의 목표는 기존
코드와의 상호 운용성을
최대한 용이하게 하는 동시에
제약 사항이 변경되는 경우
추가 작업이 생성되지
않도록 하는 것입니다
개발 과정에서 새로운 소식을
계속 알려드리겠습니다
이제 궁금해하실 만한
다른 주제로 넘어가겠습니다
지금까지 저희의 계획과
실현 방법에 대해 말씀드렸습니다
저희는 오늘 새로운
웹사이트를 발표했는데요
d.android.com/jetpackcompose입니다
이 Jetpack Compose 웹사이트에
버그를 신고하는 방법 등의
콘텐츠가 올라와 있습니다
가셔서 확인해보시기 바랍니다
게시한 콘텐츠에는 튜토리얼도 있습니다
튜토리얼을 통해 Compose의 기본 원리 등
오늘 진행한 강연과 비슷한 내용을
더 자세하게 확인하실 수 있습니다
확인해보시기 바랍니다
가서 읽어보시면 이해가 잘 되실 겁니다
또한 Jetpack
Compose를 지원하는
Android 스튜디오 빌드를
다운로드하실 수도 있습니다
곧 게시될 예정입니다
[기침]
죄송합니다
[웃음]
새로운 템플릿도
사용하실 수 있습니다
업로드하고 계시네요
종속 항목을 비롯한
모든 것을 설정하는
Compose 활동을 위한 템플릿입니다

Portuguese: 
bastante nas próximas semanas.
Queremos garantir interoperabilidade
com o código atual da forma mais simples,
sem gerar trabalho extra
se as restrições mudarem.
Vamos avisando no decorrer
do desenvolvimento.
Agora, espero que estejam
pensando em outra pergunta.
Vocês viram o que podemos fazer.
O que estamos tentando fazer.
Mas como testar?
Hoje publicamos um site novo,
o d.android.com/jetpackcompose.
Atualizamos o conteúdo no site
do Jetpack Compose,
incluindo como informar bugs.
Confiram.
Também publicamos um tutorial.
Nele, vocês verão os princípios básicos
do Compose com mais detalhes.
Então, confiram.
Vocês podem ficar com a parte teórica...
ou fazer o download
da nova versão do Android Studio
compatível com Jetpack Compose.
Vai estar disponível logo.
Vocês terão uma novo modelo
para uma atividade do Compose
que definirá dependências e tudo mais.

English: 
a good bit of our time
over the coming weeks.
So we want to be sure that
interop with your existing code
is as straightforward as we can
make it, while not leading you
down a path that ends up
creating additional work
if your constraints change.
So we'll keep you updated
as development continues,
but hopefully by now you're
asking another question.
CLARA BAYARRI: So you've
heard what we can do.
You've heard what we're
trying to get to do.
But how do you play with it?
Well, today we've published
a brand new website.
So d.android.com/jetpackcompose.
We've updated the content in
the Jetpack Compose website,
including, for example,
how to file bugs.
So please, go check that out.
As part of that content
we've published a tutorial.
And the tutorial will guide you
through the basic principles
of Compose, kind of similar
to what we've done today,
but much more in detail.
So please go check that out.
You can read through it
and it will make sense.
Or you could go and download
the new Android Studio build
that supports Jetpack Compose.
It should be up soon I think.
[COUGHS]
ROMAIN GUY: Sorry.
[LAUGHTER]
CLARA BAYARRI: You will
also get a new template--
ADAM POWELL: He's
uploading it now.
CLARA BAYARRI: --for
a Compose activity
that will set up all your
dependencies and everything.

Japanese: 
他の設計項目と同じく これらにも
これから数週間で取り組みます
既存のコードとの互換性を
できる限り明確化しつつ
制約に変更があった場合に
追加の作業が発生しないように
配慮していきます
開発の最新情報をお届けしていきますが
ここで新たな疑問が生じたと思います
新機能や
私達の取り組みをご紹介しました
では試せるのか？
本日ウェブサイトを公開しました
d.android.com/jetpackcomposeです
Composeのサイトの内容を更新しました
たとえばバグの記録です
是非ご覧ください
またチュートリアルを公開しました
Composeの基本的な原則をガイドします
本日の公演をさらに詳細にした内容です
読んでいけば理解できます
Jetpack Composeをサポートする
Android Studioビルドも
入手できます
もうすぐアップされるはずです
新しいテンプレートもあります
今アップロード中です
Composeアクティビティ用で
依存関係などすべて設定できます

Chinese: 
会在今后几周内占用我们相当多的时间
我们想要把它和你们现有代码的互操作性
做得尽量简洁明了
同时尽量不在约束条件变更的时候增加你的工作量
我们会随着开发进度的推进随时为大家提供最新信息
希望现在你们已经在提出新的问题了
大家现在了解了我们能做到什么
了解了我们正在努力做到什么
那么 大家要如何去做呢？
今天 我们发布了一个全新的网站
d.android.com/jetpackcompose
我们在 Jetpack Compose 网站上更新了内容 
内容包括如何提交 bug 等等 
请大家去看看
作为内容的一部分 我们也发布了一个教程
这个教程会引导大家了解 Compose 的基本原则
其实和我们今天讲的东西很接近 不过详细得多
请大家前往参阅
读过之后 大家就会明白了
各位还可以下载最新版的 Android Studio
它可以支持 Jetpack Compose
大家应该很快就可以看到它了
-大家还会获得一些模版  -他正在上传
可以用于 Compose
并且会设置好所有依赖 等等

Indonesian: 
waktu kami di minggu-minggu
mendatang.
Kami ingin pastikan
interoperabilitas berfungsi
sesederhana mungkin,
dan Anda tak perlu
melakukan kerja tambahan lain
jika batasan Anda berubah.
Kami akan terus
sampaikan perkembangannya,
tapi kami harap Anda bersabar.
-Anda sudah mendengar upaya kami,
dan apa yang
ingin kami lakukan.
Lalu apa peran Anda?
Hari ini kami mempublikasikan
situs baru.
d.android.com/jetpackcompose.
Kami telah memperbarui konten
di situs Jetpack Compose,
termasuk, misalnya,
cara melaporkan bug.
Jadi, silakan buka situsnya.
Kami juga menyediakan tutorial
yang akan memandu Anda
tentang prinsip dasar Compose
seperti yang kita lakukan hari ini,
tapi lebih detail.
Jadi, silakan membacanya.
Anda bisa baca secara detail
dan semua akan masuk akal.
Atau Anda bisa download
versi baru Android Studio
yang mendukung Jetpack Compose.
Saya yakin akan segera tersedia.
-Maaf.
-Juga akan ada template baru--
-Dia sedang menguploadnya.
-untuk aktivitas Compose
yang akan menyiapkan
dependensi dan segalanya,

Portuguese: 
Vocês não precisam
ler postagens aleatórias.
Diremos como configurar.
Podem testar a prévia que
mostramos na apresentação principal.
É possível ver o que estamos
criando com o Compose.
É possível ver a amostra.
Publicamos JetNews como uma amostra.
Todo o conteúdo está lá,
e é possível ver
como criar um app de notícias.
E há outras coisas que vocês
podem fazer na Conferência.
Há duas sessões de codelab acontecendo.
Também está disponível
on-line se estiver no streaming.
E temos duas palestras recomendadas.
Uma sobre as novidades no Studio.
Tor e J vão falar
das ferramentas para Compose.
Amanhã, o Leland, da equipe
do Compiler e ambiente de execução,
vai falar mais sobre
o funcionamento interno do Compose,
desmistificar o Compiler e mostrar
o que está sendo feito nos bastidores.
Muito obrigada.
-Obrigado.
-Obrigado.

English: 
So you don't need to go
read random blog posts that
will tell you how to set it up.
You can try the new preview that
we showcased at the keynote.
You'll be able to preview what
you're building with Compose.
You'll be able to
see the sample.
So we published
JetNews as our sample.
It showcased everything
that is there now
and how you can use it to
build this news article app.
And then other
things that you can
try while you're here
at the Dev Summit,
there's two codelab
sessions happening.
The codelab is also available
online if you're streaming.
And we have two talks that
you should go check out.
What's New in Android
Studio, where Tor and Ja will
walk through the tools
that we're building
for Compose as part of that.
And tomorrow we have
a talk from Leland,
who's in our compiler
and runtime team.
And will explain a lot more
on how the insides of Compose
work, and kind of
demystify the compiler,
and what we're doing
behind the scenes.
Thank you very much.
ROMAIN GUY: Thanks.
ADAM POWELL: Thanks.
[APPLAUSE]
[MUSIC PLAYING]

Korean: 
이제 설정 방법을
설명하는 블로그 게시물을
찾아 읽지 않으셔도 됩니다
이제 저희가 키노트에서 선보였던
새로운 프리뷰를 사용해보실 수 있습니다
Compose로 구현 중인
작업물을 미리 보실 수 있습니다
샘플을 확인할 수 있습니다
JetNews를 샘플로 게시했습니다
여기에 담긴 모든 내용과
뉴스 기사 앱 구현에 사용할 수 있는 방법이
소개되어 있습니다
여기 Dev Summit에 계시는 동안
다른 강연도 참여해보시기 바랍니다
Codelab 세션 2개가 진행됩니다
Codelab은 온라인
스트리밍으로 보실 수도 있습니다
참여를 추천드리는
강연이 두 가지 있습니다
Android 스튜디오의
새로운 기능에서는 토르 씨와 자말 씨가
Compose용으로 구현 중인 도구를
설명하실 예정이고요
내일은 저희 컴파일러
및 런타임팀 소속이신
릴랜드 씨가
Compose 내부의 작동 방식
컴파일러의 속설 파헤치기
보이지 않는 곳에서
저희가 하고 있는 일을 소개할 예정입니다
감사합니다
감사합니다
감사합니다
[박수]
[음악 재생]

Japanese: 
設定のためにどこかのブログ記事を
読む必要がなくなります
基調講演で見たプレビューも試せます
Composeでの作成物をプレビューできます
サンプルも見れます
JetNewsを公開しました
現在の内容も
これを使用してニュース記事アプリを
作成する方法も載っています
Dev Summit中に
試せることが他にもあります
コードラボセッションが２つあります
オンラインのストリーミングでも見れます
注目の講演が２つあります
トーアとジェイが講演の中で
Compose用に作成しているツールを
紹介します
また明日 コンパイラと
ランタイムチームのリーランドが
Composeの内部の仕組みと
コンパイラと舞台裏を
わかりやすく説明します
ありがとうございました
どうも
ありがとう

Indonesian: 
Jadi tak perlu mencari
sembarang postingan blog
tentang cara menyiapkannya.
Anda bisa coba pratinjau baru,
yang kami tampilkan di keynote.
Anda bisa lihat pratinjau
aplikasi Anda di Compose,
dan sampelnya.
Kami publikasikan
JetNews sebagai sampel,
yang menampilkan semuanya
dan cara menggunakannya
untuk membuat aplikasi artikel berita ini.
Lalu, Anda juga bisa coba,
selagi ada di summit ini,
dua sesi codelab
yang sedang berlangsung.
Codelab juga tersedia secara
online melalui streaming.
Kami juga punya dua bahasan
yang bisa diikuti.
What's New in Android Studio
bersama Tor dan Ja
membahas fitur yang dibuat
untuk Compose.
Besok akan ada Leland,
dari tim runtime dan compiler.
Dia akan jelaskan
lebih banyak tentang Compose,
compiler, dan hal-hal
di balik layar.
Terima kasih banyak.
-Terima kasih.
-Terima kasih.

Spanish: 
No es necesario que lean blogs por ahí
para saber cómo configurarla.
Pueden probar la nueva vista previa
que mostramos en el resumen.
También podrán ver
qué están compilando con Compose.
Podrán ver la muestra.
Publicamos JetNews como ejemplo.
Mostraba todo lo que hay allí ahora
y cómo pueden usarlo para compilar
esta app de artículos de noticias.
Mientras están en la Dev Summit,
pueden asistir a dos sesiones de codelab
que se están llevando a cabo.
El codelab también está disponible
en línea si están transmitiendo.
Tenemos dos charlas a las que deberían ir.
Novedades de Android Studio, donde Tor y Ja
les mostrarán las herramientas
que estamos compilando para Compose.
Y mañana tenemos una charla de Leland,
que es parte de nuestro equipo
de compilador y entorno de ejecución.
Explicará más acerca
de la parte interna del trabajo de Compose
desmitificará el compilador
y contará lo que hacemos tras bambalinas.
Muchas gracias.
- Gracias.
- Gracias.

Chinese: 
这样大家就不用去读那么多的博客文章了
大家也可以试试我们在主题演讲里展示的全新预览版
其中就有用 Compose 构建成品的过程
并提供了样例
我们发布了 Jetnews 作为我们的样例
它展示了目前已经投入使用的所有功能
并说明了使用它来构建这个新闻文章应用的方法
在本次开发者峰会期间 大家还可以参与
两个代码实验室 都有提供在线直播
我们也有两场演讲值得大家一听
在 Android Studio 的最新进展中
Tor 和 Ja 会带大家介绍
我们正在为 Compose 构建的工具 等等
明天 我们还有一场来自 Leland 的演讲
他是我们的编译器及运行时团队的成员
我们会向大家讲解很多
关于 Compose 内部工作原理的知识
并为大家揭开编译器和我们的幕后工作的秘密
多谢大家 谢谢
