
Chinese: 
大家好 我是 David Herman
我是 Justin Nieto
我们都是 Android Studio 团队的开发者
今年早些时候的 I/O 大会上
我们团队中的其他成员向大家分享了一些
在 Android Studio 中进行项目编辑的小技巧
当时讲得非常好
但是 我们开发者都清楚 有的时候
在调试器里花费的时间 大大超出在代码编辑器中花费的时间
所以 Justin 和我走遍了团队内部
询问每个人 看看他们最喜欢的调试功能是什么
今天的演讲时间有限 
所以我们总结出了一些关键的技巧
我们认为大家可以轻松将它们纳入自己的调试流程
为了展示这些功能
我们做了一个简单的游戏
基于最新的 Android 10 版本
规则很简单 每当你抓住10的时候 就得分
撞到太多甜点 (每个甜点代表一个旧版本) 游戏就会结束
这个游戏的核心是一个尝试以60帧每秒的频率运行的循环

Korean: 
[음악 재생중]
안녕하세요, 여러분
저는 데이빗 허먼입니다
저는 저스틴 니에토입니다
저희는 Android
스튜디오 개발자입니다
올해 초 I/O에서
다른 팀원들이
Android 스튜디오에서
프로젝트를 편집하는
팁과 요령에 대해 얘기했는데요
정말 좋았습니다
하지만 개발자로서
우리는 모두
코드 에디터 작업보다
디버거에 더 많은 시간을
보내는 날도 있다는 것에
동의하실 겁니다
그래서 저스틴과 제가 
저희 팀원들에게
즐겨 사용하는
디버깅 기능이 무엇인지 물어봤죠
오늘 얘기할 시간이
많지는 않기 때문에
디버깅 플로우에 통합하는 데 
도움이 될 만한
필수적인 팁만
간추려서
말씀드리겠습니다
이러한 기능을
선보이기 위해
새 Android 10 버전에서
영감을 받은 단순한 게임을 함께
살펴보겠습니다
규칙은 간단해요
10점을 잡으면 점수를 따게 됩니다
오래된 버전을 의미하는
디저트를 너무 많이 먹으면
게임 오버가 됩니다
이 게임의 핵심은
초당 60프레임으로
실행하려고 하는 루프이며
여기에서 게임의

Spanish: 
[MÚSICA SONANDO]
Hola a todos.
Soy David Herman.
Yo soy Justin Nieto.
Somos desarrolladores en Android Studio.
A principio de este en
I/O, otros miembros del equipo
dieron una charla de
Consejos y Trucos
sobre cómo editar 
tu proyecto en Android Studio.
Es excelente.
Sin embargo, como
desarrolladores,
sabemos que hay días que
pasas
mucho más tiempo
en tu depurador
que en el editor de código.
Con ese fin, Justin y yo,
hablamos con nuestro equipo.
Preguntamos cuál era su función 
de depuración favorita.
No tenemos demasiado tiempo,
así que lo redujimos a lo
que pensamos que son los
consejos esenciales
más fácil de incorporar
en su proceso de debugging.
Para mostrar estas funciones
creamos un pequeño juego
inspirado en la versión de
Android 10.
Las reglas son simples,
si agarras un 10 obtienes puntos.
Si agarras demasiados postres,
que representan versiones previas,
se acabó el juego.
El núcleo de este juego
es un bucle que
intenta ejecutarse a 60
cuadros por segundo,

English: 
[MUSIC PLAYING]
DAVID HERMAN: Hey everyone.
I'm David Herman.
JUSTIN NIETO: And
I'm Justin Nieto.
DAVID HERMAN: And we are
developers on Android Studio.
Now, earlier this year at
I/O, other members of our team
gave a Tips and Tricks
talk about editing
your project in Android Studio.
It is excellent.
However, as
developers, we all know
that there are
some days you just
spend way more time
in your debugger
than you do in your code editor.
So to that end, Justin and
I-- we went around our team.
We asked everybody for their
favorite debugging features.
We don't have a lot
of time up here,
so we narrow them down to what
were the essential tips that we
think will be easy
to incorporate
into your debugging flow.
Now, in order to
showcase these features,
we put together a simple game
inspired by the new Android 10
version.
Rules simply are you grab
10's, you get points.
You run into too many desserts,
which represent old versions.
It's game over.
The core of this
game is a loop that
tries to run at 60
frames a second, where

Indonesian: 
Halo, semuanya.
Saya David Herman.
Dan saya Justin Nieto.
Kami developer di Android Studio.
Pada awal tahun ini di I/O,
anggota lain dari tim kami
memberikan Tips dan Trik
tentang mengedit
project Anda di Android Studio.
Itu sangat bagus.
Tapi, sebagai developer,
kadang kita banyak menghabiskan
waktu di debugger daripada di editor kode.
Berkaitan dengan hal itu,
kami berkeliling ke tim kami.
Dan menanyakan
apa fitur proses debug favorit mereka.
Karena waktunya sedikit,
kami mempersempitnya menjadi tips penting
yang menurut kami
mudah untuk diterapkan
ke dalam alur proses debug Anda.
Sekarang, agar dapat
menunjukkan fitur ini,
kami membuat game sederhana
yang terinspirasi
dari versi Android 10 baru.
Aturannya jika mengenai
angka 10, Anda mendapatkan poin.
Tapi jika terkena banyak camilan,
sebagai representasi versi lama,
permainan akan berakhir.
Inti dari game ini adalah
loop yang berjalan 60 frame per detik,

Portuguese: 
Olá a todos!
Eu sou David Herman.
E eu sou
Justin Nieto.
Somos programadores
do Android Studio.
No Google I/O do início do ano,
outros membros da nossa equipe
deram Dicas e Truques
sobre a edição
de projetos no Android Studio.
Isso é ótimo.
Mas como programadores,
sabemos
que há dias em
que passamos
muito mais tempo
no depurador
do que no editor de códigos.
E, para isso, Justin e eu
falamos com nossa equipe.
Perguntamos sobre seus recursos
de depuração favoritos.
Nós não temos muito tempo aqui.
Então, resumimos as dicas
que consideramos essenciais e
que são fáceis
de serem incorporadas
no trabalho de depuração.
Para mostrar agora esses recursos
criamos um jogo simples
inspirado na nova versão
do Android 10.
As regras são simples:
colete 10 e ganhe pontos.
Se encontrar muitos doces,
que representam versões antigas
você perde.
O principal nesse jogo é
um loop
que tenta rodar
a 60 frames por segundo

Japanese: 
皆さん こんにちは
デービッド･ハーマンと申します
ジャスティン･ニエトです
Android Studioの開発者です
今年のI/Oでは
チームの他のメンバーが
Android Studioでプロジェクトを
編集するための
ヒントやコツをお伝えしました
素晴らしいです
しかし皆さんが開発者として
コードエディタよりもデバッガで
多くの時間を費やしていることを
知っています
そこでジャスティンと私は
チームを回って
皆にお気に入りの
デバッグ機能について聞きました
ここではあまり時間がないので
私たちが最も重要だと考える
デバッグフローに組み込みやすい
ヒントに絞ってお話しします
それらの機能をお見せするために
新しいAndroid 10バージョン
に基づいて
簡単なゲームを作りました
ルールはシンプルです
“10”をキャッチするとポイントになり
旧バージョンを表す
デザートを取りすぎると
ゲームオーバーです
このゲームのコアは１秒間に
60フレームで実行するループで

Portuguese: 
em que atualiza todos
os objetos do jogo
e os disponibiliza.
Imagino que seu app
não seja como esse.
Mas não se preocupe,
todos os recursos
que vamos compartilhar
podem ser usados em qualquer projeto.
A partir de agora
vamos fazer demonstrações.
Temos muito o que mostrar
então eu vou passar
para o Justin agora.
Isso mesmo,
como disse o David
daremos diversas dicas
sobre depuração.
Mas se você
é um pouco como eu,
assistirá a essa apresentação
irá para casa
e ainda usará as funções printf em tudo
para ver o que acontece.
Tudo bem.
Também temos dicas para você
e vamos começar por aí.
Se abrirmos o Logcat,
onde aparecem todos
os registros do Android no IDE,
você verá que quando o app inicia
há duas coisas acontecendo.
A QPS, taxa de quadros por segundo
está sendo registrada
a cada segundo.
E quando o Android morre
no final do jogo
também registramos
a pontuação atingida na sessão.

English: 
it updates all of the
objects in the game,
and then it renders them.
I'm going to assume
that your own app is not
quite the same as this one.
But don't worry,
all of the features
that we're going to share here
will apply for any project.
Now, this is all going to be a
demo from this point forward.
And we have a lot
to get into, so I'm
going to get out of the way
and kick it over to Justin.
JUSTIN NIETO: Right,
so as David mentioned,
we're going to talk about
a lot of debugging tips.
But if you're anything
like me, you're
going to sit through
this whole presentation
and then go home and still use
printf statements everywhere
to see what's going on.
That's OK.
So we have tips for you too.
We're actually
going to start here.
So if we open up Logcat, which
is where all of our Android
logs surface in the IDE, you'll
see that when we start the app,
we have two things
going on here.
We're logging the FPS--
the frames per second rate--
every second.
And then when Android dies
at the end of the game,
we also log the score that
you got through the session.

Indonesian: 
dan akan memperbarui
semua objek dalam game,
lalu merendernya.
Saya berasumsi bahwa
aplikasi Anda berbeda dengan game ini.
Tidak masalah,
semua fitur berikut
bisa diterapkan untuk project apa saja.
Mulai dari sini, kami akan
memberikan demo kepada Anda.
Karena banyak yang harus dibahas,
saya akan langsung meneruskan ke Justin.
Baik, seperti yang disampaikan David,
kita akan membahas
banyak tips proses debug.
Tapi jika Anda seperti saya,
Anda akan duduk
selama presentasi ini,
lalu pulang,
dan tetap menggunakan statement printf
di mana saja untuk melihat keadaan.
Tidak masalah.
Jadi, kami punya tips untuk Anda juga.
Kami akan memulai di sini.
Jadi, jika kita membuka Logcat,
tempat semua log Android muncul di IDE,
bisa dilihat bahwa saat memulai aplikasi,
ada dua kejadian di sini.
Kita mencatat FPS--
rasio frame per detik--pada setiap detik.
Lalu, saat Android mati di akhir game,
kita juga mencatat skor
yang didapatkan di sesi tersebut.

Spanish: 
donde actualiza todos los
objetos del juego
y luego los renderiza.
Voy a asumir que su propia
aplicación no es tan parecida
a esta.
No se preocupen,
las funciones
que compartiremos aquí,
aplican a cualquier proyecto.
De aquí en adelante será
una demostración
y tenemos mucho
que ver, así que
me voy a poner a un costado
y dejarle el camino a Justin.
Como dijo David,
vamos a hablar de
consejos de depuración.
Pero si se parecen a mí,
se escucharán
toda la presentación
e irán a casa y seguirán usando
la instrucción printf
para ver qué esta pasando.
Eso esta bien.
También tenemos consejos para ustedes.
Vamos a comenzar.
Si abrimos Logcat, que es donde
todos nuestros registros de Android
aparecen en el IDE, verán que cuando
iniciamos la aplicación,
dos cosas suceden aquí.
Registramos los FPS,
la velocidad de cuadros por segundo,
a cada segundo.
Y cuando Android muere
al final del juego,
también registramos el puntaje
obtenido en la sesión.

Chinese: 
它会更新游戏内的所有对象 然后再渲染它们
我觉得你们自己的应用可能跟这个不太一样
但是别担心 我们要在这里分享的功能适用于任何项目
从现在开始 后面都是演示了
要讲的东西很多 我现在把位置让给 Justin
好 正如 David 所说
我们要将很多调试方面的小技巧
不过 如果是我的话 就会在看完演示之后
仍然到处使用 printf 看看会怎样
这样做没问题 我们也可以为你提供相应的小技巧
我们就从这里入手开始讲
当我们打开 Logcat 之后
Logcat 就是 IDE 中各种日志集中出现的地方
我们可以看到 当我们启动应用时
会发生两件事
我们每一秒钟都在记录 FPS 也就是每秒帧数
在游戏结束 Android 退出时
我们也会记下你在这次会话中取得的分数

Japanese: 
これがゲームのすべての
オブジェクトを更新し
それらをレンダリングします
皆さんが開発しているアプリとは
随分懸け離れているかと思いますが
心配いりません
ご紹介する機能はすべて
あらゆるプロジェクトに適用できます
すべて これから行うデモでお見せします
興味深い点がたくさんありますよ
それではジャスティンと交代します
では デービッドが述べていたように
デバッグに関するヒントを
たくさんお伝えします
私のような人なら
このプレゼンをすべて聞いて
家に帰ってからも
printfを使って
何が起きるか確かめるでしょう
それではたくさんのヒントを
これからお伝えします
Logcatを立ち上げます
IDE内のAndroidログです
アプリを起動すると
表示されます
２つのことが起こっています
毎秒FPS（フレームレート）を
記録しています
ゲームが終了してAndroidが終了すると
そのセッションで取得したスコアが
ログに記録されます

Korean: 
객체를 모두 업데이트한 후
렌더링합니다
여러분의 앱이 지금 이 경우와
그렇게 똑같지는
않을 수도 있지만
그래도 걱정하지 마세요
여기에서 공유하는
모든 기능은
어떤 프로젝트에든 적용 가능합니다
지금부터는
모두 데모 과정입니다
살펴볼 요소가 많으니까
더는 방해하지 않고
저스틴에게 차례를 넘기겠습니다
네, 데이빗이 말씀드렸다시피
디버깅 팁에 대해
많은 이야기를 나눠볼 텐데요
저와 같은 상황이시면
꼼짝않고 이 프레젠테이션을
모두 들으신 다음
집에 돌아가서는
계속해서 printf 문을 사용해서
어떻게 되는지
결과를 두고 보겠죠
괜찮아요
자, 여러분을 위한 팁이 있습니다
여기서부터
시작할 건데요
모든 Android 로그가 
IDE에서 표시되는
Logcat을 열고
앱을 시작하면
이렇게 두 가지가 표시됩니다
FPS,
즉 초당 프레임 속도를
매 초마다 기록합니다
Android가 죽고
게임이 끝나면
세션 전반에서 얻은
점수도 기록합니다

Japanese: 
ご覧のように
ここにたくさんのログが出力されます
日付やスレッドようなものですが
気にしないでください
ご存知ないかもしれませんが
設定バーで
私たちが必要とするタグや
メッセージだけ表示されるように
いくつかの情報を削除できます
消えましたね？
はい
これだけでも
スパムのようなログが
たくさん表示されていることに
お気付きでしょう
これらはハイスコアのメッセージを
見えづらくしています
ここでできることは
ここで検索して
フィルタリングすることです
これは良い方法です
もしいつでも活用できる
役立つ検索であれば
保存して
後でまた使用できます
それには
ここから
カスタムフィルタを追加します
[Edit Filter Configurations]を選択すると
私はこれを事前に行っていましたが
この場合
“High Score”を探していますが
探している文字列を入力できます
同じ様にフィルタリング
できましたが
別のフィルタリングに
切り替えることもできます

English: 
So you might notice right away
that there's kind of some bloat
here-- things like the
date and the threads--
that we don't really care about.
One thing you might
not know is that you
can go to this
Settings bar over here
and remove some of
this information
so that we can cut it down to
just the tag and the message
that we care about.
[APPLAUSE]
Right?
Yeah.
So even with this, you
might notice that we
have all of these spammy logs.
And they're kind of getting
in the way of us seeing
these high score messages.
So what we can do there
is actually search
here to filter things down.
And this is nice, but if
this is a super useful search
that you do all the time-- or
you have multiple searches--
you might want to
actually save this
so you can come
back to it later.
So what we can do
to make that happen
is to go here and
add a custom filter.
So if we go over here in
Edit Filter Configurations--
I did this before.
So in this case, I'm
looking at high scores.
I can type in the substring
that I'm looking for.
And now I have the
same filtering effect.
but I can jump back and
forth between different ones.
So for now.

Spanish: 
Pueden notar rápidamente
que hay una especie de relleno,
cosas como fechas e hilos,
que realmente no nos importan.
Algo que quizás no sepan es que
pueden ir a la barra de Configuraciones
y eliminar parte de
la información
para que podamos acotarlo
a la etiqueta y el mensaje
que nos importa.
[APLAUSOS]
¿Bien?
Si.
Incluso con esto, pueden
notar que todavía
hay registros no deseados.
Y que no nos permiten ver
estos mensajes de puntajes altos.
Lo que realmente podemos
hacer allí es buscar
aquí para filtrar las cosas.
Y esto es muy bueno, pero
si es una búsqueda que
haces todo el tiempo, o
tienes varias búsquedas,
quizás quieras
guardar esto
para usarlas
mas tarde.
Para hacer que
esto suceda, vamos
aquí y agregamos
un filtro personalizado.
Si vamos aquí en
Editar Configuraciones de Filtros
Hice esto antes.
En este caso, estoy
viendo puntajes altos.
Puedo escribir la substring
que estoy buscando.
Ahora, tengo el mismo
efecto de filtrado.
Y puedo cambiar entre
los diferentes filtros.
Por ahora,

Indonesian: 
Mungkin Anda menyadari
ada penggelembungan di sini--
seperti tanggal dan thread--
yang tidak terlalu penting.
Anda mungkin belum tahu
bahwa Anda bisa membuka menu Settings
dan menghapus beberapa informasi
agar bisa melihat
tag dan pesan yang diinginkan saja.
Benar, kan? Ya.
Bahkan dengan ini, Anda mungkin sadar
bahwa masih banyak log berisi spam
yang sedikit menghalangi kita
untuk melihat pesan skor tertinggi.
Jadi, yang bisa kita lakukan
yaitu mencari
untuk melakukan pemfilteran.
Tapi jika pencarian berguna
dan dilakukan setiap saat--
atau ada banyak pencarian--
sebaiknya Anda simpan
agar bisa melihatnya lagi nanti.
Untuk melakukannya,
klik di sini dan tambahkan filter kustom.
Jika mengklik di sini,
lalu memilih Edit Filter Configurations--
saya pernah melakukan ini sebelumnya.
Dalam hal ini,
saya ingin melihat skor tertinggi.
Lalu, saya bisa
mengetik substring yang dicari.
Sekarang, efek pemfilteran sudah sama
tapi saya juga bisa berpindah
antara pemfilteran yang berbeda.

Chinese: 
大家可能会马上注意到 这里的文字有些太多了
诸如日期 线程之类 我们不太关心的东西
不过大家有所不知的是 
你可以前往这里的 Settings 栏 移除一些信息
让我们可以把信息裁剪到只剩下 tag 和我们在乎的消息
是不是很棒？嗯
即使有了这些手段 大家可能还是会发现一些无用日志
它们妨碍了我们观察最高得分相关的信息
所以 我们能做的就是 在这里通过搜索来过滤结果
这个做法不错 不过如果这个搜索特别有用而且常用
或者是如果你有多个搜索 那么你就需要保存它
这样才方便以后回过头来查看
所以我们能做的就是 在这里添加一个定制过滤器
我们在这里编辑过滤器配置
这个我之前做过
现在我们要找的是 高分
我可以输入我要找的子字符串
现在得到了相同的过滤效果
不过我可以在不同的效果之间切换

Korean: 
바로 눈치채셨을 텐데
여기에는 몇 가지 블로트가 있습니다
날짜와 스레드 같은 거죠
별로 신경 쓰지 않아도 됩니다
아마 모르실 텐데
여기 이 설정 막대로 가서
이 정보 일부를 지워
중요하게 생각하는
태그와 메시지만 보이게
추릴 수 있습니다
[박수]
그렇죠?
좋아요
이것만으로도
이런 스팸 로그가 있다는 것을
알아차리실 수 있습니다
이런 것들 때문에
높은 점수 메시지를 찾는 데
방해가 되죠
이때 가능한 작업은
여기에 검색을 해서
필터링을 하는 것입니다
정말 좋은 기능이에요
항상 하는 유용한 검색이나
여러 번 검색을 해야 할 경우에는
이걸 저장해서
나중에 다시 사용할 수 있게
하는 것이 좋겠죠
그렇게 하려면
여기로 가셔서
사용자 맞춤 필터를 추가하세요
그리고 여기 
필터 구성 편집으로 가세요
저는 이미 해 놨는데요
이 경우에는
높은 점수가 보이니까
찾으려는 하위 문자열을
입력하면 됩니다
이제 동일한
필터링 효과가 생겼습니다
그렇지만 서로 다른 항목으로
이동할 수 있죠
지금은

Portuguese: 
Então, dá para ver
que há muita informação aqui.
Coisas como
a data e as linhas
que não são importantes.
Talvez você não saiba
que pode ir
na Barra de Configurações
aqui em cima
e remover
uma parte da informação
para exibir apenas
as tags e as mensagens
que são importantes.
Certo?
Sim.
Portanto, mesmo com isso
você pode perceber
vários registros com spam.
E eles
não deixam a gente ver
as mensagens de maior pontuação.
O que podemos fazer
é pesquisar aqui
para filtrar as informações.
Isso é legal,
mas se essa
é uma pesquisa super útil
que é feita sempre,
ou diversas pesquisas
você vai querer salvá-la
para poder voltar depois.
Para isso acontecer,
podemos
ir aqui
e adicionar um filtro personalizado.
Se formos em
Editar configurações de filtro...
Já fiz isso antes.
Nesse caso,
estou vendo as pontuações máximas.
Posso digitar na substring
que estou procurando.
E agora tenho
o mesmo efeito de filtro
mas posso passar
de um para o outro.

Chinese: 
现在我要回到完整的日志集
这很不错 
不过我们可能需要查看游戏内的每段日志
只是不想要这些看起来碍眼的 FPS 记录
这里 我们可以选中那些
和所有多余东西相关的子字符串
右键点击它 选择 折叠这样的内容
这样就为我们创建了一个过滤器
可以折叠所有信息 只留下我们想要的东西
这样做之后 就会看到
有一些分数之类的来自模拟器的信息
如果我们需要稍后回顾这些信息的话
也随时可以展开或折叠它们
解决了日志问题之后
下面我们来看一些代码
具体来说 我们要从这个循环入手
游戏循环的每帧中 这个循环都会启用
我们会在它们身上执行所有的计算
因为它在每一帧都会出现
所以我应该可以在这里设置一个断点
在我开始调试的时候 这里应该会立即生效

Japanese: 
とりあえずログ全体を
表示する設定に戻します
良い機能ですが
ゲームのすべてのログを見たいと
思われるかもしれません
この邪魔なFPSログは
表示させたくありません
そこで表示させたくない
スパムログの中から
文字列を強調表示し
右クリックして
[Fold Lines Like This]を選択します
そうすると
これらのメッセージを折り畳んで
表示させたいメッセージのみを
残してくれるフィルタが作成されます
これを行うと
スコアとエミュレータからの
情報のみが
表示されます
後でこれらの情報を確認する
必要が生じれば
いつでも展開したり
折り畳んだりできます
それではこれらのログを後にして
次は いくつかのコードに注目してみましょう
とりわけ
ゲームループのすべてのフレームで発生する
このループから始めたいと思います
すべてのアイテムを調べ
議論していきましょう
これはすべてのフレームで
発生するので
ここにブレークポイントを設定します
デバッグを開始するとすぐ
ここにヒットします

Indonesian: 
Sekarang, saya akan kembali
ke seluruh kumpulan log.
Itu bagus,
tapi mungkin kita
ingin melihat setiap log dalam game.
Kita hanya tidak ingin
melihat log FPS yang berisi spam.
Jadi, yang bisa kita lakukan
yaitu menandai substring yang relevan
di antara spam yang tidak diinginkan,
klik kanan,
lalu pilih Fold Lines Like This.
Pemfilteran akan dilakukan
dengan menciutkan semua pesan
dan menyisakan pesan yang diinginkan.
Dengan melakukan ini,
Anda hanya melihat skor
dan beberapa informasi lain dari emulator.
Jika perlu melihat
informasi ini lagi nanti,
kita bisa meluaskan
atau menciutkannya lagi.
Setelah membahas semua tentang log,
mari kita lanjutkan ke kode.
Secara khusus,
kita akan mulai dari loop yang ada
di setiap frame pada loop game,
tempat kita mengatur
semua item beserta alasannya.
Karena ada di setiap frame,
breakpoint bisa ditetapkan di sini.
Dan saat proses debug dimulai,
breakpoint akan langsung kena.

Spanish: 
voy a volver al conjunto
completo de registros.
Es grandioso, pero
quizás queramos
ver cada registro
en el juego.
Pero no queremos estos
registros no deseados de FPS.
Lo que podemos hacer aquí
es resaltar la substring
que es relevante entre
las diferentes cosas no deseadas
que no nos importan,
clic derecho,
e ir a doblar lineas así.
Y crear un filtro
que colapse todos
estos mensajes juntos
y deje solo
las cosas que nos importan.
Si hago esto, notarán
que ahora
vemos los puntajes
y otro tipo de información
del emulador.
Y si necesitamos ver
esta información luego
siempre podemos
expandirla o colapsarla.
Ahora que tenemos todos los bits
de registros donde no molestan,
avancemos y veamos
algo de código.
En particular,
empecemos por
este bucle, que ocurre en cada
cuadro del bucle del juego,
donde revisamos todos los
objetos y pensamos acerca de ellos.
Debido a que ocurre en
cada cuadro,
debería poder agregar un
punto de revisión aquí.

Korean: 
전체 로그 세트로
다시 돌아갈게요
좋은 기능이죠
그런데
게임 내 모든 로그를
보려고 할 수도 있습니다
단지 이런 스팸 FPS 로그만
원치 않는 것이죠
그러면 별로 중요하지 않은
여러 스팸 요소 사이에서
관련이 있는 하위 문자열을
강조표시하고
마우스 오른쪽 버튼으로 
클릭합니다
이렇게 폴드 라인으로 이동합니다
이러한 모든 메시지를 숨길
필터를 생성하고
중요한 정보는 
그대로 둡니다
이렇게 하면
이제 점수와
에뮬레이터의
다른 정보 몇 가지가
표시됩니다
나중에
이 정보를 보려면
언제든 펼치거나 
숨길 수 있습니다
이제 완료된
모든 로깅 비트가 표시됩니다
계속해서
코드 몇 가지를 살펴보죠
특히
게임 루프의
모든 프레임에서 발생하는
이 루프부터 시작하겠습니다
여기서 모든 항목과
원인을 확인할 수 있습니다
모든 프레임에서
발생하기 때문에
여기에 중단점을
설정할 수 있어야 합니다
디버깅을 시작하면
거의 바로 시작되어야 하죠

Portuguese: 
E agora vou voltar
para o conjunto de registros.
Ótimo, mas e se
quisermos ver
cada registro do jogo.
Não queremos
esses registros de QPS com spam.
Nesse caso, podemos
destacar a substring relevante
entre todos esses diferentes spams
que não são importantes
Clique com o botão direito
e vá para linhas de dobra assim.
Isso cria um filtro
que juntará todas 
essas mensagens e deixará
apenas o que consideramos importante.
Se fizer isso,
verá agora
apenas o placar
e algumas informações do emulador.
Se precisarmos depois
dessas informações,
é possível expandir
ou recolher os dados.
E agora que temos
as questões de registros fora do caminho
vamos para
um pouco de programação.
Em particular,
vamos começar
com esse loop que ocorre
em cada frame do loop do jogo
vamos passar por
todos os itens e as razões.
Já que ocorre em todos os frames
consigo definir
um ponto de parada.
E quando começo a depurar,
isso deve ocorrer imediatamente.

English: 
I'll go back to
the whole log set.
So that's great,
but maybe we really
want to look at every
log in the game.
We just don't want
these spammy FPS logs.
So what we can do here is
highlight the substring
that's relevant between all
these different spammy things
that we don't care
about, right-click on it,
and go to fold lines like this.
And creates a filter
for us that will
collapse all of these
messages together and leave
just the things we care about.
So if I do this, you'll
see that now we're
just looking at the scores
and some other information
from the emulator.
And if we need to look at
this information later,
we can always expand
it or collapse it.
So now that we've got all the
logging bits out of the way,
let's go ahead and
jump into some code.
In particular,
we're going to start
at this loop that happens
every frame of the game loop,
where we go through all the
items and reason over them.
So since it happens
every frame, I
should be able to set
a breakpoint here.
And when I start debugging, this
should hit pretty immediately.

Portuguese: 
Então vamos lá.
Eu não fiz isso.
É brincadeira.
Eu fiz de propósito.
Apertei o botão Executar
ao iniciar o app
em vez de Depurar.
E como fiz de propósito
para mostrar o próximo recurso
quero mostrar
que isso ocorre comigo
algumas vezes na vida real.
Pode ser muito frustante
parar o app
começá-lo no modo Depurar e
voltar tudo para o estado
que está tentando depurar.
Em vez disso,
clique nesse ícone
e conecte o depurador
ao processo já em execução.
Ao fazer isso,
chegaremos ao ponto de parada
imediatamente.
Agora temos um ponto de parada.
Digamos que o bug rastreado
é relacionado
a quando o Android
de fato acerta
um desses doces.
Não há um ponto de parada imediato
porque ele é
acertado em cada frame.
E nunca chegamos até o doce
que estamos tentando acertar
para reproduzir.
Em vez disso,
podemos
ir para a parte do código

English: 
So let's go ahead and do that.
So I didn't do that.
Just kidding.
So I did this on purpose.
I hit the Run button when
I started the app, instead
of hitting the Debug button.
And while I did it on purpose to
demonstrate the next feature I
want to show, this
actually happens
to me quite a bit in real life.
And it can be super
frustrating to stop the app,
start it in Debug
mode again and then
work your way all the
way back to the state
that you're trying
to debug from.
So what you can do instead
is click this icon over here
and attach the debugger to
the already-running process.
And when I do that, you'll
see that we hit the breakpoint
pretty immediately.
So that being said, we
have our breakpoint.
But say the bug that
we're tracing down
is related to when
Android actually
hits one of these desserts.
It's not going to have
a breakpoint right
here because it gets
hit every frame.
And we never get
up to the dessert
that we're trying
to hit to repro.
So instead, what
we might want to do
is go down to the
part of the code

Spanish: 
Y cuando comience la depuración,
esto debería parar de inmediato.
Así que, vamos a hacer eso.
Así que, no hice eso.
Solo bromeo.
Lo hice a propósito.
Hice clic en el botón Run cuando
inicié la aplicación, en vez de
hacer clic en el botón Debug.
Lo hice a propósito para
demostrar la siguiente función.
Esto en realidad me pasa seguido
en la vida real.
Y puede ser muy
frustrante para la aplicación,
empezar en modo
de depuración de nuevo
y luego ir hacia atrás
hasta el punto
que quieres hacer la depuración.
En vez de eso, pueden hacer
clic en este ícono de aquí
y adjuntar el depurador al
proceso que se está ejecutando.
Y cuando haces eso,
pueden ver que llegamos al
punto de revisión bastante rápido.
Habiendo dicho eso,
tenemos nuestro punto de revisión.
Digamos que el error 
que estamos rastreando
está relacionado con
que Android realmente
golpee alguno de estos postres.
No tendrá un
punto de revisión aquí
porque obtiene golpes
en cada cuadro.
Y nunca llegaremos al postre
que intentamos
golpear para reproducir el error.
En vez de eso, lo
que podemos intentar es
ir a la parte de abajo
del código donde

Korean: 
그럼 계속해서 해볼게요
제가 그런 게 아니에요
사실은 농담이고
일부러 제가 한 게 맞습니다
앱을 시작할 때
'디버그' 버튼 대신
'실행' 버튼을 눌렀습니다
보여드리고 싶은 다음 기능을 위해
일부러 이 상황을 만들었지만
이런 일은 실제로
저한테 꽤 자주 일어납니다
이때 앱을 멈추는 게
정말 힘들 수 있는데요
디버그 모드에서 다시
시작한 후에
디버깅 작업을
수행하려고 했던
지점부터 다시 원래 상태로
모든 작업을 수행해야 합니다
그 대신 어떻게 하냐면
여기에 있는 아이콘을 클릭하고
디버거를 이미 실행 중인
프로세스에 연결합니다
그렇게 하면
중단점으로
바로 이동하게 됩니다
말하자면,
중단점이 있는 것이죠
그런데 추적하려는 버그가
Android가 실제 
디저트 하나를 건드리는 시점과
관련이 있다고 해볼게요
그때는 중단점이 바로
여기에 있지 않을 겁니다
모든 프레임마다
생기기 때문이죠
리프로에 닿으려는
디저트에
절대 도달할 수 없습니다
대신에
디저트를 건드렸음을
실제로 확인한 위치의
코드 부분으로

Indonesian: 
Mari kita melakukannya.
Saya tidak melakukannya.
Hanya bercanda.
Jadi, saya sengaja melakukannya.
Saya mengklik
tombol Run saat memulai aplikasi,
bukan tombol Debug.
Selain sengaja untuk
mendemonstrasikan fitur berikutnya,
saya sering
mengalaminya di kehidupan nyata.
Akan merepotkan
jika harus menghentikan aplikasi,
memulainya di mode Debug kembali,
lalu mengulanginya lagi
dari titik asal yang akan di-debug.
Jadi, Anda bisa mengklik ikon ini
dan sematkan debugger
ke proses yang sudah berjalan.
Dan saat melakukannya,
kita langsung mengenai breakpoint.
Dengan begitu,
kita sudah punya breakpoint.
Tapi misalkan bug yang kita lacak
berkaitan saat Android
mengenai salah satu dari camilan.
Breakpoint tidak akan ada di sini
karena terkena di setiap frame.
Kita tidak bisa
sampai ke camilan
yang dicari untuk diproduksi ulang.

Chinese: 
所以我们就这样做一下
这可不是我做的
开个玩笑 其实是我故意做的
我在启用应用时点击 Run 按钮 
而不是点击 Debug 按钮
虽然这里我是刻意这么做的 目的是展示下一个功能
但是 其实我在现实中经常会搞出这种情况来
如果需要我来停止应用 重启进入调试模式
一路找到你想要调试的那个状态 那是相当烦心的
所以 你可以直接点击这里的这个标志
并把调试器挂载到已经在运行的进程中
这么做的时候 你会发现 我们几乎立即就抵达了断点
在抵达断点之后
假如我们追踪的这个 bug 
是由于 Android 小绿人撞上这些甜点而导致的
这里不会出现断点
因为它在每帧中都会被击中
而我们从未到达过甜点上面
所以 我们要做的是 在代码中找到

Japanese: 
やってみましょう
あっ間違えた
冗談です
わざとですよ
デバッグボタンを押す代わりに
実行ボタンをクリックして
アプリを開始しました
次にお見せしたい機能のデモを行うために
わざと行いましたが
実際にもよくやってしまうことです
アプリを止められなくて
イライラします
もう一度デバッグモードで開始します
デバッグする状態に戻して
進めます
今度は
このアイコンをクリックして
既に実行しているプロセスに
デバッガをつなげます
そうするとブレークポイントに
すぐにヒットします
先ほども言いましたが
ブレークポイントがあります
トレースしているバグは
これらのデザートにヒットする
タイミングに関係しています
そこには
ブレークポイントを設定できません
すべてのフレームが
ヒットしてしまうからです
ヒットを試みるデザートに
到達できません
その代わりに
デザートにヒットしたと判断した
コードまで

Korean: 
이동할 수 있습니다
한 가지 좋은 점은
이제 이 중단점이
필요 없기 때문에 중요한
라인으로 가기만 하면 되는 거죠
이전 라인에서 제거한 후에
실행할 수 있습니다
그리고 충돌할 때
지금부턴 충돌을 볼 건데요
괜찮습니다
추적 중인 버그가
Android가 결국 죽는 시점에
건드린 마지막 디저트하고만
관련이 있을 수 있습니다
그렇기 때문에
동일한 문제가 생겼습니다
디저트를 건드릴 때마다
중단해야 했어요
지루한 작업이죠
그러면
조건부 중단점 설정을
호출하면 됩니다
디버거에서 이 중단점을
마우스 오른쪽 버튼으로 클릭하고
조건을 추가할 수 있습니다
여기 Kotlin에 부울 식도
넣을 수 있습니다
true로 계산될 경우
코드가 이를 건드리면
중단점을
잡게 됩니다
player.health를 
입력해 보겠습니다
중요한 부분의 마지막 지점에서
줄일 것이기 때문에
1과 동일합니다
쭉 살펴보면
두 번 건드렸고
잡지는 않았죠
이제 마지막 것을
건드렸고 중단점을 잡았습니다
신경 쓰는 부분만
확인되는 것입니다

Portuguese: 
em que de fato é determinado
que acertamos um doce.
É ótimo que não preciso mais
desse ponto de parada
posso arrastá-lo
para a linha que eu quiser.
E ele some da linha antiga
e eu posso seguir em frente.
E quando eu bater,
agora vou chegar a colisões.
Ótimo, mas talvez
o bug que quero de fato
seja apenas relacionado
ao último doce que eu atingir
quando o Android morre no final.
Para isso,
há o mesmo problema.
Eu paro sempre
que bato em um doce.
Fica chato.
O que podemos fazer é
configurar
um ponto de parada condicional.
Posso clicar nele com o 
botão direito, no depurador
e colocar a condição.
E posso pôr uma expressão booleana
em Kotlin.
E se for considerado verdadeiro
quando o código acertar
teremos atingido o ponto de parada.
Nesse caso,
digitarei que o player.health
é igual a 1 porque
estamos prestes a diminuí-lo
pela última vez
no caso que estamos lidando.
E quando passamos por isso
batemos duas vezes 
e não pegamos.
Agora bato no último
e chego ao ponto de parada.
Eu só pego o caso
que é importante para mim.

Spanish: 
determinamos que hemos
golpeado un postre.
Algo bueno, porque este
punto de revisión ya no es
necesario, es que puedo
arrastrarlo a la línea que necesite.
Y es descartado de la línea
vieja y luego lo puedo ejecutar.
Y cuando golpea, ahora
obtengo golpes.
Es genial, pero quizás el
error que estoy
persiguiendo esta relacionado
con el último postre que golpee,
cuando Android muere al final.
Tenemos el mismo problema.
Tengo que parar cada vez
que golpeo un postre.
Es tedioso.
Lo que podemos hacer es configurar
un punto de revisión condicional.
Hago clic derecho en este
punto de revisión en el depurador,
y agrego mi condición.
Y puedo poner cualquier expresión
Boolean en Kotlin aquí.
Si se resuelve como verdadero,
cuando el código le pegue,
luego lo agarramos 
en el punto de revisión.
En este caso, voy a escribir player.health
es igual a 1 porque estamos
a punto de disminuirlo por
última vez en la forma
que nos importa.
Y cuando lo hago,
golpeamos dos veces y
no lo agarramos.
Ahora golpeo el último
y agarro el punto de revisión.
Y obtengo el caso
que me importa.

English: 
where we've actually determined
that we've hit a dessert.
One thing that's nice, because
I don't need this breakpoint
anymore, I can just drag it
to the line that I care about.
And it gets rid of it from the
old line, and then I can run.
And when I collide, now
I get it on collisions.
That's great, but maybe
the bug that I'm actually
chasing down is only related to
the last dessert that I hit--
when Android dies at the end.
So for that, we had
the same problem.
I had to stop every
time I hit a dessert.
It gets tedious.
So what we can do is
what's called setting
a conditional breakpoint.
So I can right-click on this
breakpoint in the debugger,
add my condition.
And I can put any Boolean
expression in Kotlin here.
And if it evaluates to
true, when the code hits it,
then we'll catch
at the breakpoint.
So in this case, I'm going
to type player.health
is equal to 1 because
we're about to decrement it
for the last time in the
case that we care about.
And when I go through that--
we hit twice and
we didn't catch.
Now I hit the last one and
I've caught the break point.
And I only get the
case that I care about.

Indonesian: 
Jadi, Anda sebaiknya ke bagian kode
yang Anda yakin memang mengenai camilan.
Hal baiknya adalah
karena breakpoint tidak dibutuhkan lagi,
saya bisa menariknya
ke baris yang diinginkan.
Dan akan hilang dari
baris sebelumnya, lalu bisa dijalankan.
Dan saat terkena,
saya sekarang bisa mengenainya.
Itu bagus, tapi mungkin
bug yang sebenarnya dicari
hanya berkaitan saat
mengenai camilan terakhir--
saat Android mati di akhir game.
Jadi, masalahnya masih sama.
Saya harus berhenti
setiap terkena camilan.
Itu melelahkan.
Jadi, solusinya kita bisa
menyetel breakpoint bersyarat.
Saya akan mengklik kanan
breakpoint di debugger,
menambahkan syaratnya.
Saya bisa menambahkan
ekspresi Boolean apa pun di Kotlin.
Dan jika dievaluasi ke true,
saat kode mengenainya,
maka akan mengenai breakpoint.
Dalam hal ini, saya akan mengetik
player.health sama dengan 1
karena akan dikurangi untuk terakhir kali
dalam kasus yang diinginkan.
Dan saat saya mencobanya--
sudah kena dua kali
dan belum mengenai breakpoint.
Sekarang, kena yang terakhir
dan mengenai breakpoint.
Dan hanya mendapatkan
kasus yang saya inginkan.

Japanese: 
下がっていきたいと思います
うれしいことに
ブレークポイントが必要なくなるため
注目したい行にドラッグできます
古い行から取り除いて
実行できます
ヒットしたら
そこがブレークポイントです
これはいいですが
追跡しているバグは
最後のデザートと関係があります
Androidの終了時です
その問題が発生しました
デザートにヒットするたびに
停止します
面倒くさいです
そこで
条件ブレークポイントを設定します
デバッガでこのブレークポイントを
右クリックし
条件を追加します
ここにKotlinでブーリアン式を追加できます
ヒットしたときに
trueと評価されたら
ブレークポイントでキャッチします
この場合
“player.health == 1”と入力します
注目しているケースの最後のタイミングで
減分したいからです
実際にやってみると
２回ヒットしましたが
キャッチしませんでした
最後のヒットで
ブレークポイントをキャッチしました
注目したいケースだけを取得します

Chinese: 
表示我们确认小绿人撞上了甜点的那一段
好消息是 我现在不需要这个断点了
我只需把它拖动到我在意的那行代码即可
然后它就会被从旧代码行中移除
然后我就可以运行了
当出现碰撞的时候 我就会在碰撞点获取它
这样不错 但是 也许我要找的那个 bug 
只和我上一次撞到的甜点有关
也就是说 当小绿人最后死去的时候
这里的问题也是一样的 
我需要在每次撞到甜点的时候停下来
非常令人不耐烦
所以 我们可以设定一个条件断点
我可以在调试器中右击这个断点 添加条件
我可以在这里加入任何用 Kotlin 写成的布尔表达式
如果求值为真 那么当代码命中这个条件时
我们就会找到断点
在本例中 我要输入 player.health 的值为1
因为我们要把它缩减到我们关心的上一次撞击
运行之后我们发现
我们撞击了两次 都没有抓住
现在撞到了最后一次 这次我抓到断点了
我也只关心这么一个用例

Chinese: 
进一步延伸这个例子的含义
现在假如我们追踪的这个 bug 属于你最后撞上的那个甜点
而且是在我们正在渲染心形图案的时候
如果我下到我们的渲染循环中
来到我们决定采用残缺的心形还是完整的心形的地方
我可以在这里设置一个断点
因为我已经撞到了另一个条件断点
所以 当我运行的时候 它会前往渲染环节
这没有问题
但是 如果我想要多次检查这个状态
如果我想反复循环它
以免碰到 bug 不能重现的问题
那么 在这里留下无条件断点 就不是什么好的做法
因为我也有同样的问题
每一帧我都会重新回来
为了避免这种现象 我可以
再次右击断点
打开 More 菜单
前往这里 在这里禁用断点
直到我们的第一个断点被命中为止
我来让游戏运行完
现在就不会出现停顿了
因为断点被禁用了
然后 当我撞上最后一个甜点时

English: 
So to take this
example even further,
say the bug that we're
tracing is actually
last dessert that you hit,
but when we render the hearts.
So if I jump down
into our render loop
where we make that determination
between broken and full hearts,
I could set a breakpoint here.
And because I've already hit the
other conditional breakpoint,
when I run, it'll go through
to the rendering step.
And that's fine.
But if I want to check this
condition multiple times--
I want to cycle
through this in case
the bug doesn't
repro every time--
this isn't a great
thing to do to leave
this unconditional
breakpoint here.
Because I have the same problem.
Every frame, I'm
going back through.
What I can do to
get around this is,
right-click on the
breakpoint point again,
open up the More menu.
And go to this
section here, where
we can disable the breakpoint
until the first one
that we had was hit.
I'll let the game run through.
Now we end up with, I'm
not stopping every time
because the breakpoint
is disabled.
And then when I hit
the last dessert,

Korean: 
이 예시를
더 자세히 살펴보겠습니다
우리가 추적하는 버그가
실제로 마지막으로 건드리는
디저트인데
하트를 렌더링한다고 해보죠
렌더 루프로 건너뛰어 볼게요
깨진 하트와 꽉 찬 하트를
결정하는 부분이죠
여기에 중단점을 설정할 수 있습니다
다른 조건부 중단점을
이미 건드렸기 때문에
실행 시에
렌더링 단계를 거치게 됩니다
그건 괜찮습니다
하지만 이 조건을
여러 번 확인하고 싶고
버그가 매번 복제되지 않는 경우
이를 순환하려고 하면
이 무조건부 중단점을
여기에 두는 것은
좋지 않습니다
저도 같은 문제를
겪고 있는데요
모든 프레임을
다시 살펴봐야 하죠
이를 해결하려면
중단점에서 다시
마우스 오른쪽 버튼을 클릭해
'더 보기' 메뉴를 엽니다
그리고 이 섹션으로 이동합니다
여기에서는 처음으로
건드릴 때까지
중단점을 비활성화할 수 있습니다
게임을 실행해볼게요
이제 중단점이 비활성화되어서
매번 중단할 필요가 없게 되었습니다
마지막 디저트를 건드리면

Japanese: 
この例をさらに進むと
追跡しているバグは
確かに最後のデザートで
ヒットしましたが
ハートのレンダリング時です
レンダリングループにジャンプすると
そこで
壊れたハートと完全なハートを判断しています
ここにブレークポイントを設定できました
もう１つのブレークポイントにヒット済みです
実行すると
レンダリングステップに進みます
いいですね
しかしこの条件を複数回確認したくても
ケースでこれを繰り返したくても
バグは毎回再現されません
この無条件ブレークポイントを
残すのは
よくありません
同じ問題が発生します
すべてのフレームで 戻ってしまいます
これを回避するために
ブレークポイントを
もう一度右クリックし
[More]メニューを開きます
このセクションに進み
設定した最初のブレークポイントに
ヒットするまで
そのブレークポイントを無効にできます
ゲームを実行します
最終的に
ブレークポイントが無効になっているため
毎回停止しません
最後のデザートにヒットすると

Spanish: 
Para llevar este ejemplo
un poco más lejos,
digamos que el error que
queremos rastrear es en realidad
el último postre golpeado,
pero cuando renderizamos los corazones.
Si voy al bucle de renderización
donde hacemos
la determinación entre
corazones rotos y completos,
podemos agregar un punto de revisión aquí.
Como ya llegué otros
puntos de revisión condicionales
cuando lo corra, irá al
paso de renderización.
Y está bien.
Pero si quiero controlar
esta condición varias veces,
quiero pasar por
esto en caso
de que el error no se
reproduzca cada vez,
esto no es algo
bueno, dejar este
punto sin condición aquí.
Tengo el mismo problema.
En cada cuadro, vuelvo a pasar.
Para evitar esto,
hago clic derecho en el punto de revisión,
abro el menú "Más"
y voy a esta sección
donde podemos inhabilitar 
el punto hasta que
llegamos al primero que tuvimos.
Ahora llegamos a...
Permitiré que el juego siga.
Llegamos a que no lo voy
a parar cada vez porque
el punto esta inhabilitado.
Cuando golpeo el último postre,

Indonesian: 
Jadi, untuk mengembangkan contoh ini,
misalkan bug yang dicari
adalah camilan terakhir yang terkena,
tapi saat kita merender nyawa.
Jika menuju ke loop render di bawah
tempat kita membuat penentuan
nyawa yang terpakai dan masih penuh,
breakpoint bisa ditetapkan di sini.
Dan karena sudah mengenai
breakpoint bersyarat lain,
saat dijalankan,
langkah rendering akan dimulai.
Itu tidak masalah.
Tapi jika ingin memeriksa
syarat beberapa kali--
saya ingin mengulanginya
misalkan bug
tidak selalu memproduksi lagi--
sebaiknya Anda tidak membiarkan
breakpoint tidak bersyarat ini.
Karena masalahnya sama.
Di setiap frame, berulang kali.
Untuk menangani masalah ini,
klik kanan lagi titik breakpoint-nya.
Buka menu More.
Dan pergi ke bagian ini,
tempat kita bisa menonaktifkan
breakpoint hingga yang pertama terkena.
Game akan saya jalankan.
Sekarang game tidak selalu berhenti
karena breakpoint dinonaktifkan.
Saat mengenai camilan terakhir,

Portuguese: 
Para aprofundar
nesse exemplo
digamos que o bug
que procuramos é de fato
o último doce que acertou,
mas quando renderizamos os corações.
Então, se entrar
no loop de renderização
em que escolhemos entre
corações partidos e inteiros,
aqui pode ser o ponto de parada.
E como já acertei o
outro ponto de parada condicional
quando executo,
passo pela etapa de renderização.
E está tudo bem.
Mas se quero checar
essa condição várias vezes
quero passar por isso
caso o bug não seja reproduzido
todas as vezes
não será bom sair agora
do ponto de parada incondicional.
Porque tenho o mesmo problema.
Eu volto em cada frame.
O que posso fazer
para contornar
é clicar no ponto de parada
de novo
para abir o menu Mais.
E ir para a sessão
onde podemos
desabilitar o ponto de parada
até o primeiro
em que batemos.
Vou deixar o jogo rodar.
Agora que acabamos,
não estou parando sempre
porque o ponto foi desabilitado.
E quando eu bato
no último doce

Korean: 
첫 번째 중단점이 잡힙니다
첫 번째 중단점이
잡혔기 때문에
다른 종속 중단점이
활성화되죠
이제 실행을 하면
렌더 루프로 가게 됩니다
이 부분을 살펴보면서
알아채셨을 것 같은데요
이러한 중단점을
마우스 오른쪽 버튼으로 클릭하고
작업을 시작하면
여기 중단 탭이
보입니다
지금까지 이 모든 항목에 대해
모두 선택을 했는데요
그 말은 현재 실행 스레드가
중단점을 만나면
애플리케이션에서
모든 스레드가
중단된다는 의미입니다
그러면 전체 게임 상태가
일시 중지됩니다
버그에는 유용할 수 있는 부분입니다
전에 하트 렌더링에 대해
얘기한 것처럼 말이죠
하지만 여러 스레드가 지정된
애플리케이션에서 작업하고
정말 까다로운 동기화 문제
몇 가지를 해결하려고 할 경우
중단점을 만난 스레드만
중단해 보려고 하는 것이
좋을 수도 있습니다
이 기능을
강조하기 위해
Android가 죽으면
어딘가에 있는 일부 서버에
점수를 보내는 시뮬레이팅을
담당하는 게임 섹션을
준비했습니다

Spanish: 
el primer punto lo agarra.
Y como llegamos al
primer punto
activó el otro
punto dependiente.
Y al pasar por ahí,
aterrizamos en bucle de render.
Lo que pueden haber notado
durante todas estas cosas,
cuando hicimos clic derecho 
en estos puntos
y empezamos a trabajar con ellos
notarán la pestaña Suspend.
Hasta ahora tenemos todo
esto seleccionado.
Que significa, que cuando el
subproceso que se está ejecutando
encuentre el punto de revisión,
vamos a parar
cada subproceso en la aplicación.
Eso pausa todo el estado del juego.
Y puede ser útil para el error
como dijimos con la
renderización de los corazones.
Si están trabajando en una
aplicación con varios subprocesos
y están buscando
problemas de sincronización
quizás quieran probar
suspender solo el subproceso
que encontró el punto de revisión.
Para resaltar esta funcionalidad,
tenemos una sección en el juego
que, cuando Android muere,
simula que envía el puntaje
a un servidor en algún lugar.

English: 
our first breakpoint catches.
And because we've hit
the first breakpoint,
it's activated the other
dependent breakpoint.
And when I run through, we
land there in the render loop.
So what you might have noticed
during all these things is,
when we right click
on these breakpoints
and start working
with them, you'll
notice the Suspend tab here.
And so far we've had All
selected for all of this.
And that means that when the
currently-executing thread
encounters the
breakpoint, we will just
stop every thread
in the application.
And that pauses the
whole game state.
And that can be
useful for the bug,
like we were talking before
with rendering the hearts.
But if you're working on a
multi-threaded application
and you're chasing down some
really tricky synchronization
issue, you might
also want to try
suspending just the thread that
encountered the breakpoint.
So to highlight
this functionality,
we have a section
of the game that's
responsible for
when Android dies,
simulating sending off the
score to some server somewhere.

Indonesian: 
breakpoint pertama akan aktif.
Karena breakpoint pertama sudah kena,
breakpoint dependen lain akan diaktifkan.
Saat menjalankannya,
kita berhenti di loop render.
Jadi, Anda mungkin
menyadari dari penjelasan ini,
saat mengklik kanan
breakpoint ini dan mulai bekerja,
Anda akan melihat tab Suspend.
Dan kita memilih All hingga saat ini.
Hal ini berarti saat thread
yang berjalan menemui breakpoint,
kita akan menghentikan
semua thread dalam aplikasi.
Dan akan menjeda seluruh game.
Hal itu dapat berguna untuk bug,
seperti saat bahasan kita
tentang merender nyawa.
Tapi jika mengerjakan
aplikasi multi-thread
dan mencari
masalah sinkronisasi yang sulit,
sebaiknya Anda menangguhkan
thread yang menemui breakpoint saja.
Jadi, untuk menandai fungsi ini,
kita mempunyai bagian game
yang bertanggung jawab saat Android mati,
sebagai simulasi untuk mengirimkan
skor ke server di suatu tempat.

Portuguese: 
atingimos o primeiro ponto.
E como o atingimos
o outro ponto de parada é ativado.
E quando rodo,
chego a um loop de renderização.
O que você pode ter percebido
durante tudo isso é
que quando clico com o botão direito
nesses pontos de parada
e começo a trabalhar
com eles
surge a guia Suspender aqui.
E até agora temos Tudo selecionado
para tudo isso.
Isso significa que agora quando o
segmento em execução
encontra o ponto de parada,
pararemos
cada segmento
na aplicação.
Isso pausa o jogo
e pode ser útil
para o bug
como falamos antes
com a renderização dos corações.
Mas se você estiver trabalhando em uma
aplicação multithread
em busca de um problema
de sincronização bem complicado
também pode tentar
suspender apenas o segmento
com o ponto de parada.
Para destacar essa funcionalidade,
temos uma sessão
desse jogo
que é responsável
pela morte do Android
que simula o envio da pontuação
para um servidor em algum lugar.

Chinese: 
就按条件激活了第一个断点
然后因为我们撞上了第一个断点
也就激活了另一个依赖断点
继续运行后 我们就会抵达渲染循环
大家可能注意到的是
在我们右击这些断点的时候
你可能会注意到这里的 Suspend 标签
目前我们为所有这些代码选中了 All
这意味着 在当前执行线程遇到断点的时候
我们会停止应用内的所有线程
这样就会停止整个游戏状态
这样可能会对我们之前提到过的在渲染心形图案时出现的 bug 有用
但是 如果你正在处理一个多线程应用
而你正在寻找一些特别麻烦的异步问题
这时你可以试着只去暂停那个撞到断点的线程
为了重点说明这个功能
我们在游戏中设置了这样一个环节
在小绿人死去的时候 
模拟出一个向其他地方的服务器发送分数的操作

Japanese: 
最初のブレークポイントが
キャッチします
最初のブレークポイントにヒットすると
依存するブレークポイントが
アクティブ化します
通過すると
レンダリングループに入ります
これらをご覧になって
お気付きになったかもしれませんが
これらのブレークポイントを
右クリックし
機能し始めると
ここに[Suspend]タブがあります
これまではすべてで
[All]が選択されていました
これは現在実行中のスレッドが
ブレークポイントに遭遇すると
アプリケーションのすべてのスレッドが
停止することを意味します
これによりゲーム全体状態が停止します
これは ハートのレンダリングのような
バグで役立ちます
マルチスレッドの
アプリケーションで
面倒な同期問題を
追跡している場合
ブレークポイントに遭遇した
スレッドのみを
停止したいと思うかもしれません
この機能についてご紹介します
このゲームには
Android終了時を扱う
セクションがあり
どこかにあるサーバーにスコアを送る
シミュレーションをしています

Korean: 
이 경우에 지연을
적용하고 몇 가지를 기록합니다
네트워크 호출을 하는
여기 백그라운드 스레드에
중단점을 설정할 경우
마우스 오른쪽 버튼으로 클릭해
스레드에서만 중단을 요청합니다
그 다음에
게임을 플레이합니다
다시 끝나버렸네요
이전에 죽었기 때문에
이미 백그라운드 스레드에
있다는 게 보이실 겁니다
하지만 UI 스레드는
아직 활성화되어 있죠
즉, 전체 게임을
다시 순환하고
여러 네트워크 호출 신호를
보내는 상태로
전환할 수 있습니다
또한 몇 가지 까다로운 동기화 문제를
거기에서 복제해 볼 수도 있죠
다음 팁으로는,
설정한 나머지 중단점의
유용성에 대해
알려 드리고 싶습니다
그러면 계속해서
여기에서 비활성화해보겠습니다
마우스 오른쪽 버튼으로 클릭해
활성화를
선택 해제하면 됩니다
이 방법도 괜찮긴 하지만
더 편리한 방법은
'Alt'를 누른 채
클릭하는 것인데
이렇게 하면 이 항목이 켜졌다 꺼집니다

Indonesian: 
Saat ini, kita menunda
dan mencatat beberapa hal saja.
Tapi jika menetapkan
breakpoint di thread latar belakang
tempat kita melakukan
panggilan jaringan,
klik kanan, dan setel untuk
menangguhkan thread tersebut saja,
lalu game akan saya jalankan--
yang juga sudah berakhir--
dan Anda akan menyadari
karena saya kalah sebelumnya,
saya sudah
di thread latar belakang.
Tapi, thread UI-nya masih aktif,
yang berarti saya
bisa mengulangi game-nya
dan membuat saya, misalnya, mempunyai
beberapa isyarat panggilan jaringan.
Saya bisa mencoba merekonstruksi beberapa
masalah sinkronisasi yang rumit di sana.
Jadi, untuk tips berikutnya
yang ingin saya tunjukkan.
Karena breakpoint lain
yang sudah disetel tidak terlalu berguna,
jadi saya akan mencoba
menonaktifkannya di sini.
Jadi, saya akan mengklik kanan
dan batalkan pilihan Enabled.
Itu tidak masalah.
Tapi, akan lebih praktis
menggunakan Alt + Klik,
yang bisa mengalihkannya
ke aktif atau nonaktif--
atau Option + Klik untuk Mac.

Spanish: 
En nuestro caso, solo lo retrasamos
y registramos cosas.
Pero si agrego un punto de revisión aquí
en el subproceso en segundo plano donde
hacemos nuestra llamada a la red,
hago clic derecho y le digo
que se suspenda en ese subproceso,
luego puedo jugar
a través del juego,
que terminó nuevamente,
y pueden ver que
como morí anteriormente, ya estoy
en el subproceso en segundo plano.
Pero el subproceso de IU sigue activo
así que puedo moverme por todo el juego
y ponerme en un estado en el
que tengo múltiples llamadas
a la red esperando.
Y puedo intentar reproducir
algún problema raro de
sincronización allí.
Para el siguiente consejo
que quiero mostrarles
el resto de los puntos de revisión
que agregamos no son muy útiles.
Así que voy a intentar desactivarlos aquí.
Para hacer eso, 
puedo hacer clic derecho y luego
desmarcar la opción de habilitado.
Y eso está bien.
Pero lo que puede ser más 
cómodo, es utilizar
Alt + Clic, lo que intercambia
esto entre encendido y apagado

Japanese: 
このケースでは
遅延を発生させログに記録しています
ネットワーク呼び出しを行う
バックグラウンドスレッドのここに
ブレークポイントを設定する場合
右クリックしてそのスレッドだけで
停止するように設定します
ここで行いたいのは
ゲームオーバーになったゲームを
終わりまでプレイすることです
終了しているため
バックグラウンドのスレッドにいます
しかしUIスレッドは
まだアクティブです
つまりもう一度ゲーム全体を
繰り返すことができ
複数のネットワーク呼び出しを
キューに入れている状態にできます
そこで面倒な同期問題などを再現できます
次に紹介するヒントでは
設定した残りのブレークポイントは
特に役立たないものです
先に進んで
これらを無効にしましょう
これを行うには
右クリックして
[Enabled]の選択を外します
これでOKです
もう少し便利なのは
Altを押しながら
クリックしてオン/オフを切り替えるか

Chinese: 
在这个例子中 我们只需设置延迟 并记录一些日志即可
但是 如果我在正进行网络调用的背景线程中设置断点
右击它 让它暂停那个线程
然后继续玩游戏 游戏又结束了
大家可以注意到 因为我的角色之前死了
所以我现在已经在背景线程里了
但是 UI 线程还处在激活状态
也就是说 我可以再次重复循环整个游戏
并让自己进入这样一个状态：
我对多个网络调用进行了排队操作
我可以在那里复制一些很麻烦的异步问题
下面我想展示给大家的小技巧是
我们设置的其余断点并没有特别的用处
所以 我要禁用它们
我可以右击并取消选中 Enabled
这没问题
不过更方便的做法是使用 Alt-点击
这样就会让它们在开/关状态间切换
如果是 Mac 电脑的话 用 Option-右击就好

Portuguese: 
Nós apenas atrasamos e registramos
algumas coisas.
Mas se eu colocar um ponto de parada aqui
no segmento de fundo
onde fazemos a chamada de rede,
clique nele com o botão direito
para suspender apenas o segmento,
e o que eu posso fazer
é jogar o meu jogo
que acabou novamente
e veremos que como eu morri antes,
já estou
no segmento de fundo.
Mas o segmento da IU
ainda está ativo
e eu posso passar
por todo o jogo de novo
e chegar a um estado que,
digamos
possua várias chamadas de rede na fila.
E posso reproduzir
um tipo de problema de sincronização
complicado aqui.
Para a próxima dica,
gostaria de mostrar a vocês
os outros pontos de parada
que definimos
não são muito úteis.
Vou seguir em frente
e tentar desativá-los aqui.
Para isso,
posso clicar com o botão direito
e desmarcar a opção Ativar.
E tudo bem.
Mas pode ser mais fácil
usar Alt + clique
que irá apenas
ativá-los e desativá-los

English: 
In our case, we just
delay and log some stuff.
But if I set a breakpoint here
in the background thread where
we're doing our network call,
right-click it and tell it
to suspend on just the thread,
then what I can do is play
through my game--
which is over again--
and you'll notice that because
I died before, I'm already
in the background thread.
But the UI thread
is still active,
which means I can cycle
through the whole game
again and get myself in a
state where, say, I have
multiple network calls cued.
And I can try to reproduce some
kind of tricky synchronization
issue there.
So for the next tip
I want to show you,
the rest of the breakpoints
that we have set
aren't particularly useful.
So I'm going to go ahead and
try to disable them here.
So what I can do to
do that is right-click
and then deselect Enabled.
And that's fine.
But what might be
handier is to use
Alt + Click, which will just
toggle these guys on and off--

Indonesian: 
Lalu, kita lanjutkan
ke tips yang terakhir,
bukan baris itu, tapi yang ini.
Jadi, ini adalah bagian kode
tempat kita menentukan pengganda skor
di atas sini yang menentukan
seberapa banyak poin yang digandakan
saat mengenai angka 10.
Misalnya, saya perlu melacak
nilai ini dalam aplikasi berulang kali--
banyak sekali.
Saya bisa menyetel breakpoint di sini.
Lalu, saya jalankan aplikasi.
Dan masalahnya masih sama.
Saat game dijalankan,
saya selalu mengenai breakpoint ini.
Lalu, saya harus mencari informasi
yang dicari melalui seluruh menu ini,
yang akan melelahkan.
Saya sebenarnya
ingin mencatat nilai pengganda ini.
Tapi, saya tidak ingin
membiarkan laporan log berada di kode.
Karena akan menyusahkan.
Jadi, yang bisa kita lakukan
yaitu membiarkan breakpoint
dan menonaktifkan Suspension sepenuhnya.
Kini, setiap terkena breakpoint ini,
aplikasi tidak akan berhenti.
Lalu, saya akan 
ke bagian Evaluate and log.
Dan saya bisa mengetik
ekspresi Kotlin apa pun.

Chinese: 
现在为大家介绍最后一个小技巧 是这一行
在这部分的代码中 
我们会确定分数倍增器 也就是这个东西
它负责决定当你撞到10时 分数会倍增多少
假如我需要在应用中多次追踪这个值
我可以在这里设置断点
然后浏览应用 我们的问题是相同的
在游戏运行时 我总会撞到这个东西
然后 我就需要在整个菜单中找出我想要的信息
有时这会是一个非常麻烦的任务
我真正想做的是 在这里记下倍增器数值
但我不想在代码里到处都写上记录日志的语句
这样太难受了
我们要做的是 留下断点 并整体禁用暂停
现在 无论我们何时撞上这个断点
都不会导致整个应用停止
然后我可以来到这里的 Evaluate and Log 选项
输入任何 Kotlin 语言写成的表达式

Spanish: 
u Option + Clic si usan Mac.
Después de haber dicho eso, iré a
mi último consejo, que no es esta línea,
es esta de aquí.
Esta es la parte del código donde
determinamos el multiplicador de puntajes,
que es esto de aquí, que determina
por cuánto se multiplica tu puntaje
cuando llegas a 10.
Digamos que necesito rastrear este valor
en todo momento en la aplicación.
Digamos que muchas veces.
Puedo agregar un punto de revisión aquí
y puedo ejecutar mi aplicación
y tendremos el mismo problema.
Cuando el juego se está ejecutando,
llego aquí todo el tiempo
y tengo que perseguir la información
que estoy buscando en todo el menú
lo que puede resultar tedioso.
Lo que en realidad quiero hacer
es registrar el valor del multiplicador.
Pero no quiero descartar declaraciones
de registro en todo mi código.
Porque es un fastidio.
En vez de eso, podemos
dejar nuestro punto de revisión
e inhabilitar la suspensión por completo.
Cada vez que lleguemos
a este punto de revisión
no vamos a detener la aplicación.
Luego puedo ir a esta sección
de registro y evaluación
y puedo escribir cualquier
expresión de Kotlin.

Japanese: 
MacであればOptionを
押しながらクリック
さて
最後のヒントに移りたいと思います
こっちではなく
こっちですね
これはスコアの乗数を決定する
コードです
ここまでですね
これは“10”をヒットしたときに
乗じるポイントを決定します
アプリ内で様々なタイミングで
この値を追跡する必要があるとします
非常に多くの回数です
ここにブレークポイントを
設定できます
アプリを実行します
同じ問題が発生します
ゲームを実行すると
この問題に毎回ぶつかります
情報を追跡する必要があります
このメニュー全体を探します
うんざりします
乗数の値を記録できたらと
本当に良いと思います
だからと言ってlogステートメントを
コードの至る所に
書き加えることもしたくありません
骨が折れます
その代わりに
ブレークポイントを残し
停止をすべて無効にします
このブレークポイントにヒットしても
アプリは停止しません
次に[Evaluate and Log]セッションに
移動します
任意のKotlin式を入力できます

English: 
or Option + Click
if you're on Mac.
So all that being said, I'll
go to my last tip, which
isn't that line, it's this one.
So this is the part of the code
where we determine the score
multiplier, which is
this guy up here that
determines how much your
points are multiplied
by when you hit a 10.
Let's say I need to track this
value over all sorts of times
in the app--
very, very many times.
I can set a breakpoint here.
And I can run through my app.
And we have the same problem.
When the game is running, I
hit this guy all the time.
And then I have to chase
down the information
I'm looking for through
this whole menu, which
can be tedious.
What I really want to do is
log the multiplier value here.
But I don't want to drop log
statements all over my code.
It's kind of a pain.
So what we can do instead
is leave our breakpoint
and disable
suspension altogether.
So now, whenever we
hit this breakpoint,
we're not going to stop the app.
Then I can go over here to
this Evaluate and Log section.
And I can type in any
Kotlin expression.

Korean: 
Mac을 사용하신다면
'Option'을 누른 채 클릭하면 됩니다
그렇게 되는 것이고
이제 마지막 팁으로 넘어갈게요
이 라인을 보셔야 해요
이건 점수 승수를 결정하는
코드의 일부입니다
여기 있는 녀석이죠
10을 만나면
점수에 곱해지는
배수를 결정하는 것이죠
앱 내에서
몇 번이고 이 값을 추적해야 한다고
가정해 봅시다
정말 정말 많이요
여기에 중단점을
설정할 수 있습니다
그리고 앱을 실행하면 됩니다
같은 문제가 나타나죠
게임을 실행할 때
이 녀석을 항상 건드려요
그런 다음 이 메뉴
전체를 둘러보며
찾고 있는 정보를
추적해야 합니다
정말 지치죠
정말 하고 싶은 건
여기에 승수 값을 기록하는 것입니다
하지만 로그 문을
코드 전반에 흐트러뜨리고 싶진 않아요
골칫거리가 될 테니까요
그렇다면 대신
중단점을 두고
중단을 다같이
비활성화할 수 있습니다
이제 이 중단점이
잡힐 때마다
앱이 중단되는 일은 없습니다
그러고 여기 계산
및 로그 섹션으로 이동할 수 있습니다
모든 Kotlin 식을
입력할 수 있죠

Portuguese: 
ou Opção + clique
para Mac.
Com tudo isso,
irei para a última dica
que não é essa linha,
é essa aqui.
Essa é a parte do código em
que determino o multiplicador da pontuação
que fica aqui em cima
e que diz
quantos pontos são multiplicados
ao acertar um 10.
Digamos que preciso rastrear
esse valor diversas vezes
no aplicativo.
Muitas vezes mesmo.
Defino um ponto de parada aqui.
Posso rodar o app
e ter o mesmo problema.
Quando rodar o jogo,
sempre chegarei a esse ponto.
E quando tiver
que procurar a informação
verei esse menu inteiro
o que pode ser chato.
O que quero fazer é
registrar o valor do multiplicador aqui.
Mas não quero inserir instruções de
registro em todo o meu código.
Isso é meio chato.
Em vez disso,
posso deixar o ponto de parada
e desativar junto
a suspensão.
E agora, sempre
que chegar até ele
o app não para.
Depois posso ir
para a seção Avaliar e Registrar.
E posso digitar
um tipo de expressão em Kotlin.

Indonesian: 
Dalam hal ini,
"Mult is ${score.multiplier}_".
Sekarang, saat menemui
breakpoint, thread tidak berhenti.
Thread hanya mengevaluasi ekspresinya,
mencatat log ke konsol,
lalu melanjutkan proses.
Jika tidak perlu
informasi sebanyak itu--
Anda hanya perlu memeriksa
jika ada jalur kode tertentu--
Anda bisa batal memilihnya
dan memilih pesan saat terkena breakpoint.
Dan akan memberi tahu
jika Anda kali ini mengenai breakpoint.
Bahkan, ini sangat praktis
hingga ada pintasannya.
Tekan Shift + Klik di bagian tepi,
setelan akan dibuat untuk Anda.
Demikian tips yang ingin saya sampaikan.
Saya akan kembalikan ke David
untuk menyampaikan
beberapa hal yang dia ketahui.
Baik, pernahkah Anda mengerjakan
bug tanpa ada perkembangan,
mengesampingkannya untuk sementara,
lalu mengerjakan bug kedua?
Tapi saat mengerjakan bug-nya,
Anda selalu terkena
breakpoint dari bug yang pertama.
Karena belum bisa menghapusnya,
Anda harus selalu
menonaktifkannya satu per satu.

Portuguese: 
Nesse caso,
o multiplicador é score.multiplier.
E agora quando o segmento encontra
o ponto de parada
ele não para.
Ele avalia
a expressão
registra no console
e segue em frente.
Se não precisar de todas essas informações
verifique se há
algum caminho de códigos
desmarque ele
e em vez disso
escolha uma mensagem
para o ponto de parada
que irá avisá-lo
que você chegou até ele
dessa vez.
De fato, isso é tão útil
que há um atalho.
Se usar Shift + Clique
na calha
criará um deles
para você.
Essas são todas as dicas
que queria compartilhar.
Vou chamar novamente o David
para falar sobre outras dicas
que ele sabe.
Você já
se encontrou trabalhando
em um bug
em que não estava fazendo progresso,
decidiu parar um pouco
e foi trabalhar em outro bug?
Mas enquanto trabalhava
nesse bug
continuou se deparando
com os pontos do primeiro
e ainda não estava pronto
para deletá-los
então você continua desativando
um de cada vez.

Korean: 
이 경우에 승수는
score.multiplier입니다
이제 스레드가 이 중단점을 만나면
멈추지 않습니다
이 식을 계산하기만 하고
콘솔에 기록되고
계속 진행됩니다
그렇게 많은 정보가
필요하지 않으면
특정 코드 경로를
다루는지 확인하기만 하면 됩니다
이 항목을 선택 해제하고
대신에 중단점이
메시지가 표시되도록
선택하면 됩니다
이때 이 중단점에
도달했음을
알려 줄 것입니다
사실 바로 가기가 있어서
매우 편리하죠
거터에서
'Shift'를 누른 채로 클릭하면
이 중 하나가
만들어집니다
지금까지 제가 공유하고 싶은
팁을 말씀드렸습니다.
그럼 데이빗을
다시 초대해 볼까요?
여러분께 여러 가지 지식을
알려 드릴 것입니다
[박수]
혹시 그런 경험 있으신가요?
버그를 발견했는데
별로 진전이 없을 때
잠시 제쳐 두고
두 번째 버그로 넘어간 경험 말입니다
하지만 두 번째 버그를
작업하는 와중에도
첫 번째 버그의 중단점을
계속 만나게 되는 거죠
아직 그 중단점을
삭제할 준비가 되지 않아
한 번에 하나씩
계속 비활성화합니다

Chinese: 
在本例中 我的倍增器是 score.multiplier
现在 当线程遇上这个断点的时候 它就不会停止
它只会计算这个表达式
将其记入控制台 然后继续运行
如果你不需要这么多信息
而只是想看看是否需要通过某个特定的代码路径
那么你可以取消选中这里
然后选择采用断点撞击信息
它会直接告诉你 这次你撞上了这个断点
这种做法非常方便 还附带了一个快捷方式
如果你在栏距中 Shift+点击
它就会帮你创建好
这就是我想要分享的小技巧
下面有请 David 来为大家分享一些他所知的小技巧
大家有没有遇到过这种情况：
想要处理一个 bug 但却迟迟没有进展
于是你决定把它放在一边不管
然后再去处理第二个 bug
但是 就在你处理第二个 bug 的时候
你会不断地撞上来自第一个 bug 的断点
你还不想删除这些断点
所以只能一个一个地去禁用

Spanish: 
En mi caso, mi multiplicador es
score.multiplier.
Y cuando el subproceso encuentre
el punto de revisión,
no se detendrá.
Solo evaluará esa expresión,
la registrará en la consola,
y continuará.
Si no necesitan tanta información
y solo quieren saber si atraviesan
cierta ruta del código
pueden no seleccionar esto y
que aparezca un mensaje
cuando se llega al punto de revisión.
Solo les dirá que llegaron a ese punto
en ese momento.
De hecho, es tan útil que
tiene una combinación de teclas.
Se creará si presionan Mayúscula + Clic.
Esos son todos los consejos 
que quería compartir.
Voy a invitar a David de nuevo
para que les cuente 
sobre los que él conoce.
[APLAUSOS]
¿Alguna vez han estado trabajando
en un error con el
cual no están progresando
y deciden dejarlo de lado por un momento
y trabajar en un segundo error?
Y cuando están haciendo eso
siguen llegando a los puntos de revisión
del primer error.
No están listos para borrar esos puntos,
así que los inhabilitan uno por uno.
Hay una mejor forma

English: 
So in this case, my multiplier
is score.multiplier.
And now when the thread
encounters this breakpoint,
it doesn't stop.
It just evaluates
this expression,
logged it to the
console, and moves on.
If you don't need that
much information-- you just
need to check to see if we go
through a certain code path--
you can deselect
this and instead
choose to have a
breakpoint hit message.
And it'll just tell you
that you hit this breakpoint
at this time.
And in fact, that's
so handy that there
is a shortcut for it.
If you Shift +
Click in the gutter,
it'll create one
of these for you.
So those are all the tips
that I wanted to share.
I'm going to invite
David back over
to tell you about some of
the ones that he knows.
[APPLAUSE]
DAVID HERMAN: All
right, have you ever
found yourself working
on a bug where you're not
making progress, you decide
to put it aside for a bit,
and then work on a second bug?
But while you're
working on that bug,
you keep hitting the
breakpoints from the first bug.
You're not ready to delete
those breakpoints yet,
so you just keep
disabling one at a time.

Japanese: 
ここでは“score.multiplier”を入力します
これでスレッドが
このブレークポイントに遭遇しても
停止しません
この式を評価するだけです
コンソールに記録され
先に進みます
それほど情報が必要なく
コードパスを通過したかどうかだけ
確認すればいい場合は
この選択を外し
ブレークポイントヒットメッセージの通知を
選択します
ここでブレークポイントに
ヒットしたことを通知するだけです
ショートカットがあるので
非常に便利です
Shiftを押しながらガターを押すと
これらが１つ作成されます
私がお伝えしたかったヒントは
以上です
デービッドと代わります
今度は彼がいくつかのヒントを
お話しします
はい
これまでバグの修正をしていて
手に負えないと思い
ひとまず放っておいて
次のバグの修正を始めた
ことがありますか
しかしそのバグに取り組んでいると
最初のバグのブレークポイントに
ヒットし続けます
ブレークポイントはまだ
削除できる状態ではありません
一度に１つずつ無効にしていきます

Indonesian: 
Tapi, ada cara yang lebih baik
dengan menggunakan grup breakpoint.
Saya akan ke sini.
Misalkan kita mengenai breakpoint ini.
Klik kanan breakpoint, lalu buka More.
Dan bisa dilihat
semua breakpoint ini.
Anda bisa memilih banyak,
klik kanan, dan buat grup barunya.
Anda bisa memberinya
nama sesuai bug yang dikerjakan.
Saya akan memberinya nama Justin.
Karena sudah dikelompokkan,
Anda bisa mengaktifkannya--
aktifkan/nonaktifkan dengan satu klik.
Dan saat sudah selesai dengan bug,
Anda juga bisa menghapus semuanya.
Baik, saya akan kembali ke kode.
Pada konteks tertentu,
fungsi ini bertanggung jawab
untuk menginisialisasi item saat ini.
Saya jalankan
beberapa kali agar terlihat.
Saat berada di atas layar,
kita belum tahu apakah item
adalah camilan acak atau angka 10.
Sekarang, misalkan saya ingin
memilih metode generateRandomType,
tapi secara tidak sengaja melewatinya.
Mungkin saya sengaja melakukannya,
tapi mungkin juga hasilnya
sedikit membingungkan.
Saya tidak menduganya.

English: 
Well, it turns out
there's a better
way using breakpoint groups.
So I'm going to go here.
And let's imagine that this
was a breakpoint we just hit.
Right-click on the
breakpoint, go to More.
And now you see all the
breakpoints up here.
You can multi-select
them, right-click,
create a new group for them.
You can name this after the
bug that you're working on.
I'm just going to
call this Justin.
Now that they're grouped,
you can enable them--
toggle them on and off
with a single click.
And when you're
done with the bug,
could also just delete
all of them as well.
I'm going to jump
back into the code.
Now for some context,
this is the function
responsible for initializing
the current items.
So I'm going to let this
run a couple of times
so you can see it.
So when the item is off
the top of the screen,
we don't yet know if it's
going to be a random dessert
or a number 10.
Now, let's say
here, I want to step
into this generate
random type method,
but I accidentally step over it.
Now, I may have stepped
over on purpose also,
but maybe the result was a
little bit confusing to me.
I didn't expect it.

Spanish: 
por medio de los grupos 
de puntos de revisión.
Iré aquí.
Imaginemos que es un punto de revisión
al que llegué
Hagan clic derecho 
en el punto de revisión y vayan a Más.
Verán todos los puntos aquí.
Pueden hacer selección múltiple,
clic derecho,
crear un grupo nuevo.
Pueden darle el nombre
del error en el que están trabajando.
Voy a llamarlo Justin.
Ahora que están agrupados,
pueden habilitarlos,
cambiar entre encendido y apagado
con un solo clic.
Y cuando terminen con el error,
pueden borrarlos todos.
Voy a volver al código.
Para darles contexto, esta es la función
que inicializa los elementos actuales.
Lo ejecutaré un par de veces
para que lo vean.
Cuando el elemento está 
fuera de la pantalla
aún no sabemos si será un postre
o un número 10.
Digamos que quiero entrar en este
método de generación de tipo aleatorio
pero accidentalmente paso sobre él.
Es posible que lo haya pasado a propósito
pero tal vez el resultado fue
un poco confuso para mí.
No esperaba eso.

Korean: 
하지만 이렇게 하는 것보다
중단점 그룹을 사용하는 것이
더 효율적입니다
여기를 봐주세요
이게 방금 만난 중단점이라고
상상해 봅시다
마우스 오른쪽 버튼으로 중단점을 클릭해 
'더 보기'로 이동합니다
이제 여기에
모든 중단점이 표시됩니다
다중 선택을 하고
마우스 오른쪽 버튼으로 클릭해
새 그룹을 만듭니다
작업 중인 버그의
이름을 따서 지정할 수 있겠죠
저는 저스틴이라고
부르겠습니다
이제 그룹화가 되어
활성화할 수 있습니다
한 번의 클릭으로
활성화를 켰다가 끌 수 있죠
버그 작업을 마치면
전체를
삭제할 수도 있습니다
그럼 코드로
돌아가보겠습니다
지금 일부 컨텍스트에서는
이게 현재 항목의
초기화를 담당하는
함수입니다
몇 차례 실행을 해서
어떻게 되는지
보여 드리겠습니다
아이템이 화면 상단에서 떨어지면
그게 무작위 디저트일지
숫자 10일지 아직
알 수 없습니다
이제 여기서
무작위 유형의 메서드를
생성하려고 하는데
실수로 넘어가 버렸습니다
일부러 넘어갔을 수도 있는데요
결과는 좀 혼란스러웠습니다
예상치 못했죠

Chinese: 
其实 使用断点群组 就方便得多了
我来为大家演示一下
假如这个就是我们刚刚撞上的断点
右击断点 前往 More
现在你会看到 所有的断点都在上面
你可以多选它们 右击 为它们创建一个新群组
你可以把它命名为你正在处理的 bug 的名字
我先把它命名为 Justin
分组完毕后 你可以启用它们
点击一下即可在开/关状态间切换
在 bug 处理完毕之后
你也可以把它们全部删除
现在回到代码
先给大家提供点上下文 这个功能的作用是
初始化当前内容
我让它运行几遍 大家看看
当内容从屏幕顶端掉下来时
我们这时还不知道它会是随机的其他甜点还是 10
假如这里我想要步进到这个生成随机内容的方法
但是我一不小心跨过了它
我可能是故意跨过它的
但是这个结果可能看起来让人有点迷惑
是我没有料到的
事后来看 我希望自己的做法是步进进去

Portuguese: 
Bom, há uma maneira melhor
de usar grupos de pontos de parada.
Vamos para cá.
Imaginem que acabei de me deparar
com esse ponto.
Clique com o botão direito nele
vá para Mais.
e veja todos os pontos de parada.
Selecione vários
ao clicar com o botão direito
e crie um novo grupo.
O grupo pode ter o nome do bug
em que você está trabalhando.
Eu vou chamá-lo de Justin.
Agora que estão agrupados,
eles podem ser habilitados
ativados e desativados
com um só clique.
E quando terminar o bug
pode também deletar
todos eles.
Eu vou voltar para o código.
Para mostrar o contexto,
essa é a função responsável
pela inicialização dos itens atuais.
Deixarei rodar umas vezes
para verem.
Se o item não está
no topo
não sabemos se ele será
um doce aleatório
ou o número dez.
Digamos
que quero entrar agora
neste método
de geração aleatória,
mas, acidentalmente,
eu passo por ele.
Eu também posso ter passado
por cima dele de propósito
mas o resultado
pode ter sido um pouco confuso.
Eu não esperava por ele.

Japanese: 
いい方法があります
ブレークポイントグループを使用するのです
これについてお話しします
これが今ヒットした
ブレークポイントだとします
ブレークポイントを右クリックし
[More]をクリックします
ここにすべてのブレークポイントが
表示されます
複数選択して
右クリックし
新しいグループを作成できます
取り組むバグにちなんで
これに名前を付けます
ここでは“Justin”と名付けます
これでグループ化されました
ワンクリックで
これらのオン/オフを
切り替えることができます
バグの対応が終わったら
すべてを削除することもできます
コードに戻りたいと思います
これはあるコンテキストで
現在のアイテムを初期化する関数です
ご覧いただくために何度か実行します
アイテムが画面に表れるまでは
それがデザートなのか“10”なのか
まだわかりません
仮にこのランダムタイプ生成メソッドに
ステップインしたいとします
しかしうっかり
ステップオーバーしてしまいました
わざとステップオーバーしたかもですが
結果に少々混乱しています
予想していませんでした
ステップインしたかったのです

Portuguese: 
Então o que gostaria de fazer
é voltar atrás e entrar nele.
Se o seu alvo é um dispositivo
que roda no mínimo o Android 10,
pode clicar no botão drop frame.
Isso fará você sair do método atual
e voltar para antes de ter começado.
E ao chegar nele de novo,
terá uma segunda chance.
Esse recurso não é
uma máquina do tempo.
Então, se estiver no meio
de uma função longa
e tiver feito muitos intermediários
como ter modificado
o estado da classe atual
isso não é desfeito
ao ativar o drop frame.
Isso não é um problema,
apenas algo que deve saber.
Mas apesar disso,
esse recurso me salvou muitas vezes.
Agora vamos focar
na janela de Variáveis.
Então essa é a classe do item.
E a instância em particular
de um item é ID10231.
Como pode ver nessa tela,
já existem alguns itens.
Digamos que eu só queira seguir
o ciclo de vida
desse item aqui.
Antes,
eu posso ter escrito 10231
em um pedaço de papel
mas isso pode me fazer errar

Chinese: 
如果你的针对设备至少运行的是 Android 10 以上版本
那么你可以点击这个丢帧按钮
它的作用是 把你拉出当前的方法
再放回它开始前的地方
当你再次步进它的时候 就会获得重新开始的机会
这个功能并不是什么时光机
如果我身处一个冗长的方法当中
而它又已经做了很多中间性的工作
例如修改当前类的状态
那么当丢帧发生时 这些工作并不会消失
这不是什么大不了的事 只是需要大家注意一下
尽管如此 这个功能还是为我省下了大量的时间
好 现在请大家关注下面这里的 变量 窗口
这是项目类
这个项目的实例是 ID10231 
正如大家在屏幕上看到的
这里已经有了几个项目
但我们只想跟踪这个特定项的生命周期
以前 我可能会在纸上写下 10231
但是这样容易出错
我们只需右击它 标记这个对象

Indonesian: 
Jadi, saya ingin
secara tepat memilih metodenya.
Jika menargetkan perangkat
yang minimal menjalankan Android 10,
Anda bisa mengklik tombol Drop Frame ini.
Dan itu akan menarik Anda
keluar dari metode saat ini
dan mengembalikan Anda ke titik awal.
Jadi, saat memilihnya lagi,
Anda mendapatkan kesempatan kedua.
Tapi, fitur ini bukan mesin waktu.
Jika berada
di tengah fungsi yang panjang
dan sudah melakukan
banyak pekerjaan menengah--
misalnya, mengubah status class saat ini--
Drop Frame tidak akan
mengurungkan perubahan.
Bukan faktor penentu,
tapi perlu untuk diperhatikan.
Terlepas dari itu, fitur ini
sudah membantu saya berulang kali.
Sekarang, saya ingin
Anda fokus ke jendela Variables di bawah.
Jadi, ini adalah class item.
Dan instance item ini adalah ID10231.
Jadi, dapat dilihat di layar,
sudah ada beberapa item.
Tapi misalkan saya ingin
mengikuti alur item ini saja,
Hal yang biasanya
saya lakukan dulu
adalah menulis 10231 di selembar kertas,
tapi hal itu rentan error.

Spanish: 
Lo que quiero hacer en retrospectiva
es entrar en el método.
Si apuntan a un dispositivo
que tenga, al menos, Android 10
pueden hacer clic en este botón
de marco desplegable
y los sacará del método en curso
y los llevará al punto 
antes de que empiece.
Cuando ingresen nuevamente,
tendrán una nueva oportunidad.
Esta función no es una máquina del tiempo.
Si estoy en el medio de
una función larga y realicé
mucho trabajo intermedio,
por ejemplo,
modifiqué el estado de
una clase en curso,
eso no se deshace cuando
se descarta el marco.
No es un factor decisivo,
es algo para tener en cuenta.
A pesar de eso, esta función
me ha salvado millones de veces.
Ahora quiero que presten atención 
a la ventana de variables.
Esto es una clase de elemento.
Y esta instancia en particular 
de un elemento es ID10231.
Como pueden ver en la
pantalla, hay un par de elementos.
Pero digamos que solo quiero
seguir el ciclo de vida
de este elemento en particular.
En el pasado, habría escrito
10231 en un papel
pero eso es propenso a errores.

Japanese: 
Android 10以上のデバイスで
実行している場合
この[Drop Frame]ボタンをクリックできます
このボタンで
現在のメソッドから抜け出し
開始する前の状態に戻れます
もう一度ステップインして
やり直せます
この機能はタイムマシンではありません
長い関数の中にいて
たくさんの処理を実行済みの場合
例えばこの現在のクラスの状態を
変更している場合
[Drop Frame]ボタンを押しても
元に戻せません
更地に戻す機能ではないので
注意してください
それでもこの機能によって
多くの時間を節約できました
次に[Variables]ウィンドウについて
説明したいと思います
これはアイテムクラスです
アイテムのインスタンスは
ID10231です
ご覧のとおり
いくつかのアイテムが
既に存在していますが
このアイテムのライフサイクルだけを
追跡することとします
“10231”と紙に
メモしたと思いますが
これは問題が起こりやすい行為です

English: 
So what I wish I could do in
retrospect was step into it.
If you're targeting
a device that's
running at least Android 10,
you can click on this drop frame
button.
And what that's
going to do is it's
going to pull you out
of the current method
and put you right back
before it started.
So when you step into it again,
you get your second chance.
Now, this feature is
not a time machine.
So if I was in the middle of a
long function and it had done
a lot of intermediate
work-- for example,
modified the state of
this current class--
that doesn't get undone
when you drop frame.
That's not a deal-breaker, it's
just something to be aware of.
And despite that, this feature
has saved me a ton of times.
Now I'd like to bring your
focus down here to the Variables
window.
So this is the item class.
And this particular instance
of an item is ID10231.
So as you can see on
the screen, there's
already a couple of items there.
But let's say I just want to
follow the lifecycle of just
this particular item.
Now, what I might
have done in the past
is write down 10231
on a piece of paper,
but that's a little error-prone.

Korean: 
다시 생각해보니 먼저
발을 들여놨어야 했던 것 같습니다
Android 10 이상을
실행하는 기기를 대상으로 하면
이 '드롭 프레임' 버튼을
클릭할 수 있습니다
그러면
현재 메서드에서 나와
시작하기 바로 전으로
돌아가게 됩니다
다시 발을 들여놓으면
두 번째 기회를 얻게 됩니다
지금 이 기능은
타임머신이 아닙니다
긴 함수의 중간에 있고
중간 작업을 정말 많이 수행했다면
예를 들어서
이 현재 클래스의 상태를
수정하는 것 말이죠
그러면 프레임을 드롭해도
실행 취소가 되지 않습니다
그건 장애 요인이 아닙니다
알아 두어야 할 사항이죠
그럼에도 불구하고 이 기능은
여러 번 저를 살렸습니다
이제 여기 아래 변수 창을
보시죠
이건 아이템 클래스입니다
이 특정 아이템 인스턴스는
ID10231인데요
화면에 보이다시피
이미 몇 개의 아이템이 있죠?
이 특정 아이템의
수명 주기를
따라가보려고 합니다
과거에는
종이 조각에
10231을 적었습니다
하지만 그건 오류가 발생하기 쉽죠

Portuguese: 
em vez disso, clique com o botão direito,
marque o objeto.
e ele pedirá um nome.
Vou ser criativo
e chamá-lo de meu item.
Você verá imediatamente
que em todo lugar
que aparecer
nas janelas de depuração
ele terá um nome.
Agora minha parte favorita,
se eu vier aqui
em um método aleatório.
Ah, você sabia que pode clicar
no espaçamento de linha
e irá diretamente para lá?
Agora estou no método de renderização.
E minha instância de item,
claro, não está no escopo.
O que eu poderia fazer
é ir até a janela Assistir.
E digitar o meu nome,
meu item
seguido pelo nome
de depuração sublinhado.
Mas não é preciso
se lembrar disso
pois é preenchido automaticamente.
Em qualquer lugar no app,
posso seguir a instância única
para ver o que o estado dele
está fazendo.
Isso é muito eficiente
se combinado com
os pontos de parada
de que falamos antes.
E essa linha é
responsável pela renderização
de todos esses items.
O que farei é
definir um ponto na linha
e clicar nele com o botão direito.
Definirei minha condição
como item
igual a meu marcador item.debug.

Chinese: 
它会向你请求标签
下面我要充满原创精神地把它命名为“我的项目”
大家立刻就可以注意到
无论它出现在这些调试窗口中的哪个位置
它都是已经被加上标签的
我最喜欢的部分是 
如果我使用随机方法
顺便说一句 你知道吗 只需点击代码行这里
就可以直接定位过去了
下面我进入到了随机方法
当然 我的项目实例不在范围内
我可以来到 Watches 窗口
输入我的标签 myItem_DebugLable
不过 你不用担心如何记住它
因为它会自动完成
我可以在应用内的任何地方
跟随单一实例 来观察它的状态在做什么
如果你把它和之前我们讲过的条件断点结合起来的话
效果其实是相当强大的
比如这行负责渲染所有项目
所以 我要在代码行中设置断点 右击它
再把我的状态设置成 item == myItem_DebugLabel

English: 
Instead, just right-click
on it, mark the object.
It asks you for a label.
I'm going to creatively
call it my item.
And immediately you'll
notice that anywhere
that this appears in any
of these debugging windows,
it's labeled.
Now my favorite part of
this is, if I come over here
to a random method--
oh by the way, did you know you
can click on the line gutter
and you'll run to that directly?
So now I'm in the render method.
And my item instance, of
course, is not in scope.
What I could do is come
over to the Watches window.
And I can type my
label, my item,
followed by underscore
debug label.
But you don't have to
worry about remembering it
because it auto-completes
it for you.
And anywhere in my
app, I can actually
follow my single instance to
see what it's state is doing.
This is actually
very powerful when
combined with conditional
breakpoints, which
we talked about earlier.
So this line here is
responsible for rendering
all of these items.
So what I'm going
to do is I'm going
to set a breakpoint on the line,
I'm going to right-click on it.
And I'm going to set
my condition to item
equals my item.debug label.

Spanish: 
En cambio, hago clic derecho en él
y marco el objeto.
Pedirá una etiqueta.
Creativamente la llamaré
"Mi elemento".
De inmediato notarán 
que en cualquier lugar
que aparece esto, en cualquier
ventana de depuración,
aparece la etiqueta.
Mi parte favorita es si voy aquí
a métodos aleatorios.
Por cierto, ¿sabían que si hacen clic
en la canaleta de la línea
irán allí directamente?
Ahora estoy en el método render.
Y la instancia "Mi elemento", 
por supuesto, no esta incluida.
Lo que puedo hacer es ir
a la ventana Watches.
Y escribo mi etiqueta,
"Mi elemento",
seguido de guion bajo
y una etiqueta de depuración.
No tienen que recordarlo
porque se autocompleta.
Y en cualquier lugar de la app,
puedo seguir
mi instancia única para saber
en qué estado se encuentra.
Esto es muy poderoso cuando se combina
con los puntos de revisión condicionales
que mencionamos antes.
Esta línea es responsable
de renderizar todos estos elementos.
Así que voy agregar
un punto de revisión en la línea
y haré clic derecho en ella.
Y voy a configurar mi condición
a item = my item.debug.

Indonesian: 
Jadi, klik kanan item,
pilih Mark Object.
Lalu, akan meminta label.
Saya akan memberinya nama myItem.
Dan Anda langsung sadar
bahwa di mana pun item muncul
di jendela proses debug, sudah ada label.
Sekarang, bagian favorit saya,
yaitu jika saya ke metode random--
tahukah Anda jika mengklik bagian tepi
Anda bisa langsung menjalankannya?
Kini saya di metode render.
Dan instance item saya
tentu saja tidak dalam jangkauan.
Jadi, saya akan membuka jendela Watches.
Lalu, saya bisa mengetik
myItem_DebugLabel.
Tapi, Anda tidak perlu menghafalnya
karena akan melengkapi secara otomatis.
Dan di aplikasi mana pun,
saya bisa melihat status instance-nya.
Ini sangat berguna jika dikombinasikan
dengan breakpoint bersyarat,
yang sebelumnya dibahas.
Jadi, baris ini bertanggung jawab
untuk merender semua item ini.
Jadi, saya akan menetapkan
breakpoint pada garis, lalu klik kanan.
Dan saya tetapkan kondisinya
ke item sama dengan myItem_DebugLabel.

Korean: 
그 대신 마우스 오른쪽 버튼으로
클릭해 객체를 표시합니다
라벨을 지정해야죠
창의적으로 저는
내 아이템이라고 할게요
이 디버깅 창의
아무 곳에나 나타나는 것이
즉시 확인됩니다
라벨이 지정되었죠
마음에 드는 부분은
여기 무작위
메서드로 오시면
아, 그런데 라인 거터를 클릭해서
바로 실행할 수 있다는 거 아셨나요?
그래서 이제
저는 렌더 메서드에 있습니다
그리고 아이템 인스턴스는
물론 범위 내에 없죠
제가 할 수 있는 건
보기 창으로 가는 거였습니다
그리고 제 라벨인
내 아이템을 입력하면 되죠
그 뒤에 밑줄을 긋고
디버그 라벨을 입력합니다
기억 못할까 봐 걱정하지
않아도 됩니다
자동 완성을 해주거든요
내 앱 어디서든
실제로 단일 인스턴스를 따라
현재 상태를
확인할 수 있습니다
이 기능은 이전에 말한
조건부 중단점과 결합하면
굉장히 유용한 기능이 됩니다
여기 이 라인은
모든 아이템의
렌더링을 담당하죠
이제 해당 라인에
중단점을 설정하고
마우스 오른쪽 버튼으로
클릭해보겠습니다
내 조건을
item.debug 라벨과
동일하게 설정하겠습니다

Japanese: 
代わりに右クリックして
[Mark Object]をクリックすると
ラベルを入力できます
“my item”と名前を付けます
どこにいてもすぐに分かりますね
どのデバッグウィンドウにも表示されます
ラベル付けされています
私が一番気に入っているのは
任意のメソッドにカーソルを合わせると
ところで
ラインガターをクリックすると
直接ジャンプできることを知っていましたか？
レンダリングメソッドにいますね
もちろんmy itemインスタンスは
スコープ内にありません
[Watches]ウィンドウに移動し
ラベル“my item”を入力します
下線付きのデバッグラベルが続きます
しかし思い出す
必要はありません
自動入力されるからです
アプリのどこにいても
特定のインスタンスを追跡し
その状態がどうなっているかを
確認できます
これを前に話した条件ブレークポイントと
組み合わせるとかなり使えます
この行でこれらのアイテムの
レンダリングを行います
この行にブレークポイントを設定して
右クリックします
条件を
“item == my item_debugLabel”
に設定します

Korean: 
거기에서 실행하면
제가 여기 특정 아이템을
강조표시한 것을 보실 수 있습니다
다른 인스턴스의 중단점을
넘길 필요가 없었죠
여기, 그리고
중단점에 있는 이상
이 식 계산 버튼을 클릭하여
식 계산 대화 상자를
표시할 수 있습니다
때로는 단일 라인 모드로
여기에 열립니다
저는 여러 라인으로
확장하는 것이 좋더라고요
보기 창과 같이
어떤 식이든 여기에 입력할 수 있죠
그럼 item.image를 하겠습니다
그런 다음 '계산' 버튼을 누릅니다
아래의 이 객체 탐색기에서
객체를 탐색할 수 있습니다
여기에서 더 풍부한 식을
수행할 수도 있습니다
변수를 생성할 수 있는 것처럼
if 문을 사용할 수도 있습니다
그럼 넘어가서
무작위 식을 넣어
작동되는지
확인해보겠습니다
됐습니다
코드가 단계를 밟으면서
시간이 지남에 따라
값이 변화되는 것을
확인하는 데 이 변수 및 보기 창이
유용한 경우가 있습니다
하지만 앱의 현재 상태를
볼 수 있는

Japanese: 
そこで実行すると
確かに
特定のアイテムを強調表示していますね
他のインスタンスの
ブレークポイントを
ステップオーバーする
必要はありませんでした
ここにいるときに
ブレークポイントにいるときに
この[Evaluate Expression]ボタンを
クリックすると
[Evaluate Expression]ダイアログが
表示されます
単一行モードで開くことがあります
広げて複数行にしたいと思います
[Watches]ウィンドウのように
任意の式を入力できます
“item.image”と入力してみます
[Evaluate]ボタンを押すと
このオブジェクトブラウザで
オブジェクトを参照できます
より高度な式を実行することもできます
変数を作成したり
ifステートメントを使用したりできます
もう少しやらせてください
これが任意の式で機能するか
確かめてみましょう
どうでしょう
[Variable]や[Watch]ウィンドウは
コードをステップスルーする際
時間の経過とともに
値の変化をウォッチ
したいときに非常に役立ちます
[Evaluate Expression]ダイアログは

English: 
And when I run
there, sure enough,
you can see that I am
actually highlighting
my particular item.
And I didn't have to
step over the breakpoints
of the other instances.
Now, as long as
we're here and we're
at a breakpoint,
what you can do is,
you can click on this
Evaluate Expression button
to bring up the Evaluate
Expression dialog.
It sometimes opens up
here in single-line mode.
So I like to expand
it to multiple lines.
Like the Watches window, you
can type in any expression here.
So let's just do item.image.
And then hit the
evaluate button and you
can browse the object in
this Object Browser below.
But you can do richer
expressions in here as well.
Like you can create variables,
you can use if statements.
And let me just go
ahead and verify
that this is working just by
putting in a random expression.
And there you go.
So sometimes the variable
and Watch windows
are great for when
you're trying to watch
values change over time as
you step through the code.
But the evaluate
expression dialog

Chinese: 
运行一下 很好
大家可以看到 我高亮显示了我指定的项目
不必踏过其他实例的断点
抵达断点之后 你就可以
点击这个 Evaluate Expression 按钮
呼出 Evaluate Expression 界面
它有时会在这里以单行模式打开
我想把它扩展为多行
正如 Watches 窗口
你可以在这里输入任何表达式
所以 我们就输入 item.image
然后点击 Evaluate 按钮
然后你就可以在下面的 Object Browser 中浏览对象了
不过 你也可以在这里进行更加丰富的表达
你可以创建变量 使用 if 声明
让我来加入一个随机表达式
验证一下这个能不能用
就这样
有时 变量和 Watch 窗口非常适合
在你步进代码的时候 用来观察数值随时间更改的情况
Evaluate Expression 对话

Portuguese: 
E quando eu passar ali,
com certeza
poderei ver
que estou de fato destacando
meu item em particular.
E eu não tive que passar por cima
dos pontos
de outras instâncias.
Agora, enquanto estamos aqui
em um ponto de parada,
podemos clicar
no botão Avaliar expressão
para exibir a caixa de diálogo
Avaliar expressão.
Às vezes, ela é aberta
no modo de linha única.
Então, eu gosto de expandi-la
para várias linhas.
Como em Assistir,
pode-se digitar qualquer expressão.
Vamos fazer apenas item.image.
E clicar no botão avaliar
para procurar o objeto
neste Navegador de objetos abaixo.
Mas você pode fazer
expressões melhores.
Como criar variáveis,
usar instruções "se".
Vou seguir e ver
se funciona
comr uma expressão aleatória.
Feito.
Às vezes,
as janelas Variável e Assistir
são ótimas para quando
tentamos ver os valores mudarem
à medida que avançam no código.
Mas a caixa de diálogo
"Avaliar expressão"

Indonesian: 
Dan saat dijalankan, tentu saja,
bisa dilihat saya menandai item saya.
Dan saya tidak perlu
melewati breakpoint dari instance lain.
Sekarang, selama kita
di sini dan di breakpoint,
Anda bisa mengklik
tombol Evaluate Expression
untuk memunculkan
dialog Evaluate Expression.
Terkadang akan terbuka
dalam mode satu baris.
Saya suka meluaskannya
menjadi beberapa baris.
Seperti di jendela Watches
Anda bisa mengetik ekspresi apa pun.
Ketikkan saja item.image.
Lalu, tekan tombol Evaluate
dan Anda bisa mencarinya
melalui Object Browser di bawah.
Tapi, Anda juga bisa
mengetikkan ekspresi yang lebih kaya.
Seperti membuat variabel,
Anda bisa menggunakan statement if.
Dan izinkan saya memastikan
bahwa ini bekerja
hanya dengan menaruh ekspresi acak.
Begitulah.
Variabel dan jendela Watches
terkadang berguna
saat memantau perubahan nilai dari
waktu ke waktu saat Anda menangani kode.

Spanish: 
Y cuando lo ejecuto, pueden ver 
que estoy resaltando mi elemento.
Y no tuve que pasar 
sobre los puntos de revisión
de otras instancias.
Mientras estemos aquí y estemos
en un punto de revisión,
lo que pueden hacer es
presionar en el botón
Evaluate Expression (Evaluar Expresión)
para traer el mensaje de diálogo de
Evaluate Expression.
A veces se abre en modo
de línea única.
A mí me gusta expandirlo a
líneas múltiples.
Como en la ventana Watches,
pueden escribir cualquier expresión aquí.
Escribamos item.image.
Presionamos el botón de evaluar
y podemos buscar el objeto en este
navegador de abajo.
También pueden hacer expresiones
enriquecidas aquí.
Pueden crear variables,
pueden crear instrucciones "if".
Y déjenme adelantarme
y verificar
que esto funciona
con una expresión aleatoria.
Ahí lo tienen.
A veces las ventanas de
Variables y Watch
son geniales cuando intentan
ver cómo los valores
cambian en el tiempo
mientras recorren el código.
Pero el diálogo de evaluar expresión

Spanish: 
es realmente grandioso si quieren
una inspección en vivo
en el que pueden ver el
estado actual de su aplicación.
Y quizás no están seguros
de lo que quieren depurar,
pero pueden sumergirse
haciendo estas evaluaciones.
Voy a volver a un punto de revisión
que Justin agregó anteriormente.
Si lo recuerdan, este es el código
responsable de chocar con un postre.
Y hay una condición allí.
Como pueden ver es:
player.health = 1.
Voy a habilitarla.
Será algo difícil de ver en este caso.
Voy a tratar de chocarme
con algunos postres.
Miren si pueden notar que
hay una pequeña inestabilidad,
incluso cuando no se llega
al punto de revisión.
Es difícil de ver, 
pero aquí en el tercero.
Incluso en este caso, si no pudieron verlo
cada vez que tienen un
punto de revisión condicional,
incluso si no lo detienen, el depurador
aún tiene que hacer el trabajo
para evaluar la expresión.
Y si esto se encontrara en el
medio de un bucle ajustado,
esto sería realmente notorio.
No hay demasiado
que se pueda hacer en estos casos
si esto está afectando

Portuguese: 
é ótima para
uma inspeção ao vivo
que possa mostrar
o estado atual do app.
E talvez não tenha certeza
do que deseja depurar,
mas pode se aprofundar
fazendo essas avaliações.
Eu vou voltar para
um ponto de parada
que Justin fez antes.
Lembram,
esse é o código responsável
pela colisão com um doce.
E há uma condição nele.
Como pode ver,
é player.health igual a um.
Irei ativá-lo agora.
Será meio difícil de ver
nesse caso.
Mas tentarei bater
em alguns doces.
Veja se consegue perceber
que há uma leve ondulação
mesmo quando
não atinge o ponto.
Vou seguir em frente
e fica um pouco difícil de ver
mas agora aqui no terceiro.
Mesmo nesse caso,
em que quase não conseguimos ver
sempre que houver
um ponto condicional
mesmo que não parar,
o depurador ainda terá que trabalhar
para avaliar a expressão.
E se estiver no meio
de um loop bem apertado
pode ficar bastante perceptível.
Infelizmente,
não há o que fazer

Japanese: 
アプリの現在の状態を確認できる
非常に有用な
ライブインスペクションシェルです
何をデバッグしたいか
よく分からないときでも
これらの評価を行なって
まず始めてみましょう
ジャスティンが前に設定した
ブレークポイントに
戻ります
これはデザートにヒットする
コードです
条件があります
“player.health == 1”を
有効にします
これは確認するのが
少し難しいです
いくつかのデザートに
ヒットしてみたいと思います
分かるでしょうか
ブレークポイントにヒットしないときでも
少しずつ変化しています
やってみます
若干見つけにくいです
今３つめにヒットしました
確認できない場合でも
条件ブレークポイントでは
停止しない場合でも
デバッガはその式を
評価する作業が必要です
非常に密なループ内の場合
分かりやすいかもしれません
残念ながら
デバッグエクスペリエンスに大きく

English: 
is really great if you
just want a live inspection
shell that you can see the
current state of your app.
And maybe you're not really
sure what you want to debug,
but you can you dive in by
doing these evaluations.
I'm going to jump
back to a breakpoint
that Justin set earlier.
If you remember,
this is the code
responsible for
colliding with a desert.
And there's a condition on it.
As you can see, it's
player.health equals one.
I'm going to enable it.
Now, this is going to
be a little bit hard
to see in this case.
But I'm going to try
running into some desserts.
And see if you can notice,
there's a very slight stutter,
even when the
breakpoint doesn't hit.
Let me go ahead and it's
a little bit hard to see,
but now here on the third one.
So even in this case, if
you couldn't quite see it,
whenever you have a
conditional breakpoint,
even if you don't
stop, the debugger
still has to do the work to
evaluate that expression.
And if this was in the middle
of a really tight loop,
this might become
really noticeable.
Unfortunately,
there's not really
much you could do in that
case if this is actually

Indonesian: 
Tapi, dialog Evaluate Expression
akan sangat berguna jika Anda ingin
shell inspeksi live agar Anda
bisa melihat status aplikasi saat ini.
Jika tidak yakin
apa yang akan di-debug,
Anda bisa menentukannya
dengan melakukan evaluasi ini.
Saya akan kembali ke breakpoint
yang ditetapkan Justin sebelumnya.
Jika masih ingat,
kode ini bertanggung jawab
saat kita mengenai camilan.
Dan ada syaratnya.
Seperti yang terlihat,
player.health sama dengan 1.
Akan saya aktifkan.
Ini akan sedikit sulit untuk dilihat.
Tapi, saya akan mencoba
mengenai beberapa camilan.
Dan melihat apakah Anda
bisa menyadari bahwa ada sedikit sendatan,
bahkan saat
tidak terkena breakpoint.
Izinkan saya melanjutkannya
karena sulit terlihat,
dan sudah kena yang ketiga.
Bahkan dalam hal ini,
jika Anda tidak terlalu bisa melihatnya,
kapan pun
Anda punya breakpoint bersyarat,
walaupun tidak berhenti,
debugger masih harus
mengevaluasi ekspresi tersebut.
Tapi jika ada di tengah loop
yang sangat padat,
sendatan mungkin
bisa terlihat dengan jelas.
Namun, tidak banyak
yang bisa Anda lakukan

Chinese: 
则非常适合用来充当实时检测器
观察应用的当前状态
也许你不是很确定要调试些什么
不过你可以通过这些评估来深入了解一下
下面讲回 Justin 刚才设置好的断点
如果大家还记得的话 这些代码的用途是
和甜点对撞 它附加了一个条件
大家可以看到 也就是 player.health ==1
我来启用它
在本例中 这不太好发现
但是我想撞到其他的甜点
不知大家是否能发现
这里有一个很轻微的卡顿
即使在断点并未命中的时候也是如此
看清它不是很容易
现在来看看第三个
即使在本例中 如果你看不清楚
无论何时 当你拥有一个条件断点的时候
即使你不停止 调试器还是需要继续工作
来评估那个表达式
如果这一切都发生在一个很紧密的循环中
结果可能会比较显眼
不幸的是 如果这种情况严重影响了你的调试体验
你也无法改变它

Korean: 
라이브 검사 셸만 원할 경우에는
식 계산 대화 상자가
적합합니다
디버그하려는 항목이
뭔지 잘 모를 수 있지만
이 계산을 수행하여
그쪽으로 이동할 수 있죠
그럼 저스틴이 설정한 중단점으로
다시 돌아가보겠습니다
기억하실지 모르겠지만
이 코드는
디저트와의 충돌을 담당합니다
여기에는 조건이 있습니다
보시다시피
player.health는 1입니다
활성화해보죠
이 경우에는
보기가 조금
힘든데요
몇 가지 디저트와
만나도록 해보겠습니다
아주 약간 버벅거리는 게
확인되네요
중단점을 만나지
않았는데도 말이죠
그럼 계속해볼게요
약간 잘 안 보이는데
이제 여기 세 번째입니다
이 경우에서도
잘 보이지 않으면
조건부 중단점이
발생할 때마다
여러분이 멈추지 않아도
디버거는 계속
해당 식을 계산해야 합니다
이 작업이 정말 빠듯한
루프 가운데에 있었으면
더 확실히 눈에 띄었을 겁니다
안타깝게도
이게 실제로 디버깅 경험에
영향을 주는 경우에는

Spanish: 
su experiencia de depuración.
Lo que deben hacer es
escribir su expresión explícita.
Voy a poner un
[? no op ?] aquí
así puedo enganchar mi punto de revisión.
Hasta aquí hice la versión de código
del punto de revisión condicional 
que estaba aquí
lo que a veces tengo que hacer
por rendimiento.
Aquí es donde quizás deban reiniciar
la aplicación y volver a depurarla.
Pero en vez de eso, usaremos 
la función de aplicar cambios
que está disponible en todos 
los dispositivos con al menos Android 8.0
Esto aplicará el arreglo 
que hice en mi código.
Y quiero que vean con atención
la ventana Frames, porque ahora
dice obsoleta.
Lo que paso es que estaba 
en esta versión vieja
del método Update.
Y pasamos una nueva versión
con mi nuevo código adentro.
Pero el depurador
sigue en la versión vieja.
Lo que voy a hacer es utilizar la función
Drop Frame que mecionamos antes.
Voy a salir de la versión vieja 
e ingresaré a la nueva.

English: 
really affecting your
debugging experience.
So what you just have to do
is type the expression out
explicitly.
I'm just going to put
a [? no op ?] here so I
could hook my breakpoint on it.
At this point, I've
done the code version
of what the conditional
breakpoint was here,
which I sometimes have
to do for performance.
This is a point where you might
decide to restart your app
and re-hit the Debug button.
But instead, let's go ahead
and use Apply Changes, which
is available in all Android
devices at least running 8.0.
Now, what this is
going to do is,
it's going to apply
my code patch over.
And I want to draw
your attention
here to the Frames window
because it now says Obsolete.
So what's happened
is, I used to be
in this old version
of the Update method.
And we've pushed over this new
version with my new code in it.
But that being
said, the debugger
is still stuck in the old one.
So what I'm going to do is,
I'm going to use the Drop Frame
feature we talked before.
I'm going to go out of the old
and step back into the new.
So here I verified
that, in fact,

Japanese: 
影響するケースでは
できることはあまりありません
まずは
式を明示的に入力します
ここに入力し
ブレークポイントを設定します
ここではコードバージョン
を確認しました
条件ブレークポイントは
ここです
パフォーマンスのためにときどき実行します
ここでアプリを再開するか
[Debug]ボタンをもう一度押すか
判断できる場所です
その代わりに
[Apply Changes]を使用してみましょう
これは8.0以上のAndroidデバイスであれば
利用できます
ここで私のコードパッチを
適用したいと思います
注目していただきたいのが
[Frames]ウィンドウです
古いと言っています
つまり
古いバージョンのUpdateメソッドです
新しいコードで
新しいバージョンを押しのけています
デバッガは古いバージョンの
ままです
ここで以前にも話した
[Drop Frame]を使用します
古いバージョンから出て
新しいバージョンに戻ります
ここで
コードがパッチされたことを確認しました

Portuguese: 
se isso está realmente
afetando a depuração.
Então, o que precisa fazer
é digitar a expressão
explicitamente.
Só irei colocar
um "no op" aqui
e ligarei o ponto de parada nele.
Até agora,
fiz a versão do código
do que era
o ponto de parada condicional aqui
o que às vezes é preciso
para ter desempenho.
Este é o momento
para reiniciar o app
e clicar novamente no botão Depurar.
Mas, em vez disso,
vamos usar o Aplicar modificações
disponível em todos os Android
com no mínimo versão 8.0.
Isso fará com que
o código de reorganização seja aplicado
E quero chamar sua atenção
para a janela Frames
que agora diz Obsoleto.
O que aconteceu foi
que antes eu estava
nessa versão antiga
do método Atualizar.
E lançamos uma nova versão
com meu novo código.
E o depurador
ainda está preso no antigo.
Eu usarei o recurso drop frame
de que falamos antes.
Vou sair do antigo
e voltar para o novo.
Assim pude perceber que,
de fato

Indonesian: 
jika hal ini sangat mempengaruhi
pengalaman proses debug.
Jadi, Anda hanya perlu
mengetik ekspresi secara eksplisit.
Saya akan menaruh no op di sini
agar dapat mengaitkan breakpoint.
Kini, saya sudah
menyelesaikan versi kode
dari breakpoint bersyarat
yang ada di sini,
yang terkadang
harus dilakukan untuk performa.
Di titik ini,
Anda sebaiknya memulai ulang aplikasi
dan menekan tombol Debug kembali.
Sebagai gantinya,
mari kita lakukan Apply Changes,
yang tersedia di semua
perangkat dengan Android setidaknya 8.0.
Sekarang,
ini akan menerapkan patch kode saya.
Dan saya minta
Anda fokus ke jendela Frames
karena sekarang tertulis Obsolete.
Jadi, saya sebelumnya
ada di metode Update versi lama.
Dan kita telah berpindah
ke versi baru dengan kode yang baru.
Dengan begitu,
debugger masih berada di versi lama.
Jadi, saya akan menggunakan
fitur Drop Frame yang sebelumnya.
Saya akan keluar dari yang
lama, lalu pindah ke yang baru.
Jadi, di sini saya memastikan

Korean: 
할 수 있는 일이
그리 많지 않습니다
그냥 식을 명확하게
입력하는 방법 밖에는
없습니다
[? no op ?]를
여기에 입력하겠습니다
중단점을 여기에
걸 수 있도록 말이죠
이때 여기 있던 조건부 중단점의
코드 버전을 완료했습니다
성능을 위해
이 작업을 해야 하는 경우가 있죠
이때 앱을 다시 시작하고
'디버그' 버튼을 다시
눌러야 할 수 있습니다
하지만 대신에 '변경내용 적용'을
사용해보겠습니다
이는 최소 8.0을 실행하는 모든
Android 장치에서 사용할 수 있습니다
이제 어떻게 되냐면
코드 패치가 적용됩니다
여기서 프레임 창을
봐주셨으면 하는데요
이제 사용되지 않음으로
표시되기 때문입니다
그러니까 업데이트 메서드의
이전 버전에 있었다는 것입니다
이 새 코드가 있는 새 버전을
여기에 넣었습니다
하지만 디버거가 아직도
오래된 버전에
막혀 있습니다
그래서 이전에 얘기한
드롭 프레임 기능을
사용하려고 합니다
오래된 버전에서 벗어나서
새로운 버전으로 다시 돌아가보죠
사실 여기에서는
중단점에 도달했기 때문에

Chinese: 
所以 你需要再写出一些表达式
我在这里输入一个 no-op
方便把断点挂在上面
此时 我就完成了与条件断点相对应的代码版本
为了应用性能表现 我要时常添加条件断点
这时 你可能就要决定重启应用 重新进行调试
并重新按下 Debug 按钮了
然而 让我们来使用 Apply Changes
它在所有运行 Android 8.0+ 的设备上均可使用
它会应用我的代码补丁
请大家注意这里的 Frames 窗口
因为现在它显示的文字是 Obsolete
我曾经使用的是旧版的 Update 方法
我们推送了这个含新代码的新版本
但是尽管如此 调试器还在用着旧版本
所以 我要使用之前提到过的丢帧功能
跨出旧版本 回到新版本

Japanese: 
ブレークポイントにヒットしたからです
これらのボタンにも注目して
いただきたいと思います
これらは両方とも
[Apply Changes]です
最初のボタンは
ただコードをパッチします
２つ目のボタンは
同じことを実行しますが
その後にアクティビティの
再開も実行します
これはレイアウトリソースを
修正した場合に非常に役立ちます
デバッグしようとしているコードが
onCreateメソッド内にいる
場合などにも役立ちます
最後に
これらのヒントやコツを実践したとしても
バグがなくならず
それらを公開してしまい
バグレポートを受け取るでしょう
コールスタックを含むバグレポートを
受け取った場合
ここに膨大なテキストがあります
コピーしてAndroid Studioの
ここに戻ります
[Analyze...]をクリックします
非常に小さいですが
[Analyze Stack Trace...]をクリックします
クリップボードに貼り付けた値が
表示されます
[OK]をクリックします
コールスタックが下の
コンソールに表示されます
注釈が付いています
このおかげで
これが対象のコードベースなのか
注意を払わなくても良いコードなのか

Portuguese: 
o código foi corrigido
porque atingi o ponto de parada.
Também quero mostrar
este outro botão acima
Os dois botões são para
Aplicar modificações.
O primeiro é responsável
por corrigir apenas o código.
E o segundo faz a mesma coisa
mas reinicia
a atividade depois.
Isso pode ser muito útil
se modificou alguns recursos de layout
ou se o código
que está tentando depurar
por exemplo, encontra-se
em um método onCreate.
E, finalmente, apesar de todas
essas dicas e truques
você ainda criará
alguns bugs
irá publicá-los
e receberá
relatórios de bugs.
Portanto, se receber um relatório de bugs
com uma pilha de chamadas
ele se parece
com esse monte de texto aqui.
Copie e volte para o Android Studio
e clique em Analisar.
Fica bem pequeno,
mas analise a pilha de execução.
E verá que ele já encontrou o valor
na área de transferência.
É só clicar em OK.
Ele vai colocar
minha pilha de chamadas
no console abaixo
totalmente preenchida.
Rapidamente, vejo
que essa é a base do código,
em comparação com o código

Spanish: 
Aquí verifico que el código se arregló
porque llegué a un punto de revisión.
Quiero que presten atención 
a este botón aquí arriba.
Ambos botones son para aplicar cambios.
El primero, se encarga 
de arreglar solo el código.
El segundo, hace lo mismo
pero también reinicia la actividad luego.
Esto puede ser muy útil si
modifican recursos de diseño
o si el código que intentan depurar
está, por ejemplo, en un método Create.
Finalmente, a pesar de todos
estos consejos y trucos
igual van a escribir algunos errores
los van a publicar
y seguirán recibiendo reportes de errores.
Si reciben un reporte de error
con una pila de llamadas
aquí aparecerá un montón de texto.
Cópienlo, vuelvan a Android Studio
y hagan clic en Analyze.
Es muy pequeño,
Analyze, Analyze Stack Trace.
Y pueden ver que ya
encontró el valor que estaba
en el portapapeles.
Todo lo que debo hacer es, clic OK.
Va a llevar mi pila de llamadas
a la consola de abajo
con anotaciones completas.
Rápidamente puedo ver que esto
es mi código base contra este código

English: 
that the code has been patched
because I hit the breakpoint.
I also want to call everyone's
attention to this other button
up here.
So both of these buttons
are Apply Changes.
This first one is responsible
for patching just code.
The second one does
the same thing,
but it also restarts
the activity afterwards.
This can be really useful if you
modified some layout resources,
or if the code that
you're trying to debug
is, for example, in
an onCreate method.
And finally, despite all
of these tips and tricks,
you are going to
still write some bugs,
you're still going
to publish them,
and you're still going
to get bug reports.
So if you ever get a bug report
that has a call stack in it,
here it just looks
a bunch of text.
Just copy it, come back
over here to Android Studio,
click on Analyze.
It's really tiny, but
analyze, analyze stack trace.
And you'll see that it
already found the value that
was in the clipboard.
All I have to do is hit OK.
It's going to drop my call
stack into the console
below fully annotated.
So very quickly I
can see that this
is my code base versus this
is code that I might not

Korean: 
코드가 패치되었음이
확인되었습니다
또한 여러분 모두
여기 위에 다른 버튼을
주목해 주세요
이러한 버튼 모두가
변경내용 적용입니다
이 첫 번째 버튼은
코드 패칭만 담당하고
두 번째는
같은 일을 하지만
이후에 활성화를
다시 시작하기도 합니다
레이아웃 리소스를 일부
변경하거나
예를 들어 onCreate 메서드에서
코드를 디버그하려는 경우
정말 유용합니다
그리고 마지막으로
이러한 모든 팁이 있긴 하지만
그래도 몇 가지 버그를
작성하고
게시하고
버그 보고서를
받게 될 것입니다
콜 스택이 포함된
버그 보고서를 받은 적이 있다면
긴 텍스트로만 보일 겁니다
복사한 다음 
Android 스튜디오로 돌아와
'분석'을 클릭합니다
정말 작지만
스택 추적을 분석하세요
그러면 클립보드에 있던
값이 이미 찾아진 것을
확인하게 됩니다
'확인'만 누르면 됩니다
내 호출 스택을 아래에
완전히 주석이 달린
콘솔에 드롭할 겁니다
그러면 정말 빠르게
내 코드 베이스와 
신경 쓰지 않아도 되는 코드를

Chinese: 
这里的代码已经完成了修补 因为我撞到了断点
我还想请大家注意这个按钮
这些按钮都是“应用更改”的意思
第一个按钮的功能是为代码做修补
第二个按钮的功能相同 
但它还会在打完补丁后重启活动
如果你修改了布局资源的话
或是你试图调试的代码位于 比如说 onCreate 方法内
那么这个功能是相当有用的
最后 尽管有了这么多的小技巧
但 bug 总还是难免会出现 并且被发布的
你也还是会得到 bug 报告
如果你收到了一个包含调用栈的 bug 报告
它的外观就是一堆文本
只要复制它
回到 Android Studio 点击 Analyze 
字很小 然后点击 analyze stack trace
你会发现 它已经找到了剪贴板中的内容
我们只需点击 OK
它会对我的调用栈进行全面注解
然后再把它放在下面的控制台里
很快 我可以看到 这是我的代码
而这大概是我无需关心的代码

Indonesian: 
bahwa kode telah di-patch
karena mengenai breakpoint.
Saya juga ingin Anda
memperhatikan tombol di atas sini.
Jadi, kedua tombol ini
adalah Apply Changes.
Yang pertama bertugas hanya
untuk melakukan patching kode.
Yang kedua mempunyai fungsi sama,
tapi juga
memulai ulang aktivitas setelahnya.
Ini akan sangat berguna
jika Anda mengubah resource tata letak
atau jika kode yang ingin di-debug
misalnya, dalam metode onCreate.
Akhirnya, terlepas dari
semua tips dan trik yang ada,
Anda tetap perlu
menuliskan bug,
lalu memublikasikannya,
dan masih mendapatkan laporan bug.
Jadi, jika Anda mendapatkan laporan
bug yang mempunyai stack panggilan,
di sini tampilannya seperti teks saja.
Salin teks tersebut, kembali 
ke Android Studio, lalu klik Analyze.
Tulisannya sangat kecil,
Analyze stack trace.
Dan bisa dilihat bahwa
nilai pada papan klip sudah tercantum.
Saya hanya mengklik OK.
Lalu, stack panggilan
akan diletakkan di konsol bagian bawah
dan dianotasikan sepenuhnya.
Jadi, saya bisa langsung melihat
perbandingan basis kode saya

English: 
have to pay attention to.
And of course, you
can click on the links
to quickly jump
through your code base.
[APPLAUSE]
That concludes the demo.
JUSTIN NIETO: So we talked about
a lot of different tips today.
And as we mentioned
before, there
were still more that we
couldn't fit into this talk.
So if you are watching a
recording on this video,
please check the description.
And we'll try to include
some helpful links there.
If you are here in person,
come talk to us in the Sandbox.
And we'd love to expand
on some of these more.
If we forgot your favorite
debugging tip, please tell us.
Leave it in a comment
and tell us in person.
Because we'd love
to know what it
is to incorporate
in our own workflow.
And with that, thank
you all so much.
[APPLAUSE]

Portuguese: 
que pode não
ser tão importante.
E você pode clicar nos links
para acessar rapidamente
sua base de códigos.
Assim terminamos a demonstração.
Nós demos
muitas dicas importantes hoje.
E como mencionamos antes
há muito mais
que não conseguimos colocar aqui.
Então, se estiver assistindo
a uma gravação deste vídeo
verifique a descrição.
Tentaremos incluir
links úteis nela.
Se estiver aqui,
fale conosco nos bastidores.
Vai ser incrível falar 
mais sobre o assunto.
Se esqueceu a sua dica favorita,
fale com a gente.
Deixe um comentário
ou fale pessoalmente
Queremos saber
o que pode ser adicionado.
E muito obrigado a todos.

Korean: 
비교할 수 있습니다
물론 링크를 클릭하여
빠르게 코드 베이스로
이동할 수도 있죠
[박수]
이것으로 데모를 마치겠습니다
오늘 정말
다양한 팁에 대해 얘기했는데요
앞에서 말했듯이
여기에서 말하지 못한 것도
많이 있습니다
그러니까 이 동영상 녹화본을
보고 계신다면
설명을 확인하세요
유용한 링크를
넣어 놓도록 하겠습니다
여기에 직접 오신 분들은
샌드박스로 직접 오셔서 말씀하시면
기쁜 마음으로
더 자세히 알려드리겠습니다
저희가 잊어버린
팁이 있다면 알려주세요
댓글을 남겨 주시거나
직접 말씀해 주셔도 좋습니다
저희 워크플로에
포함할 사항이 있으면
그게 뭔지
저희도 정말 궁금하거든요
그럼 지금까지
들어주셔서 감사합니다
[박수]

Chinese: 
当然 你还可以通过点击链接
在你的代码库内进行快速跳跃检索
演示到此为止
今天我们分享了很多的小技巧
我们说过 还有很多小技巧我们无法在今天全部分享
所以 如果你正在观看这段视频
请务必查阅视频描述
我们会在其中附加一些有用的链接
如果你亲自来到了这里的会议现场
请前往体验区找我们聊聊
我们很高兴跟大家分享更多这方面的内容
如果我们没讲到你最关注的调试技巧 请务必告诉我们
可以通过评论告诉我们 也可以直接找到我们
我们很乐意聆听你的反馈 
把你关注的调试方法加入到我们的工作流中
谢谢大家

Japanese: 
すぐに見分けられます
もちろん
リンクをクリックすると
コードベースにジャンプします
これでデモを終わります
今日はさまざまなヒントについて
お話ししました
最初にお伝えしたように
この話に含められなかった点が
まだたくさんあります
このビデオを録画でご覧になっている方は
説明もチェックしてください
役立つリンクも含めたいと思っています
こちらに出席されている皆さんは
是非サンドボックスにお越しください
これらのトピックのいくつかを
さらに詳しくご説明したいと思います
聴きたかったデバッグのヒントが
漏れていたらお伝えください
コメントに残して
個人的にお伝えください
私たちのワークフローに
何を組み込むべきか
知りたいです
ありがとうございました

Indonesian: 
dengan kode yang tidak perlu diperhatikan.
Dan Anda tentu bisa mengklik link-nya
untuk langsung membuka basis kode.
Demikian penjelasan demo dari kami.
Jadi, kita sudah membahas
berbagai tips hari ini.
Dan sudah disebutkan sebelumnya,
masih ada banyak hal
yang belum bisa disampaikan.
Jika Anda menonton rekaman video ini,
harap melihat deskripsi.
Kami mencantumkan
beberapa link berguna.
Jika hadir langsung di sini,
Anda bisa menemui kami di Sandbox.
Dengan senang hati kami akan
menjelaskan hal ini lebih lanjut.
Jika tips favorit Anda
belum disebutkan, harap beri tahu kami.
Tulis di kolom komentar
atau bertemu langsung.
Kami ingin mengetahuinya
untuk diterapkan ke alur kerja kami.
Sekian, terima kasih banyak semuanya.

Spanish: 
que quizás no necesite prestarle atención.
Y por supuesto, pueden hacer clic
en los hipervínculos
para saltar a través de su código base.
[APLAUSOS]
Eso concluye la demostración.
Hablamos de muchos
consejos diferentes en el día de hoy.
Y como mencionamos antes,
hay mucho más que no pudimos incluir
en esta charla.
Si están viendo una grabación
de este video,
por favor vean la descripción.
Trataremos de incluir
hipervínculos útiles.
Si están aquí en persona,
pasen a hablar por nuestro puesto.
Nos encantaría expandir más sobre esto.
Si olvidamos su consejo
de depuración favorito, dígannos.
Dejen un comentario,
dígannos en persona.
Porque nos encantaría saber qué es
para incorporarlo en
nuestro flujo de trabajo.
Y de verdad, muchas gracias a todos.
[APLAUSOS]
