<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Arildo Borges Jr on Medium]]></title>
        <description><![CDATA[Stories by Arildo Borges Jr on Medium]]></description>
        <link>https://medium.com/@arildojr?source=rss-cc8bbfc44dc7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*eZrJIuBxqT2zew9STEJSUg.jpeg</url>
            <title>Stories by Arildo Borges Jr on Medium</title>
            <link>https://medium.com/@arildojr?source=rss-cc8bbfc44dc7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:36:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@arildojr/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Iris Mock: Uma maneira mais fácil de modificar/mockar requests no android]]></title>
            <link>https://medium.com/@arildojr/iris-mock-uma-maneira-mais-f%C3%A1cil-de-modificar-mockar-requests-no-android-08979a97a923?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/08979a97a923</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[framework]]></category>
            <category><![CDATA[mock]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Tue, 13 Aug 2024 12:33:49 GMT</pubDate>
            <atom:updated>2024-08-13T12:50:05.419Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDVE8MQgKhAjAse_MRhw0Q.png" /></figure><p>Este artigo é um mix entre a apresentação de uma nova ferramenta que desenvolvi, chamada Iris Mock, que torna a modificação/mock de chamadas de rede mais fáceis no Retrofit, Volley e em qualquer outra lib baseada no OkHttp e um pouco do processo de desenvolvimento e os aprendizados envolvidos.</p><p>Vamos começar conhecendo Iris Mock e como funciona.</p><h4>Apresentando Iris Mock</h4><p>Você, como desenvolvedor android, provavelmente já precisou mockar chamadas de rede. Há diversos motivos para isso, como implementação de testes de UI, backend em desenvolvimento (quem nunca…) e assim por diante. Um dos pontos em comum para qualquer um dos motivos que você possa ter pensado é a necessidade de criar muito código verboso e repetitivo… o famoso boilerplate 🤯.</p><p>Esse é o cenário onde Iris Mock se encaixa perfeitamente. Você não precisa se preocupar em escrever todos esses códigos, pois isso tudo será feito através de uma api DSL bem legal, onde você pode focar apenas nos próprios mocks 😎.</p><h4>Maneira tradicional de mockar chamadas</h4><p>Vamos dar uma olhada na maneira mais comum de mockar chamadas no Retrofit:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/324e9c6f195a4078142fdb943284eda0/href">https://medium.com/media/324e9c6f195a4078142fdb943284eda0/href</a></iframe><p>Você também precisa adicionar esse interceptor ao builder do OkHttpClient :</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d489e1a538de03a359101434e8703ad/href">https://medium.com/media/3d489e1a538de03a359101434e8703ad/href</a></iframe><h4>Usando Iris Mock</h4><p>Agora vamos mockar a mesma chamada do exemplo anterior, usando o Iris Mock. Para isso, adicione o plugin ao build.gradle.kts do app:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fdcedb629a997103a50592d3d26837bb/href">https://medium.com/media/fdcedb629a997103a50592d3d26837bb/href</a></iframe><p>agora você pode começar a implementar os mocks:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2b4d90478d7c7340b3c54f5dcad7e53/href">https://medium.com/media/d2b4d90478d7c7340b3c54f5dcad7e53/href</a></iframe><p>e… isso é tudo. Mas, pera, não estamos esquecendo de adicionar o interceptor ao builder do OkHttpClient ? Bem, a resposta é não. Tudo o que você precisa fazer é anotar sua classe com @IrisMockInterceptor e o Iris Mock cuidará do resto para você, injetando seus interceptors diretamente no bytecode do OkHttpClient .</p><p>Além de ser mais rápido, essa abordagem também possibilita a injeção de interceptors onde normalmente não poderíamos, como bibliotecas de terceiros. Como essas bibliotecas geralmente não expõem suas implementações do OkHttpClient , seria impossível adicionar interceptors lá.</p><p>Mais detalhes na documentação oficial: <a href="https://irismock.arildo.dev/">https://irismock.arildo.dev/</a></p><p><strong>Um exemplo um pouco mais complexo:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/45e4eb5e1d3f7295ff01ca4d3a3bbfbf/href">https://medium.com/media/45e4eb5e1d3f7295ff01ca4d3a3bbfbf/href</a></iframe><h4>Extra: Desenvolvendo um plugin</h4><p>O caminho para desenvolver um plugin envolve diversos aprendizados. No fim, o plugin é bem diferente do que eu pensei inicialmente sobre sua implementação.</p><p>O que eu sempre tive em mente com esse plugin era, de alguma maneira, não ser necessário adicionar os interceptors manualmente em algum lugar. A primeira razão é a simplicidade, obviamente, mas também porque eu queria que fosse possível seu uso mesmo em bibliotecas de terceiros. Nesse ponto, eu já sabia que precisaria fazer algo a nível de bytecode.</p><h4>Approach #1: Adicionar todos os interceptors ao bytecode do OkHttpClient</h4><p>A ideia era simples: criar uma annotation class, IrisMockInterceptor, iterar sobre todas as classes anotadas para pegar suas referências e adicioná-las ao bytecode da OkHttpClient. Para ajudar na injeção, usei a ferramenta <a href="https://asm.ow2.io/">ASM library</a>, que ajuda a manipular o bytecode. Entretanto, essa abordagem não funcionou por uma razão: O ASM visita todas as classes apenas uma vez e não é possível garantir que, quando estiver visitando o bytecode da OkHttpClient , já tenha visitado todas as classes anotadas 🥲.</p><h4>Approach #2: Classe wrapper usando KSP</h4><p>Como é impossível prever quais classes devem ser injetadas, eu tive outra ideia: E se eu gerar uma classe wrapper em build time, contendo a referência de todas as classes anotadas? Isso poderia funcionar, porque dessa maneira, seria possível saber exatamente qual classe deveria ser injetada no bytecode da OkHttpClient , a classe wrapper. Para gerar essa classe, eu decidi usar o <a href="https://kotlinlang.org/docs/ksp-overview.html">KSP</a>, que é até 2x mais rápido que o KAPT.</p><p>E voilà. Funcionou. Mas ainda tinha algo me incomodando. Agora, para usar o Iris Mock, os usuários seriam obrigados a adicionar o plugin do KSP, plugin do Iris Mock, a dependência KSP do Iris Mock e também a dependência runtime do Iris Mock… muita coisa não?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/31def9908f8d037dfd98e7fd5cc1094e/href">https://medium.com/media/31def9908f8d037dfd98e7fd5cc1094e/href</a></iframe><h4>Approach #3: Kotlin Compiler Plugin</h4><p>Decidi remover o KSP e optar por uma solução mais baixo nível. Ao analisar outros plugins, como o próprio KSP e o KAPT, descobri que eles são implementados usando o Kotlin Compiler Plugin (KCP), então decidi seguir o mesmo caminho.</p><p>Claro, como em qualquer solução, existem prós e contras, por exemplo, simplesmente não há documentação sobre o KCP. Centenas e mais centenas de linhas sem qualquer documentação. Passei vários dias (e um pouco de frustração) até encontrar um repositório que mudaria tudo, o repositório do <a href="https://github.com/square/anvil">Anvil</a>.</p><p>O Anvil é uma ferramenta bem documentada e com exemplos muito bons sobre o uso da API do KCP, sendo realmente úteis. Depois disso, foi possível refatorar todo o código diretamente para o KCP, eliminando a necessidade de adicionar o KSP ao projeto. Quanto à dependência runtime do Iris Mock, descobri um pequeno truque: delegar a responsabilidade de adicioná-la ao projeto para o próprio plugin:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb2e26145bd03dd42fec14da67d8a1de/href">https://medium.com/media/eb2e26145bd03dd42fec14da67d8a1de/href</a></iframe><p>Dessa forma, os usuários não precisam adicionar manualmente a dependência runtime do Iris Mock. Outro ponto positivo é que é mais fácil gerenciar qual versão do plugin Iris Mock é compatível com qual versão da dependência runtime, uma vez que é definido pelo próprio plugin 😎.</p><h4>Extra: Speedrun Iris Mock</h4><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Ffe3bJ55tIck%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dfe3bJ55tIck&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Ffe3bJ55tIck%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/8a9b28d152d789e0a9af1a4ac26915b1/href">https://medium.com/media/8a9b28d152d789e0a9af1a4ac26915b1/href</a></iframe><p>Isso é tudo. Espero que esta ferramenta e artigo tenham sido úteis para você e sinta-se à vontade para contribuir com o projeto. Como o Iris Mock ainda está em sua primeira versão, há muito espaço para melhorias e recursos. Outra coisa, não se esqueça de dar uma estrela ao repositório do projeto no GitHub 🥹:</p><p><a href="https://github.com/arildojr7/iris-mock">GitHub - arildojr7/iris-mock: A kotlin-first tool to intercept android network calls, modify requests/responses and mock entire APIs. Also includes a cool DSL, that helps to reduce boilerplate code and simplify development.</a></p><h4>References</h4><ul><li><a href="https://betterprogramming.pub/say-hello-to-kotlin-compiler-plugin-f4e857be9a1">Say Hello to the Kotlin Compiler Plugin</a></li><li><a href="https://bnorm.medium.com/writing-your-second-kotlin-compiler-plugin-part-1-project-setup-7b05c7d93f6c">Writing Your Second Kotlin Compiler Plugin, Part 1 — Project Setup</a></li><li><a href="https://github.com/square/anvil">GitHub - square/anvil: A Kotlin compiler plugin to make dependency injection with Dagger 2 easier.</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08979a97a923" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing Iris Mock: An easier way to mock network calls on Android]]></title>
            <link>https://proandroiddev.com/introducing-iris-mock-an-easier-way-to-mock-network-calls-on-android-11de6ff43316?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/11de6ff43316</guid>
            <category><![CDATA[ui-testing]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[network-mock]]></category>
            <category><![CDATA[androiddev]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Mon, 09 Oct 2023 18:25:02 GMT</pubDate>
            <atom:updated>2024-03-28T13:32:11.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDVE8MQgKhAjAse_MRhw0Q.png" /></figure><p>This article is a mix of presenting a new tool I have developed to make network mocks easier on Retrofit, Volley and any OkHttp based tool and my learnings during the process. Let&#39;s start by introducing Iris Mock and what is possible to do with it.</p><h4>Introducing Iris Mock</h4><p>Most likely, every Android developer has ever needed to mock networks calls. This may happen for several reasons, such as not relying on live apis for automated tests, a new feature that&#39;s not yet available on api and so on. The common point for whatever reason you have imagined is: the need for creating boilerplate (and annoying) code 🤯.</p><p>This is the scenario where Iris Mock fits perfectly. You don&#39;t have to worry about all these boilerplate codes. This will be done through a nice DSL api, where you can implement your mock logic in an idiomatic way.</p><h4><strong>Traditional way to mock calls</strong></h4><p>Let&#39;s take a look on the traditional way to mock network calls on Retrofit:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/65c66c73aab4a3f40f995e63782024ad/href">https://medium.com/media/65c66c73aab4a3f40f995e63782024ad/href</a></iframe><p>You also need to add the interceptor to the OkHttpClient builder:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b2d11e89d4dc6d37968942c5201b8e64/href">https://medium.com/media/b2d11e89d4dc6d37968942c5201b8e64/href</a></iframe><h4>Using Iris Mock 😎</h4><p>Now, let&#39;s mock the same call, using Iris Mock. First, we need to add Iris Mock plugin to the app module build.gradle.kts:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08771583639c15dab7ba4921093db1a0/href">https://medium.com/media/08771583639c15dab7ba4921093db1a0/href</a></iframe><p>Now, you can start to implement your interceptor:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8d842c7639c6902865eac879c87231a6/href">https://medium.com/media/8d842c7639c6902865eac879c87231a6/href</a></iframe><p>and… <strong>that&#39;s all.</strong> But wait, are we not forgetting to add interceptor to the OkHttpClient ? Well, the answer is <strong>no</strong>. Everything you need to do is annotate your class with @IrisMockInterceptor and Iris Mock will take care of the rest for you, injecting the custom interceptors directly into the OkHttpClient bytecode.</p><p>Besides being faster, it also makes possible to use custom interceptors on where normally we was unable, like 3rd-party libraries. As these libraries usually don&#39;t expose its OkHttpClient builder, it&#39;s impossible to add custom interceptors. As Iris Mock doesn&#39;t rely on this approach, you can add your interceptors everywhere, even on external libraries 🥹.</p><p>More details on official documentation: <a href="https://irismock.arildo.dev/">https://irismock.arildo.dev/</a></p><p><strong>A more complex Iris Mock example:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0d6bd917aec587c55bbff20ceb2bd237/href">https://medium.com/media/0d6bd917aec587c55bbff20ceb2bd237/href</a></iframe><h4>Extra: Developing a plugin</h4><p>The path to create a plugin involves a lot of learnings. At the end, the plugin is quite different from what I though about its implementation.</p><p>One thing I would like to achieve with Iris Mock was, somehow, remove the need to add interceptors manually on OkHttpClient. The first reason is to make its usage simple and the second one is to make possible to be used with external libraries. At this moment I knew I should work on bytecode level.</p><h4>First approach: add all interceptors to OkHttpClient bytecode</h4><p>The idea was simple: create an annotation class, IrisMockInterceptor, iterate over annotated classes to get its reference and add them to the OkHttpClient bytecode. The injection, by itself, is not so complex. I used the <a href="https://asm.ow2.io/">ASM library</a>, which helps manipulate the bytecode. However, it didn&#39;t work as expected for one reason: ASM iterates over all classes once and there&#39;s no way to grant that we know all annotated classes when ASM is visiting OkHttpClient bytecode, so this approach wouldn&#39;t work 🥲.</p><h4>Second approach: Wrapper class using KSP</h4><p>Since is impossible to predict which classes should be injected, I had another idea: What if I generate a wrapper class in buildtime, holding all annotated classes instances? It could work, because in this way, I would know the exactly class to be injected on bytecode. To generate this wrapper class, I decided to go with <a href="https://kotlinlang.org/docs/ksp-overview.html"><strong>KSP</strong></a>, that&#39;s up to 2x faster than KAPT.</p><p>And voilà. It worked. But, there was something bothering me. Now, to use Iris Mock, users would need to add KSP plugin, Iris Mock plugin, Iris Mock KSP dependency and Iris Mock KSP runtime dependency:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/484474e79bb067b478d89f94db78d2aa/href">https://medium.com/media/484474e79bb067b478d89f94db78d2aa/href</a></iframe><h4>Third approach: Refactor to Kotlin Compiler Plugin</h4><p>I decided to remove KSP and go with a more low level solution. Looking some other plugins, like KSP and KAPT themselves, I figured out that they are implemented using Kotlin Compiler Plugin (KCP), then I decided to also use it. Of course, as any solution, there are cons and pros, for example, simply there&#39;s no documentation about KCP. Hundreds and more hundreds of lines without any documentation. I spent several days (and felt a little frustrated) before I found a repo that changed everything, <a href="https://github.com/square/anvil">Anvil&#39;s repo</a>.</p><p>In Anvil&#39;s repo, there are very good comments and examples about KCP api usage, being really helpful. After that, it was possible to refactor all the code directly to KCP, removing the need to add KSP to the project.</p><p>For the Iris Mock runtime dependency, I found a little trick, delegate the responsibility of adding it to the project to the plugin itself:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c20e72a2f24d84792cf3e5a1d5096d49/href">https://medium.com/media/c20e72a2f24d84792cf3e5a1d5096d49/href</a></iframe><p>On this way, users don&#39;t need to add Iris Mock runtime dependency manually. Another positive point is that it&#39;s easer to manage which version of Iris Mock plugin is compatible with which version of Iris Mock dependency, since it&#39;s defined by the plugin itself 😎.</p><h4>Extra: Getting started video</h4><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Ffe3bJ55tIck%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dfe3bJ55tIck&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Ffe3bJ55tIck%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/8a9b28d152d789e0a9af1a4ac26915b1/href">https://medium.com/media/8a9b28d152d789e0a9af1a4ac26915b1/href</a></iframe><p>That&#39;s all. I hope that this tool and article have been useful for you and feel free to contribute to the project. As Iris Mock is still in alpha stage, there&#39;s a big room for improvements and new features. Also, don&#39;t forget to star the project&#39;s repo on GitHub:</p><p><a href="https://github.com/arildojr7/iris-mock">GitHub - arildojr7/iris-mock: A kotlin-first tool to intercept android network calls, modify requests/responses and mock entire APIs. Also includes a cool DSL, that helps to reduce boilerplate code and simplify development.</a></p><h4>References</h4><ul><li><a href="https://github.com/square/anvil">GitHub - square/anvil: A Kotlin compiler plugin to make dependency injection with Dagger 2 easier.</a></li><li><a href="https://betterprogramming.pub/say-hello-to-kotlin-compiler-plugin-f4e857be9a1">Say Hello to the Kotlin Compiler Plugin</a></li><li><a href="https://bnorm.medium.com/writing-your-second-kotlin-compiler-plugin-part-1-project-setup-7b05c7d93f6c">Writing Your Second Kotlin Compiler Plugin, Part 1 — Project Setup</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11de6ff43316" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/introducing-iris-mock-an-easier-way-to-mock-network-calls-on-android-11de6ff43316">Introducing Iris Mock: An easier way to mock network calls on Android</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Compose + Wear OS: Afinador Cromático]]></title>
            <link>https://medium.com/codeinlab/compose-wear-os-afinador-crom%C3%A1tico-39225b867f35?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/39225b867f35</guid>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[wear-os]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[wearables]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Wed, 01 Dec 2021 13:16:33 GMT</pubDate>
            <atom:updated>2021-12-01T13:16:33.979Z</atom:updated>
            <content:encoded><![CDATA[<h4>Exemplo prático do poder do Jetpack Compose</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y_pou3EHEfzOsTplqJTUqQ.jpeg" /><figcaption>imagem criada por freepik — br.freepik.com</figcaption></figure><p>Nesse artigo vou abordar o desenvolvimento de um afinador cromático para Wear OS, versão do android projetada para dispositivos <em>wearables — como smartwatches</em>, usando Jetpack Compose 😎.</p><p>Antes de mais nada, você sabe o que é um afinador cromático? Não? Vamos lá:</p><blockquote>Afinador cromático serve para detectar a altura das 12 notas musicais, permitindo que instrumentos sejam afinados corretamente.</blockquote><p>Todas as notas musicais possuem sua frequência de vibração específica. A nota <strong>A4 </strong>(lá), por exemplo, oscila a 440Hz. Tendo isso como base, nosso objetivo é desenvolver um aplicativo que detecte a frequência que está sendo tocada e o quão acima ou abaixo ela está da frequência específica de cada uma das 12 notas, para que o músico consiga afinar seu instrumento corretamente. Bora?</p><h4>Interface</h4><p>A interface do nosso app será bastante simples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lh8B1CxPI1awMrQQXr9Rdg.png" /><figcaption>imagem da UI, demonstrando minhas fortes skills de design… 😅</figcaption></figure><p>O primeiro estado, com fundo verde, indica que a nota tocada tem a mesma frequência da nota <strong>A#</strong> (lá sustenido), ou seja, a nota está afinada.</p><p>Já o segundo, além da cor vermelha para indicar que a frequência não está correta, também exibe setas laterais para indicar se o músico deve aumentar ou diminuir a altura da nota, a fim de chegar à frequência correta.</p><h3>Configurando Projeto</h3><p>Não tem muito mistério para criar um projeto com suporte ao Wear OS e Compose. Você pode criar um novo projeto, da maneira usual, e adicionar essas três <em>tags</em> ao <em>AndroidManifest.xml</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/68611cc4ff64d1192d7bc327102d4137/href">https://medium.com/media/68611cc4ff64d1192d7bc327102d4137/href</a></iframe><h4>Wear Compose</h4><p>Além dos pacotes convencionais do Compose, também existem pacotes específicos para dispositivos <em>wearables</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/32f445b44bed760139a3711c08de892f/href">https://medium.com/media/32f445b44bed760139a3711c08de892f/href</a></iframe><p>Vamos usar dois desses pacotes e, aproveitando que estamos configurando as dependências do projeto, adicionaremos uma biblioteca de <a href="https://pt.wikipedia.org/wiki/DSP"><em>DSP</em></a><em> </em>chamada <a href="https://github.com/JorenSix/TarsosDSP"><strong>TarsosDSP</strong></a> que, entre outros recursos, possui reconhecimento de frequências.</p><ul><li>Você pode baixá-la <a href="https://0110.be/releases/TarsosDSP/TarsosDSP-2.4/TarsosDSP-Android-2.4-bin.jar">aqui</a></li></ul><p>O bloco <em>dependencies</em> do nosso <em>build.gradle</em> ficará o seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c5281f89a65f67d7ca8a92a87778380/href">https://medium.com/media/2c5281f89a65f67d7ca8a92a87778380/href</a></iframe><p>Pronto, dependências adicionadas, agora o projeto está pronto para começarmos o desenvolvimento. Essa é a nossa <em>MainActivity:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c852aed28f53b9776b91f274deb492d1/href">https://medium.com/media/c852aed28f53b9776b91f274deb492d1/href</a></iframe><p>Uma das coisas mais legais do Compose para Wear OS é que ele nos disponibiliza um <em>Scaffold</em> próprio e algumas views úteis, como a <em>TimeText():</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c77c4a0afa6077b380bf495bb3cf04c/href">https://medium.com/media/7c77c4a0afa6077b380bf495bb3cf04c/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*DtY6lZrHVASRP1_gkbi9gA.png" /><figcaption>imagem com preview do nosso hello world no emulador</figcaption></figure><p>Com apenas 13 linhas, nosso app já ficou assim e simmm, minhas amigas, o <em>TimeText() </em>é um relógio prontinho 😎.</p><p>Agora vamos implementar a UI e o <em>@Preview</em> para cada um dos estados da tela:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5ce7d9c4dcaaf83c1ab1a68a4490899b/href">https://medium.com/media/5ce7d9c4dcaaf83c1ab1a68a4490899b/href</a></iframe><p>Feito isso, teremos os seguintes <em>previews</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/1*qUUGelcWstlHkEGc4udJZw.png" /><figcaption>imagem com preview dos três estados de tela</figcaption></figure><p>Note que no código acima a função <em>TunerScreen()</em> recebe uma <em>TunerState(),</em> que é uma<em> </em><a href="https://kotlinlang.org/docs/sealed-classes.html"><em>sealed class</em></a> que criei para facilitar o gerenciamento dos estados:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98eb8f0dc067baf493a29c6f8fff6546/href">https://medium.com/media/98eb8f0dc067baf493a29c6f8fff6546/href</a></iframe><p>Dessa forma, através de apenas uma classe, temos todas as informações necessárias para propagarmos as mudanças e atualizarmos nossa <em>view</em> 😎.</p><h3>Detecção de frequências</h3><p>A biblioteca <em>TarsosDSP</em> possui a interface <em>PitchDetectionHandler</em> que, entre diversos recursos, nos disponibiliza a frequência e o volume do som que está sendo captado. Com isso, basta usar esses valores obtidos e implementar a lógica de comparação com os valores de referência que temos para cada uma das 12 notas e suas oitavas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s_CFMhIW5BxtWYdQtFU6BQ.png" /><figcaption>Fonte: <a href="https://www.treinaweb.com.br/blog/gerando-sons-com-a-web-audio-api-do-javascript">https://www.treinaweb.com.br/blog/gerando-sons-com-a-web-audio-api-do-javascript</a></figcaption></figure><p>Dentro da <em>PitchDetectionHandler,</em> recebemos a frequência (em <em>Hz</em>) e verificamos se devemos atualizar o estado da tela. A função <em>shouldUpdateTunerState() </em>é responsável por essa parte, validar se o áudio captado possui um volume mínimo, para evitar o processamento de ruídos e se a frequência captada é valida.</p><p>Caso passe nessa validação, chamamos a função <em>getCurrentPitchState(),</em> que é responsável por nos devolver uma instância de <em>TunerState() </em>para, em seguida, propagamos o resultado para o <em>LiveData</em> <em>_tunerState:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1beb6685d5c5b3125d90c59f86086bb1/href">https://medium.com/media/1beb6685d5c5b3125d90c59f86086bb1/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8cd877cf926dd69cd82be055b072d5f3/href">https://medium.com/media/8cd877cf926dd69cd82be055b072d5f3/href</a></iframe><p>A lógica da função <em>getCurrentPitchState() </em>é bem simples:</p><ul><li>Verificar qual das frequências, entre todas as notas, é mais próxima da frequência capturada;</li><li>Pegar a nota correspondente à frequência mais próxima;</li><li>Calcular a diferença entre a frequência de entrada e a frequência de referência;</li><li>Retornar uma instância de<em> TunerState()</em>, levando em consideração essa diferença, se está dentro do aceitável, abaixo ou acima.</li></ul><p>Como instrumentos de cordas sofrem variações de frequência por causa da amplitude da vibração da corda, logo temos que adotar uma faixa aceitável para um som ser considerado afinado. Para isso, vamos usar a norma <a href="https://www.iso.org/standard/3601.html"><strong>ISO16</strong></a>, que prevê uma tolerância de ±0.5Hz.</p><p>Essa lógica está implementada na linha 12 do código acima, na <em>extension</em> <em>isInPermittedTolerance(), </em>que nada mais é que a seguinte linha:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bc315d9843a22f79c67d23334cf7dee5/href">https://medium.com/media/bc315d9843a22f79c67d23334cf7dee5/href</a></iframe><h4>LiveData.observeAsState()</h4><p>Outro ponto que vale a pena a ser comentado é sobre como nossa ui observa as informações propagadas ao <em>LiveData. </em>O Compose possui a<em> extension LiveData.observeAsState(),</em> que tem seu funcionamento bem parecido com a forma tradicional de se observar mudanças no <em>LiveData</em>, com a interface<em> Observer. </em>A diferença é que usando esse <em>approach</em>, a tela é recomposta automaticamente e o código fica bem mais limpo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/15a026a6e426f44f77a2791a9060f843/href">https://medium.com/media/15a026a6e426f44f77a2791a9060f843/href</a></iframe><p>E agora? Bom, agora podemos pular para a próxima etapa, que é justamente ver o app funcionando (ou não 😅).</p><h3>Funcionamento</h3><p>Para validar o funcionamento do nosso afinador, vamos usar um app gerador de tom reproduzindo frequências específicas, a fim de verificar se o afinador está se comportando conforme o esperado. Como sabemos que a nota <strong>A4</strong> tem frequência de 440Hz, vamos usar ela em nossos casos de teste:</p><ul><li>Frequência <strong>439.5Hz </strong>deve exibir <strong>Nota A afinada</strong></li><li>Frequência <strong>440.5Hz </strong>deve exibir <strong>Nota A afinada</strong></li><li>Frequência <strong>439.4Hz </strong>deve exibir <strong>Nota A desafinada para baixo</strong></li><li>Frequência <strong>440.6Hz </strong>deve exibir <strong>Nota A desafinada para cima</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8xBkr2F4j9zvFYAT7lTC6A.png" /><figcaption>Screenshots tiradas do meu Galaxy Watch4 + celular</figcaption></figure><p>Ok, está funcionando 😎</p><p>Você pode conferir o código completo em:</p><p><a href="https://github.com/arildojr7/tuner-compose-wearos">GitHub - arildojr7/tuner-compose-wearos</a></p><p>Qualquer sugestão ou dúvida, fique a vontade para deixar seu comentário. <br>Obrigado por ler e até a próxima!</p><h3>Referências</h3><ul><li><a href="https://pt.wikipedia.org/wiki/L%C3%A1_440">Lá 440 - Wikipédia, a enciclopédia livre</a></li><li><a href="https://www.iso.org/standard/3601.html">ISO 16:1975</a></li><li><a href="https://github.com/JorenSix/TarsosDSP">GitHub - JorenSix/TarsosDSP: A Real-Time Audio Processing Framework in Java</a></li><li><a href="https://proandroiddev.com/compose-for-wear-os-scaffold-89e0fc5cc033">Compose for Wear OS: Scaffold</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39225b867f35" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codeinlab/compose-wear-os-afinador-crom%C3%A1tico-39225b867f35">Compose + Wear OS: Afinador Cromático</a> was originally published in <a href="https://medium.com/codeinlab">CodeInLab</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Compose + Wear OS: Chromatic Tuner]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://proandroiddev.com/compose-wear-os-chromatic-tuner-47aa50b44b6?source=rss-cc8bbfc44dc7------2"><img src="https://cdn-images-1.medium.com/max/2600/1*Y_pou3EHEfzOsTplqJTUqQ.jpeg" width="3000"></a></p><p class="medium-feed-snippet">Practical example of the power of Jetpack Compose</p><p class="medium-feed-link"><a href="https://proandroiddev.com/compose-wear-os-chromatic-tuner-47aa50b44b6?source=rss-cc8bbfc44dc7------2">Continue reading on ProAndroidDev »</a></p></div>]]></description>
            <link>https://proandroiddev.com/compose-wear-os-chromatic-tuner-47aa50b44b6?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/47aa50b44b6</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[wearables]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Tue, 30 Nov 2021 17:35:12 GMT</pubDate>
            <atom:updated>2021-11-30T17:35:12.465Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Princípios SOLID aplicados ao Android]]></title>
            <link>https://medium.com/codeinlab/princ%C3%ADpios-solid-aplicados-ao-android-e874e2a82a20?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e874e2a82a20</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Mon, 12 Jul 2021 20:29:04 GMT</pubDate>
            <atom:updated>2021-07-12T20:29:04.892Z</atom:updated>
            <content:encoded><![CDATA[<h4>Como melhorar o design do seu código com esses 5 princípios</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mNm5_Tcj6HqONck0" /><figcaption>Photo by <a href="https://unsplash.com/@artem_kniaz?utm_source=medium&amp;utm_medium=referral">Artem Kniaz</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Overview</h3><p>Você já ouviu falar sobre princípios <strong><em>SOLID?</em></strong> Eles estão diretamente ligados ao desenvolvimento orientado à objetos, que é o paradigma mais utilizado para desenvolvimento mobile.</p><p>Vamos entender cada um desses princípios agora:</p><h4>S - Single Responsability Principle - SRP</h4><p>Criado por <a href="https://pt.wikipedia.org/wiki/Robert_Cecil_Martin">Robert C. Martin</a>, também conhecido como Uncle Bob, esse princípio, como o próprio nome diz, está relacionado a parte de responsabilidades de uma classe ou função.</p><p>Para que um código atenda esse princípio, é necessário que todas as responsabilidades estejam bem definidas. Uma única função não deve ter diversos objetivos não correlacionados, assim como uma classe também não deve ter mais de um propósito<strong><em>. </em></strong>Isso garante um código altamente coeso e com maior granularidade.</p><p>Vamos ver na prática, utilizando a função onBindViewHolder() da classe RecyclerView.Adapter , muito utilizada no Android:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9dda6a5399e166164bdbff4f4a39d91f/href">https://medium.com/media/9dda6a5399e166164bdbff4f4a39d91f/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f9e383ea30ddc68812668be0e886c9de/href">https://medium.com/media/f9e383ea30ddc68812668be0e886c9de/href</a></iframe><p>Note que no <em>exemplo 1</em>, estamos violando o conceito de responsabilidade única, pois a responsabilidade da função onBindViewHolder() deveria ser apenas de conectar os dados à sua respectiva <em>view</em>. Porém estamos também agregando lógica para formatação de datas.</p><p>Conformando ao <strong>SRP</strong>, chegamos ao <em>exemplo 2</em>, onde extraímos essa lógica para uma função auxiliar, numa classe de <em>utils. </em>Agora estamos respeitando esse princípio e além disso, diminuindo duplicação de código, pois provavelmente precisaremos formatar datas em outros pontos do app, e agora é só utilizar a função formatDate() .</p><h4>O - Open-Closed Principle - OCP</h4><p>A premissa desse princípio é a seguinte:</p><blockquote>Classes devem ser abertas à extensões, mas fechada à modificações.</blockquote><p>Partindo dessa afirmação, podemos concluir que uma classe pode ser estendida, pode ter sua funcionalidade aumentada através de sua classe derivada, porém não pode ter sua funcionalidade alterada. Vamos ver um exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea5a5ef0183f7767e7cc598e8f1831da/href">https://medium.com/media/ea5a5ef0183f7767e7cc598e8f1831da/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd077e82afdd7e37b3f1e8bc4322f0ea/href">https://medium.com/media/bd077e82afdd7e37b3f1e8bc4322f0ea/href</a></iframe><p>Note que no <em>exemplo 1, </em>estamos intencionalmente violando o <strong>OCP</strong>, pois a classe Circle() está estendendo a classe Rectangle() e alterando sua funcionalidade, pois agora ela não sabe mais calcular a área de um retângulo, apenas de um círculo.<br>No <em>exemplo 2, </em>estamos conformando o código ao <strong>OCP</strong>, agora estamos estendendo de uma classe mais genérica, a Shape() , e escrevendo a lógica específica em cada uma das classes derivadas. Dessa maneira garantimos que não haja alterações na funcionalidade da classe base.</p><h4>L - Liskov Substitution Principle - LSP</h4><p>Esse princípio foi introduzido por <a href="https://pt.wikipedia.org/wiki/Barbara_Liskov">Barbara Liskov</a>, em 1987. Sua definição é a seguinte:</p><blockquote><em>Se q(x) é uma propriedade demonstrável dos objetos x de tipo T. Então q(y) deve ser verdadeiro para objetos y de tipo S onde S é um subtipo de T.</em></blockquote><p>A partir dessa definição, podemos dizer que uma classe derivada deve poder ser substituída por sua classe base, assim como uma classe base deve poder ser substituída por sua classe derivada.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ef4983e21d8623297f533598afc43e7f/href">https://medium.com/media/ef4983e21d8623297f533598afc43e7f/href</a></iframe><p>A classe base deve funcionar como uma abstração de suas classes derivadas. Note que no exemplo acima, temos a classe base Vehicle() e as classes derivadas Car() e Bicycle() .</p><p>Então a implementação está certa, né? Afinal, tanto carro, quanto bicicleta são tipos de veículos… A resposta é Não!</p><p>De acordo com o <strong>LSP</strong>, essa implementação está incorreta pois, como vimos anteriormente, uma classe base deve poder ser substituída por sua classe derivada e vice-versa, porém nesse exemplo, isso não é verdade. Nossa abstração não está corretamente implementada, visto que não podemos substituir Bicycle() por Vehicle() , pois bicicleta não tem motor, logo não temos como implementar a função startEngine() .</p><p>Vamos refatorar esse código, a fim de implementar corretamente a abstração da classe base:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2d0c082307f3d5b3dba800fe636fecc5/href">https://medium.com/media/2d0c082307f3d5b3dba800fe636fecc5/href</a></iframe><p>Note que agora temos duas classes base intermediárias. Elas servem para nos ajudar nessa especificidade da abstração. Agora, é possível substituir a classe derivada pela classe base, sem nenhum problema e, dependendo do tipo utilizado, teremos acesso às funções específicas que cada uma implementa. Agora sim, estamos em conformidade ao <strong>LSP.</strong></p><h4>I - <strong>Interface Segregation Principle - ISP</strong></h4><p>Quem nunca passou pela situação de precisar implementar apenas uma função de uma interface, mas ser obrigado a colocar as outras funções &quot;vazias&quot; no código? Criado pelo Uncle Bob, esse princípio fala exatamente sobre isso:</p><blockquote>Nenhum cliente deve ser forçado a depender de métodos que não utiliza.</blockquote><p>Temos um exemplo clássico disso no Android, a interface TextWatcher, utilizada para observar mudanças em campos de texto:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c13554118d8dcda5e643528118a2b9b5/href">https://medium.com/media/c13554118d8dcda5e643528118a2b9b5/href</a></iframe><p>Na maioria das vezes, precisamos implementar apenas uma dessas funções da interface, mas ela nos obriga a ter o <em>override de todas as três funções.</em></p><p>Para conformar essa interface ao <strong>ISP</strong>, o ideal seria refatorar a própria interface, mas como ela faz parte da <em>SDK</em> do Android, isso não é possível.<br>Nesse caso, podemos criar nossa própria classe customizada, implementando a TextWatcher, de modo que possamos usar apenas a função necessária:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f4dfa7124e862b32b87bedb4511ffbb/href">https://medium.com/media/1f4dfa7124e862b32b87bedb4511ffbb/href</a></iframe><p>Note que criamos uma abstração da TextWatcher, a MyTextWatcher . Nessa abstração, nós fazemos uma implementação vazia das três funções e, a partir de agora, utilizamos sempre essa abstração, no lugar da TextWatcher. Isso permite que eu implemente apenas a função que eu realmente preciso, sem repetir código desnecessário no projeto :D.</p><h4><strong>D -</strong> <strong>Dependency Inversion Principle - DIP</strong></h4><p>Também criado pelo Uncle Bob, o Princípio da Inversão de Dependência pode ser definido pelas seguintes premissas:</p><blockquote>Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender da abstração.</blockquote><blockquote>Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.</blockquote><p>Partindo disso, vamos ver um exemplo clássico de violação do <strong>DIP:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/129a6ff2af9290890e1796e1d98e66c9/href">https://medium.com/media/129a6ff2af9290890e1796e1d98e66c9/href</a></iframe><p>Se você rodar esse código, verá que ele é totalmente funcional, porém, conceitualmente, ele está quebrando o <strong>DIP</strong>, pois, um módulo de alto nível, o ElectricPowerSwitch , depende de um módulo de baixo nível, o Light .</p><p>Vamos refatorar esse código, de modo que, além de funcional, ele também esteja em conformidade ao <strong>DIP:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0d1e348285a1acb841a900e3a53b804a/href">https://medium.com/media/0d1e348285a1acb841a900e3a53b804a/href</a></iframe><p>Criamos duas interfaces, para representar as funcionalidades de cada classe. Dessa forma, ElectricPowerSwitch não depende mais da implementação da classe Light , mas sim de sua abstração. Tanto que nada impede de criarmos a classe Speaker , implementando a interface Switchable e usar ela dentro da ElectricPowerSwitch , sem precisar de nenhuma alteração.</p><p>Ahh, veja que nesse momento, também adequamos nosso código ao Princípio de Substituição de Liskov. Demais né? :D.</p><p>Por hoje era isso, pessoal! Qualquer dúvida ou sugestão, fique a vontade em comentar. Abração e até a próxima!</p><h4>Referências</h4><ul><li><a href="https://springframework.guru/principles-of-object-oriented-design/dependency-inversion-principle/">Dependency Inversion Principle</a></li><li><a href="https://springframework.guru/principles-of-object-oriented-design/liskov-substitution-principle/">Liskov Substitution Principle</a></li><li><a href="https://pt.wikipedia.org/wiki/Princ%C3%ADpio_da_segrega%C3%A7%C3%A3o_de_Interface">Princípio da segregação de Interface - Wikipédia, a enciclopédia livre</a></li><li><a href="https://proandroiddev.com/exploring-s-o-l-i-d-principle-in-android-a90947f57cf0">Exploring S.O.L.I.D Principle in Android</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e874e2a82a20" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codeinlab/princ%C3%ADpios-solid-aplicados-ao-android-e874e2a82a20">Princípios SOLID aplicados ao Android</a> was originally published in <a href="https://medium.com/codeinlab">CodeInLab</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Complexidade Ciclomática no Android]]></title>
            <link>https://medium.com/android-dev-br/complexidade-ciclom%C3%A1tica-no-android-e69fd4362bdd?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e69fd4362bdd</guid>
            <category><![CDATA[metrícas]]></category>
            <category><![CDATA[complexidade]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[boas-práticas]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Mon, 15 Mar 2021 07:27:46 GMT</pubDate>
            <atom:updated>2021-03-15T07:27:46.452Z</atom:updated>
            <content:encoded><![CDATA[<h4>Como utilizar essa métrica de software para ter um código mais legível e testável.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6-8eE5Z8yNpn3u0K" /><figcaption>Photo by <a href="https://unsplash.com/@dnevozhai?utm_source=medium&amp;utm_medium=referral">Denys Nevozhai</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Complexidade Ciclomática</h3><p>Antes de mais nada, o que é Complexidade Ciclomática?</p><blockquote>Complexidade ciclomática (ou complexidade condicional) é uma métrica de software usada para indicar a complexidade de um programa de computador. Ela mede a quantidade de caminhos de execução independente a partir de um código fonte. Sua fórmula é: M = E - N + P, onde E = quantidade de setas, N = quantidade de nós e P = quantidade de componentes conectados.</blockquote><p>Partindo dessa definição, é possível concluir que a complexidade ciclomática está diretamente relacionada à quantidade máxima de caminhos que o código fonte pode executar, como por exemplo, uma condicional <em>if:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/827c317a28e6bcf585f2bb5bde4989c5/href">https://medium.com/media/827c317a28e6bcf585f2bb5bde4989c5/href</a></iframe><p>O código acima pode ser representado da seguinte maneira:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*0UXtaieHNUsbUY49hmnnZQ.png" /><figcaption>fluxograma representando código acima</figcaption></figure><p>Seguindo a fórmula de cálculo da complexidade ciclomática, temos:</p><p><strong>M = 5 (setas) - 5 (nós) + 2 (componentes conectados) = 2</strong></p><p>Portanto a complexidade do código de exemplo é <strong>2</strong>, pois esse é o número máximo de caminhos que o código pode executar.</p><h3>Importância dessa métrica no Android</h3><p>Como visto anteriormente, essa métrica está diretamente ligada à complexidade lógica do código, porém isso também reflete na legibilidade do código, pois à medida que se aumenta a quantidade de caminhos possíveis, também se aumenta a <strong>dificuldade de leitura</strong> desse código, se tornando cada vez mais difícil de manter. Outro bom ponto é a dificuldade de se escrever testes unitários, visto que será necessário cobrir todas as <em>N</em> possibilidades dentro de uma mesma função.</p><h3>Como gerar essa métrica no Android</h3><p>Existem diversas formas e ferramentas para se extrair complexidade ciclomática no Android, mas indico a ferramenta <a href="https://www.sonarqube.org/"><strong>SonarQube</strong></a>, que além de oferecer diversas outras métricas, ainda oferece suporte a diversas outras linguagens, não se restringindo apenas ao android:</p><p><a href="https://tech.olx.com/sonarqube-integration-in-android-application-part-1-37041b0379">SonarQube Integration in Android Application (Part -1)</a></p><h3>Como diminuir a complexidade de um código</h3><p>Uma boa estratégia é extrair códigos específicos para funções próprias para que, além de deixar o código mais legível, também diminua a quantidade de caminhos que uma única função possui, pois serão diluídos em outras funções. Essa abordagem vem muito ao encontro do que o <strong><em>SRP</em></strong> (<em>Single Responsability Principle</em>, o &quot;S&quot; de <a href="https://medium.com/desenvolvendo-com-paixao/o-que-%C3%A9-solid-o-guia-completo-para-voc%C3%AA-entender-os-5-princ%C3%ADpios-da-poo-2b937b3fc530"><strong><em>SOLID</em></strong></a>) define:</p><blockquote>No entanto, de acordo com o Princípio da Responsabilidade Única, um módulo, uma classe ou uma função tem que fazer apenas uma coisa. Em outras palavras, eles devem ter apenas uma responsabilidade. Desta forma, o código é mais robusto, mais fácil de depurar, ler e reutilizar. (traduzido do original em <a href="https://towardsdatascience.com/solid-programming-part-1-single-responsibility-principle-efca5e7c2a87">Towards Data Science</a>)</blockquote><p>Veja essa abordagem na prática, usando um código bem simples:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1059a71fa53f875e688cb4268a1c9c02/href">https://medium.com/media/1059a71fa53f875e688cb4268a1c9c02/href</a></iframe><p>O código acima possui complexidade de <strong>5</strong>. Uma forma de diminuir esse número e ao mesmo tempo conformar ao <strong><em>SRP</em> </strong>seria extrair o trecho <em>when</em> para uma função separada, pois a responsabilidade dele não é exibir o <em>toast, </em>mas sim definir se deve ser exibido ou não, de acordo com o tipo de usuário:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/18a6fc52e8ffff46dbee5749bb260bb7/href">https://medium.com/media/18a6fc52e8ffff46dbee5749bb260bb7/href</a></iframe><p>Note que no código acima, a funcionalidade não foi alterada, porém agora tem uma complexidade de <strong>2 </strong>(<strong>1</strong> componente + <strong>1</strong> <em>condicional if</em>). Isso permite uma granularidade maior de testes, visto que será possível testar duas funções separadamente, showUserNotification() e shouldShowAdsToUser() , cada uma com sua respectiva responsabilidade.</p><p>Por mais que esse seja um exemplo simples, já dá para visualizar os ganhos dessa abordagem, agora imagine a diferença no mundo real, com funções grandes, código legado, etc…</p><h3>Conclusão</h3><p>Embora a análise da complexidade ciclomática de um código seja um ponto muito importante, ela sozinha não garante que você tenha um código bem legível:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a334fe5354de45a1e97d8c5513bb1bc5/href">https://medium.com/media/a334fe5354de45a1e97d8c5513bb1bc5/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f884a6162b624384bbb154d2baf63c4/href">https://medium.com/media/0f884a6162b624384bbb154d2baf63c4/href</a></iframe><p>Veja nos dois exemplos acima, ambos possuem mesma complexidade, 4, porém legibilidade totalmente diferentes.</p><p>O ideal é sempre utilizá-la em conjunto de outras métricas e investir em boas práticas de desenvolvimento, principalmente princípios <a href="https://medium.com/desenvolvendo-com-paixao/o-que-%C3%A9-solid-o-guia-completo-para-voc%C3%AA-entender-os-5-princ%C3%ADpios-da-poo-2b937b3fc530"><strong><em>SOLID</em></strong></a><strong><em>, </em></strong>que são um ótimo referencial para você ter um código legível, testável e fácil de manter.</p><p><strong>Dica: </strong>Indico a leitura sobre uma segunda métrica relacionada a esse assunto, a <a href="https://www.sonarsource.com/docs/CognitiveComplexity.pdf"><strong>Complexidade Cognitiva</strong></a>, que está diretamente ligada a legibilidade e <em>leiturabilidade</em> do código.</p><p>Abraços e até a próxima!</p><h4>Referências e links úteis</h4><ul><li><a href="https://www.sonarsource.com/resources/white-papers/cognitive-complexity.html">Cognitive Complexity™</a></li><li><a href="https://towardsdatascience.com/solid-programming-part-1-single-responsibility-principle-efca5e7c2a87">SOLID Programming (Part 1): Single Responsibility Principle</a></li><li><a href="https://pt.wikipedia.org/wiki/Complexidade_ciclom%C3%A1tica#:~:text=Complexidade%20ciclom%C3%A1tica%20(ou%20complexidade%20condicional,partir%20de%20um%20c%C3%B3digo%20fonte.">Complexidade ciclomática</a></li><li><a href="https://pt.stackoverflow.com/questions/193665/o-que-%C3%A9-complexidade-ciclom%C3%A1tica">O que é complexidade ciclomática?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e69fd4362bdd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/android-dev-br/complexidade-ciclom%C3%A1tica-no-android-e69fd4362bdd">Complexidade Ciclomática no Android</a> was originally published in <a href="https://medium.com/android-dev-br">Android Dev BR</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cyclomatic Complexity on Android]]></title>
            <link>https://proandroiddev.com/cyclomatic-complexity-on-android-d52577d3e638?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d52577d3e638</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[complexity]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Sun, 14 Mar 2021 17:39:45 GMT</pubDate>
            <atom:updated>2021-03-14T17:39:45.739Z</atom:updated>
            <content:encoded><![CDATA[<h4>How to use this software metric to have more readable and testable code.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6-8eE5Z8yNpn3u0K" /><figcaption>Photo by <a href="https://unsplash.com/@dnevozhai?utm_source=medium&amp;utm_medium=referral">Denys Nevozhai</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Cyclomatic Complexity</h3><p>First, what is Cyclomatic Complexity?</p><blockquote>Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program’s source code. Its formula is: M = E - N + P, where E = number of edges, N = number of nodes and P = number of connected components</blockquote><p>Based on this definition, it is possible to conclude that cyclomatic complexity is directly related to the maximum number of paths that the source code can execute, such as an if conditional:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/827c317a28e6bcf585f2bb5bde4989c5/href">https://medium.com/media/827c317a28e6bcf585f2bb5bde4989c5/href</a></iframe><p>The above code can be represented as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*0UXtaieHNUsbUY49hmnnZQ.png" /><figcaption>flowchart represented above code</figcaption></figure><p>According to the formula for calculating cyclomatic complexity, we have:</p><p><strong>M = 5 (edges) — 5 (nodes) + 2 (connected components) = 2</strong></p><p>So the complexity of the sample code is <strong>2</strong>, because that is the maximum number of paths that the code can perform.</p><h3>Importance of this metric on Android</h3><p>As previously seen, this metric is directly linked to the logical complexity of the code, but this also reflects in the readability of the code, as as the number of possible paths increases, so does the <strong>difficulty of reading</strong> this code, becoming increasingly difficult to maintain. Another good point is the difficulty of writing unit tests, since it will be necessary to cover all <em>N</em> possibilities within the same function.</p><h3>How to generate this metric on Android</h3><p>There are several ways and tools to extract cyclomatic complexity on Android, but I recommend the <a href="https://www.sonarqube.org/"><strong>SonarQube</strong></a> tool, which in addition to offering several other metrics, still supports several other languages, not being restricted only to android:</p><p><a href="https://tech.olx.com/sonarqube-integration-in-android-application-part-1-37041b0379">SonarQube Integration in Android Application (Part -1)</a></p><h3>How to decrease the complexity of a code</h3><p>A good strategy is to extract specific codes for specific functions so that, in addition to making the code more readable, it also reduces the number of paths that a single function has, as they will be diluted in other functions. This approach is very much in line with what the <strong><em>SRP</em></strong> (<em>Single Responsibility Principle</em>, the “S” in <a href="https://medium.com/kayvan-kaseb/the-solid-principles-for-android-developers-75fd4ca3ef84"><strong><em>SOLID</em></strong></a>) defines:</p><blockquote>However, according to the Single Responsibility Principle, a module, a class or a function has to only do one thing. In other words, they have to have only one responsibility. This way the code is more robust, easier to debug, read and reuse.</blockquote><p>See this approach in practice, using very simple code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1059a71fa53f875e688cb4268a1c9c02/href">https://medium.com/media/1059a71fa53f875e688cb4268a1c9c02/href</a></iframe><p>The code above has a complexity of <strong>5</strong>. One way to decrease this number and at the same time conform to the <strong>SRP</strong> would be to extract the <em>`when`</em> code to a separate function, as its responsibility is not to display the <em>toast</em>, but to define whether it should be displayed or not, according to the type of user:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/18a6fc52e8ffff46dbee5749bb260bb7/href">https://medium.com/media/18a6fc52e8ffff46dbee5749bb260bb7/href</a></iframe><p>Note that in the code above, the functionality has not been changed, but now it has a complexity of 2 (1 component + 1 conditional if). This allows for a greater granularity of tests, since it will be possible to test two functions separately, showUserNotification() and shouldShowAdsToUser(), each with its respective responsibility.<br>As much as this is a simple example, you can already see the gains from this approach, now imagine the difference in the real world, with large functions, legacy code, etc …</p><h3>Conclusion</h3><p>Although analyzing the cyclomatic complexity of a code is a very important point, it alone does not guarantee that you have a very readable code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a334fe5354de45a1e97d8c5513bb1bc5/href">https://medium.com/media/a334fe5354de45a1e97d8c5513bb1bc5/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f884a6162b624384bbb154d2baf63c4/href">https://medium.com/media/0f884a6162b624384bbb154d2baf63c4/href</a></iframe><p>See the two examples above, both have the same complexity, 4 but totally different legibility.</p><p>The ideal is to always use it in conjunction with other metrics and invest in good development practices, especially <a href="https://medium.com/kayvan-kaseb/the-solid-principles-for-android-developers-75fd4ca3ef84"><strong><em>SOLID</em></strong></a> principles, which are a great reference for you to have a readable, testable and easy to maintain code.</p><p><strong>Tip</strong>: I recommend reading about a second metric related to this subject, <a href="https://www.sonarsource.com/docs/CognitiveComplexity.pdf"><strong><em>Cognitive Complexity</em></strong></a>, which is directly linked to the readability and readability of the code.</p><p>Thanks!</p><h4>References and useful links</h4><ul><li><a href="https://www.sonarsource.com/resources/white-papers/cognitive-complexity.html">Cognitive Complexity™</a></li><li><a href="https://towardsdatascience.com/solid-programming-part-1-single-responsibility-principle-efca5e7c2a87">SOLID Programming (Part 1): Single Responsibility Principle</a></li><li><a href="https://en.wikipedia.org/wiki/Cyclomatic_complexity">Cyclomatic complexity - Wikipedia</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d52577d3e638" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/cyclomatic-complexity-on-android-d52577d3e638">Cyclomatic Complexity on Android</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configurando GitHub Actions para Android]]></title>
            <link>https://medium.com/android-dev-br/configurando-github-actions-para-android-91309fa9a62c?source=rss-cc8bbfc44dc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/91309fa9a62c</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Arildo Borges Jr]]></dc:creator>
            <pubDate>Sat, 25 Jan 2020 14:15:38 GMT</pubDate>
            <atom:updated>2020-07-07T09:32:11.245Z</atom:updated>
            <content:encoded><![CDATA[<h4>Automatizando lint, test, build e outras tarefas repetitivas…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mNRmZb0AOl9FUYCfp-X6AA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@realaxer?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">tian kuan</a> on <a href="https://unsplash.com/s/photos/pipeline?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Recentemente o GitHub lançou uma ferramenta de CI/CD própria em sua plataforma, o GitHub Actions, tornando mais fácil a automatização de tarefas repetitivas, como build, test, lint, deploy, invalidação do Cloudfront e muito mais. Nesse artigo vamos ver como configurar uma <em>pipeline</em> simples para desenvolvimento Android, para você poder evoluir de acordo com as necessidades do seu projeto.</p><h3>Entendendo o arquivo de configuração</h3><p>Vamos criar o arquivo de configuração inicial do “Actions”, para isso, vá ao repositório do seu projeto, clique na tab “<strong>Actions”, </strong>depois em “<strong>Set up a workflow yourself”.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*gaeBTGa0TRSI5ZvPPQi1SQ.png" /></figure><p>Feito isso, veremos uma tela com um arquivo main.yml default (você pode alterar o nome do arquivo, respeitando apenas o formato <strong>.yml</strong>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/1*YQrj-ib3582fv1OJuAYrtw.png" /></figure><p>Note que nesse arquivo temos algumas keywords, como <em>name</em>, <em>on</em>, <em>jobs</em>, <em>steps</em>. Vou explicar cada um deles logo abaixo:</p><h4>name:</h4><p>Define o nome da <em>pipeline</em> que irá aparecer na tab “Actions”.</p><h4>on:</h4><p>Define qual evento irá iniciar a <em>pipeline</em>. Para isso temos algumas opções, como <em>push</em>, <em>pull_request</em>, <em>page_build</em> e <em>schedule</em>, sendo esse bem interessante, pois podemos agendar para a <em>pipeline</em> rodar periodicamente 😎.</p><h4>jobs:</h4><p>É aqui que iremos definir quais jobs irão rodar dentro da nossa <em>pipeline</em>.</p><p>E dentro de “Jobs”, ainda temos:</p><h4>runs-on:</h4><p>Define sobre qual plataforma o <em>job</em> irá rodar, sendo possível escolher entre ubuntu-latest, ubuntu-16.04, windows-latest e ainda macos-latest.</p><h4>steps</h4><p>São literalmente os passos dentro da execução de um job.</p><h3>Personalizando arquivo para desenvolvimento Android</h3><p>Agora que já entendemos o básico sobre o arquivo de configuração do Actions, vamos personalizá-lo para rodar os testes e build. Para isso, troque o conteúdo do arquivo.yml default para:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/73391b97caa8f310c4b68b2b407770be/href">https://medium.com/media/73391b97caa8f310c4b68b2b407770be/href</a></iframe><p>Feito isso, você pode <em>commitar</em> as alterações e clicar na tab “Actions” novamente, note que agora temos uma <em>pipeline</em> se iniciando:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*OqayenLnO0XqI3vZVR5geA.png" /></figure><p>Em alguns minutos você poderá ver o resultado os jobs, assim como os logs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*8js4lzp780vz4aEoEssWcQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/275/1*YjxQ1Yr9vvII0TRlLDQwcA.gif" /></figure><p>E agora? Bom, agora você pode evoluir de acordo com as necessidades do seu projeto, seja adicionando jobs de lint, deploy, etc...</p><p>Abraços e até a próxima!</p><h4>Referências</h4><ul><li><a href="https://help.github.com/pt/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#">Sintaxe de fluxo de trabalho para o GitHub Actions</a></li><li><a href="https://github.com/arildojr7?tab=repositories">arildojr7 - Overview</a></li><li><a href="https://arildo.dev/">Arildo Borges Jr - Portfolio</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=91309fa9a62c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/android-dev-br/configurando-github-actions-para-android-91309fa9a62c">Configurando GitHub Actions para Android</a> was originally published in <a href="https://medium.com/android-dev-br">Android Dev BR</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>