<?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 Maribel Maisano on Medium]]></title>
        <description><![CDATA[Stories by Maribel Maisano on Medium]]></description>
        <link>https://medium.com/@maribelmai?source=rss-68bf06349384------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IGkMxDOeLhigM13QnYkuQQ.jpeg</url>
            <title>Stories by Maribel Maisano on Medium</title>
            <link>https://medium.com/@maribelmai?source=rss-68bf06349384------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:26:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maribelmai/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[Moderniza tu app Android]]></title>
            <link>https://medium.com/droid-latam/moderniza-tus-apps-android-6f46ae757e78?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f46ae757e78</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Sat, 28 Nov 2020 18:28:11 GMT</pubDate>
            <atom:updated>2020-11-30T18:12:14.334Z</atom:updated>
            <content:encoded><![CDATA[<h4>Si tus proyectos se están quedando atrás en cuanto a las tecnologías utilizadas, te estás perdiendo un mundo de mejoras que podrían hacer tus aplicaciones más mantenibles y tu día a día más fácil. Chequea algunos pequeños cambios que podrías aplicar para que tu código aproveche las últimas características del desarrollo Android.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*auepDIBkNzfS5wMh" /><figcaption>Photo by <a href="https://unsplash.com/@jasmund?utm_source=medium&amp;utm_medium=referral">Michael Jasmund</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Posiblemente te abrume la cantidad de novedades que se presentan periódicamente acerca de Android: nuevas librerías, actualizaciones de Kotlin, enfoques y paradigmas que cambian con el transcurso del tiempo. Aunque no es necesario que adoptes todo lo que se ofrece, te aconsejo que te esfuerces en mantener tus conocimientos actualizados ya que, a pesar de que no encuentres casos de uso inmediatos, te servirá para poder tomar mejores decisiones a futuro.</p><p>De todos modos, mantener tu proyecto actualizado siempre es aconsejable: Aprovechas correcciones de errores, mejoras de performance, facilidad y claridad en el código y buenas prácticas en general que harán que tu proyecto no quede obsoleto y con riesgo a que ciertas características dejen de recibir soporte.</p><p>En este artículo quiero compartirte pequeñas acciones concretas que puedes tomar para reemplazar rápidamente partes de tu código de acuerdo a las nuevas recomendaciones y poder mantener tu proyecto a punto con tecnologías de vanguardia.</p><h4>findViewById no va más… ¿y entonces?</h4><p>Las formas de evitar el uso de findViewById ha mutado con el tiempo. Comenzamos por <em>ButterKnife</em>, el cual perdió sentido con la migración de Java a Kotlin ya que este introdujo <em>synthetic</em> para importar nuestros Views en el código, reduciendo gran cantidad de líneas. La mala noticia es que <em>synthetic</em> ha sido deprecado en Octubre de 2020.</p><p>Por eso, es aconsejable que comiences a eliminar su uso para prevenir problemas de compatibilidad con futuras versiones de Kotlin. Para esto, podrías utilizar <strong>View Binding</strong>. Una ventaja es que evitarás importar por error el id de un view que se encuentra en un layout que no es el que realmente necesitas. Synthetic es capaz de importarlo por el simple hecho de existir en el proyecto, pero debes colocar especial atención a corroborar que realmente está en el layout que necesitas, lo cual evitará que ocurra un NPE. Además <strong>View Binding</strong> es compatible con Kotlin y Java.</p><h4>Adiós SharedPreferences… ¡Hola DataStore!</h4><p>Esta es una migración que deberías poder realizar sin mayores complicaciones, aprovechando todo el potencial de esta nueva librería que se suma a la familia de <strong>Jetpack</strong> y que reemplaza a la antigua forma de almacenar datos en formato clave-valor en un archivo. Algunas de las ventajas son:</p><ul><li>Las operaciones de acceso al disco son realizadas en <em>background</em>, haciendo uso de las corutinas de Kotlin, lo cual representa una mejora de performance y de experiencia de uso de tu app en general.</li><li>La migración de una API a otra es relativamente sencilla ya que sus interfaces son similares.</li><li>Gracias a <em>ProtoDataStore</em> la serialización y deserialización de objetos puede ser directamente especificada, sin depender, por ejemplo, de librerías externas para convertir un objeto a JSON para ser persistido, práctica muy común utilizando <em>SharedPreferences</em>.</li></ul><h4>No más APKs ¡a producir App Bundles!</h4><p>El APK ha sido durante todos estos años el producto final del desarrollo de nuestras aplicaciones: un archivo instalable que puede ser fácilmente distribuido y, si está firmado digitalmente, ser publicado en <em>Play Store</em>. Desde 2018 se presentó <strong>App Bundle</strong> como alternativa y desde la segunda mitad de 2021 será el formato obligatorio.</p><p>El archivo <em>.aab</em> contiene los recursos y clases compiladas de la aplicación, pero es Google Play quien se encarga de la posterior firma y generación del APK. De hecho, este APK está optimizado para ciertos dispositivos en particular, por lo cual cuando los usuarios descarguen la app estarán obteniendo solamente los recursos óptimos para su dispositivo en lugar de todos los que existan en tu proyecto, lo cual deriva en una considerable reducción del tamaño del ejecutable final.</p><h4>Aprovecha las características de Kotlin</h4><p>La idea es que podamos utilizar al máximo las características de Kotlin para no depender de librerías externas. Esto, además de disminuir la inclusión de dependencias con todo lo que ello significa (reducción de tamaño del proyecto y cantidad de métodos, no depender de actualizaciones, menor riesgo de bugs introducido por código se terceros) está alineado con el enfoque de la gran apuesta de Jetbrains: <strong>Kotlin Multiplatform</strong>.</p><p>Si tienes planes de que tu código o parte de él sea portable a iOS y/o web, deberías ir tomando ciertas acciones. Por ejemplo, utilizar <strong>Flow</strong> o <strong>StateFlow</strong> en lugar de <em>LiveData</em>, <strong>Kotlinx Serialization</strong> en lugar de alguna librería como <em>Gson</em> o <em>Jackson</em>, <strong>Ktor</strong> para networking en lugar de, por ejemplo, <em>Retrofit</em> y <strong>corutinas y high order functions</strong> en lugar de <em>RxJava</em>, siempre y cuando sea posible.</p><p>Recuerda que un proyecto actualizado te evitará problemas a futuro como grandes migraciones, problemas de compatibilidad o ausencia de soporte, incluso imposibilidad de publicar en Play Store.</p><p>Con estos consejos ya tienes punto de partida ¿Por dónde empezarás?</p><h4>Enlaces de interés</h4><ul><li><a href="https://developer.android.com/topic/libraries/view-binding">View Binding</a></li><li><a href="https://developer.android.com/topic/libraries/architecture/datastore">DataStore</a></li><li><a href="https://developer.android.com/guide/app-bundle">About Android App Bundle</a></li><li><a href="https://developer.android.com/kotlin/flow">Kotlin Flows</a></li><li><a href="https://kotlinlang.org/docs/reference/serialization.html">Kotlinx Serialization</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f46ae757e78" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/moderniza-tus-apps-android-6f46ae757e78">Moderniza tu app Android</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing for developers: Working on an Android library]]></title>
            <link>https://proandroiddev.com/developing-for-developers-working-on-an-android-library-e0b49e0488b5?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0b49e0488b5</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Wed, 04 Nov 2020 23:04:57 GMT</pubDate>
            <atom:updated>2020-11-05T17:00:29.348Z</atom:updated>
            <content:encoded><![CDATA[<h4>If you want to develop an Android library or you are already working on one, these suggestions will help you to apply some good practices to achieve high quality software.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kcrqmgl2NXd3WacQ" /><figcaption>Photo by <a href="https://unsplash.com/@jruscello?utm_source=medium&amp;utm_medium=referral">Jessica Ruscello</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>This is an unified translation of the original articles published in Spanish language: <a href="https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-fc2ecae410fe">Part 1</a> and <a href="https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-ii-2cf9db6a5ee6">Part 2</a></h4><p>When talking about Android development we use to think that the product that we are creating with our code will end up as a published application. We also use to think that people that receipt our work are always the final users: they will install and use our app on their devices (smartphones, tablets, smart TVs, cars, etc).</p><p>That’s a possibility, but it’s not the only one.</p><p>In the middle of our development process, we can identify that we are finding a solution that can be useful to someone else because it solves a common problem, simplifies some kind of task, encapsulates a reusable feature, etc. So, we are in front of new opportunities: the code we are writing is not just ready to be installed on a device. It can be really useful for a lot of developers. It’s time to create a library!</p><p>Here are some suggestions that may be helpful to you.</p><h4>Think like a developer</h4><p>Of course you do. But now that you are developing a library, think like the developer that will use it. Consider the following:</p><ul><li><strong>Ease for installation and initialization (or no-initialization at all):</strong> The less mandatory steps to configure your library in order to start to use it, the best. Although it’s important to offer a certain level of customization, don’t forget to provide<em> default settings</em>.</li><li><strong>Code consistency:</strong> Follow principles to not confuse your user. Similar operations have to be done on similar ways. For example, <em>Builder</em> design pattern is often a good option to instantiate objects. This way, code is clear and offers flexibility to create complex objects specifying just the needed parameters or any other combination.</li><li><strong>Remove limitations: </strong>The usage of your library inside a project should make your user’s life easier, not to complicate it. For example, don’t abuse of some limiting features of OOP: Prioritize composition over inheritance, as the last one is more restrictive on some languages. <br>In the other hand, your implementation should not be an obstacle when writing unit tests. For example, avoid the exposure of classes with static references from your API, as they difficult the way to provide theirselves as <em>mocks</em>.</li><li><strong>Implement logging:</strong> Your library should give visibility on the operations that are being executed. Use the proper log levels. It’s important to developers to follow the processes that are running and also see what’s failing. An improvement could be to offer a <em>debug mode</em>. So, when initializing the library, the developer is able to specify if logs must be displayed or not. About the implementation, you can use a <em>log wrapper </em>that basically will decide if logs will be printed in console or not. You can implement from scratch or use an existing library like <em>Timber</em>.<br>Use <em>Exceptions </em>with clear messages if a precondition isn’t met.</li><li><strong>Avoid collisions: </strong>Ensure that your library’s code does not interfere with the application that’s using it. For example, the <em>resources </em>(<em>layouts</em>, <em>strings</em>, <em>drawables</em>, etc) could be named with a prefix to be clearly recognizable if they need to be overriden, and also it will avoid any naming conflict.</li></ul><h4>Deliver updates effectively</h4><p>Android libraries results on <em>.aar</em> files that can be installed downloading the file and manually including it inside a project. That’s not the suggested approach as you will depend on that manual action every time you want to provide an update. So, I suggest to you to use an <strong>artifact repository</strong> so your library will be available to be downloaded as a Gradle dependency. Some popular platforms are <em>Github Package</em>, <em>JitPack</em>, <em>Nexus</em> and <em>JFrog</em>.</p><p>When distributing your library that way, users can take advantage of the Android Studio’s <strong>automatic updates check</strong> that will notify them on new available versions. Also, you can provide <strong>transitive dependencies</strong> that will be automatically downloaded, keeping your library light.</p><h4>Consider backwards compatibility</h4><p>You may need to change a function signature, a class name, or delete code after a refactor. Consider that you will be affecting the compatibility with those applications that already adopted your library. For example, if you realize that you can remove some code, it would be a good practice to first mark it as <em>Deprecated</em>. You may keep it during a couple of versions to give your users some time to make the necessary changes to adopt the new API and ensure it won’t be a blocker to adopt new versions.</p><p>It is also a good practice that the naming policy you use to define versions is consistent with the changes introduced. The most common one consists of three parts: <em>Major</em>, <em>minor</em> y <em>build</em>. For example: 1.0.2. If you are consistent with your version names, your users can get a first impression of the types of changes that differentiate one version from another.</p><h4>Provide documentation</h4><p>It’s important to include set up instructions, a basic usage example and customization details to take the maximum of advantage. If it contains UI components, to include screenshots and GIFs adds a lot of value.</p><ul><li>Keep your <strong>README.md</strong> file updated. It’s the entry point of your library and it may be decisive for its adoption. Include compatibility requirements as Java version and <em>minSdkVersion </em>of Android API. Use markdowns correctly: apply proper format to code blocks. Add badges. It is sign of transparency and inspires confidency to see the build status on CI server, code coverage in terms of unit tests, latest version on artifact repository, etc.</li><li>Don’t forget to maintain a <strong>changelog</strong> containing every new feature, bugfix and breaking change. The set of all this information is commonly known as <em>release notes</em>.</li><li>Add Javadoc to your classes for easy reference during the development process.</li></ul><p>To show the capabilities and the way of use of your library, I suggest to include a <strong>sample project</strong> that can be helpful to others developers as a starting point to make quick proof of concepts and ensure that it covers the business needs.</p><h4>Modularization</h4><p>A well-known Android limitation is the number of functions that can be contained on a single DEX (~64k). Of course, <em>multidex</em> could be a solution. But at this point, we must wonder if it’s necessary to our library to contain such a large number of functions and if it could affect in a negative way the projects that uses it.</p><p>Given that, we may evaluate the possibility of <strong>separate our Android library in several modules, </strong>independant, reusable, that can be included as dependencies depending on the needs.</p><p>A clear example of this approach is the action that was taken with the <em>Play Services</em> library. It’s currently divided in different dependencies (<em>Maps</em>, <em>Cast</em>, <em>Fit</em>, etc)</p><h4>Pay attention to the security</h4><p>Although the interface of your library must be clear for its use, you must know how to separate what you want to encapsulate. Do a proper use of function access modifiers to prevent misuse.</p><p>You can even use <em>Proguard</em> to obfuscate the code that should not be visible to the programmers who will use your library. It’s usual to not use it directly. You can just document the rules that must be included on the final project instead.</p><p>One more thing: when possible, you may offer a channel where users can collaborate with you, giving feedback. They will help you with ideas and bugs reporting. As it happens on all the development processes, keep in mind that it will be changing. Provide support and keep it updated.</p><p>So, you are now ready to develop your library. The developer’s community will be really thankful!</p><h4>Useful links</h4><ul><li><a href="https://developer.android.com/studio/projects/android-library">Create an Android Library</a></li><li><a href="https://en.m.wikipedia.org/wiki/Software_versioning">Software versioning</a></li><li><a href="https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html">How to write Doc comments for the Javadoc tool</a></li><li><a href="https://github.com/JakeWharton/timber">Timber</a></li><li><a href="https://developer.android.com/studio/projects">Projects overview — Modules</a></li><li><a href="https://www.markdownguide.org/basic-syntax/">Markdown basic syntax</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0b49e0488b5" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/developing-for-developers-working-on-an-android-library-e0b49e0488b5">Developing for developers: Working on an Android library</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[Programar para programadores: Desarrollando una librería Android (II)]]></title>
            <link>https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-ii-2cf9db6a5ee6?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cf9db6a5ee6</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android-libraries]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Mon, 19 Oct 2020 21:23:40 GMT</pubDate>
            <atom:updated>2020-10-26T15:14:35.962Z</atom:updated>
            <content:encoded><![CDATA[<h4>En mi anterior artículo compartí algunos consejos que pueden resultar útiles cuando se está trabajando en el desarrollo de una librería Android. Aquí pretendo agregar algunos detalles más a ser tenidos en cuenta.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eGW9e9XnEkkYmjuY" /><figcaption>Photo by <a href="https://unsplash.com/@markuswinkler?utm_source=medium&amp;utm_medium=referral">Markus Winkler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>En la línea del desarrollo de librerías en Android y más allá de los detalles técnicos que puedan surgir, hay algunos detalles que no tenemos que perder de vista: el foco está puesto en que nuestra librería resulte ser un producto de calidad. Entre las características que queremos que tenga, podemos mencionar que sea mantenible, seguro, testeable, bien documentado, útil y que su adopción no afecte negativamente el desarrollo del producto por parte de quien la esté actualizando.</p><p>Si los consejos de <a href="https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-fc2ecae410fe">mi anterior artículo</a> te parecieron de utilidad, quiero decirte que ¡hay más! por lo cual, veamos en qué otros puntos podemos poner nuestra atención.</p><h4>Modularización</h4><p>Una limitación conocida de Android es que se presenta en relación a la cantidad de métodos que pueden ser contenidos en un único <em>DEX </em>(64.000 aprox). Desde ya que una solución es habilitar <em>multidex. </em>Pero en este punto sería razonable preguntarnos si es correcto que nuestra librería contenga una cantidad de métodos dada y si esto puede afectar negativamente a quién la use.</p><p>Dada esta situación y en caso de que no se pueda reducir demasiado, se puede evaluar la posibilidad de <strong>separar nuestra librería en módulos</strong> independientes y reutilizables que puedan ser incluidos como dependencias separadas según necesidad.</p><p>Un claro ejemplo que tenemos de esta situación es la acción que realizó Google con la antigua librería de <em>Play Services </em>la cual actualmente está dividida en distintas dependencias (Maps, Cast, Fit, etc).</p><h4>Proguard</h4><p>Si bien la ofuscación de código es una operación prácticamente obligatoria en lo que respecta a la seguridad de nuestro producto, puede resultar una dificultad a la hora de hacer seguimiento de la ejecución del código de nuestra librería por parte de quien la esté utilizando.</p><p>Una medida que podemos tomar para evitar este problema es, en lugar de aplicar Proguard directamente en la librería, ofrecer detalles en la documentación de cuáles son las <strong>reglas</strong> específicas que se deben incluir para securizar su uso. Esta especificación debe ser un <em>snippet </em>del código que debe ser incluido en el archivo de configuración de Proguard y un buen lugar para colocarlo es en el archivo README.md<em> </em>o en la documentación específica de uso.</p><h4>Tips para tu README.md</h4><ul><li>Especifica detalles de compatibilidad, especialmente la versión de Java y el <em>minSdkVersion </em>ya que la versión de la API de Android puede ser un punto decisivo para la adopción de la librería.</li><li>Haz un buen uso de <em>markdowns</em>. Separa distintas secciones y aplica formato a los bloques de código fuente que proporciones como ejemplo.</li><li>Puedes agregar algunos <em>badges </em>como el enlace al repositorio de artefactos que especifique cuál es la versión actual de tu librería, el estado del último build en el servidor de integración continua o el porcentaje de cobertura de tests. En general puedes encontrar el markdown para incluir un badge en la documentación del producto que estés usando (Maven badges, Travis CI, etc).</li></ul><h4>Modo debug</h4><p>En mi anterior artículo mencioné la importancia de dar visibilidad a nuestros usuarios sobre las operaciones que nuestra librería ejecuta e indiqué que una buena forma de hacer esto es haciendo uso de la impresión de mensajes en consola a través del Log.</p><p>Sería mejor aún si nuestra librería puede configurarse para habilitarlos o deshabilitarlos bajo ciertas condiciones. Por ejemplo, deshabilitar esos mensajes es una práctica recomendada cuando se realiza un <em>build</em> de <em>release </em>ya que no es deseable que estos mensajes puedan ser visibles por cualquier usuario que tenga instalada la versión productiva en su dispositivo.</p><p>Teniendo en cuenta esto, un consejo que puedo darte es ofrecer la opción de inicializar la librería especificando si se la utilizará en <strong>Modo debug</strong>. De ser así, la aplicación imprimirá los logs normalmente. En caso contrario, no.</p><p>A modo implementación, lo más sencillo es introducir un <em>wrapper</em> para logs que decida si debe efectivamente imprimir el mensaje en consola o no, o bien utilizar una librería configurable como <em>Timber.</em></p><p>Desde mi punto de vista, la clave se encuentra en entender que cuando desarrollamos una librería debemos tener una visión global del producto que estamos desarrollando: No sólo queremos que resuelva un problema, también queremos que la experiencia de uso sea óptima antes, durante y después de su adopción. Si perseguimos este objetivo, seguramente daremos pasos acertados.</p><p>Espero que mis consejos te resulten útiles para poder tomar las decisiones adecuadas que apliquen a tu proyecto.</p><h4>Enlaces útiles</h4><ul><li><a href="https://github.com/JakeWharton/timber">Timber</a></li><li><a href="https://developer.android.com/studio/projects">Projects overview — Modules</a></li><li><a href="https://www.markdownguide.org/basic-syntax/">Markdown basic syntax</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cf9db6a5ee6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-ii-2cf9db6a5ee6">Programar para programadores: Desarrollando una librería Android (II)</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programar para programadores: Desarrollando una librería Android]]></title>
            <link>https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-fc2ecae410fe?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc2ecae410fe</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-libraries]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Wed, 23 Sep 2020 21:46:56 GMT</pubDate>
            <atom:updated>2020-09-23T22:08:20.620Z</atom:updated>
            <content:encoded><![CDATA[<h4>Si quieres escribir una librería o ya estás trabajando en una, estos consejos te orientarán sobre algunas prácticas recomendadas para lograr un software de calidad.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kcrqmgl2NXd3WacQ" /><figcaption>Photo by <a href="https://unsplash.com/@jruscello?utm_source=medium&amp;utm_medium=referral">Jessica Ruscello</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Cuando hablamos de desarrollo Android, es habitual pensar que el producto resultante del código que producimos es una aplicación. En general entendemos que el público receptor de nuestro trabajo son los usuarios finales: Personas con nuestra app instalada en sus dispositivos (celulares, tablets, TVs, automóviles, etc).</p><p>Y esa es una posibilidad, pero no es la única.</p><p>En medio de nuestro proceso de desarrollo, puede que identifiquemos que una solución que encontramos puede servirle a alguien más porque resuelve un problema común, simplifica algún tipo de tarea, encapsula alguna funcionalidad reutilizable, etc. Entonces se nos abren nuevas posibilidades: el código que escribimos ya no solamente está listo para ser instalado en un dispositivo, sino que puede ser de utilidad para muchos otros desarrolladores. ¡Es el momento de crear una librería!</p><p>A continuación enumero algunos consejos que pueden resultarte de utilidad.</p><h4>Piensa como desarrollador</h4><p>Claro que es lo que haces siempre, pero ahora que estás desarrollando tu librería, ponte en el lugar del programador que va a utilizarla. Algunos puntos que tienes que tener en cuenta son:</p><ul><li><strong>Facilidad de instalación y simple (o nula) inicialización:</strong> Mientras menos pasos de configuración obligatorios tenga tu librería para comenzar a ser utilizada, mucho mejor. Si bien es importante que tenga cierto nivel de personalización, no olvides ofrecer configuraciones por <em>default.</em></li><li><strong>Coherencia en el código: </strong>Respeta ciertos principios para no confundir a tu usuario. Intenta que operaciones similares, se realicen de la misma forma. Por ejemplo, para instanciar objetos, el patrón de diseño <em>Builder</em> suele ser una buena opción ya que el código se expresa con claridad y da la flexibilidad de crear objetos complejos especificando todos o sólo algunos parámetros.</li><li><strong>Quita limitaciones:</strong> La incorporación de tu librería a un proyecto debe facilitarle la vida a tus usuarios, no complicarla. Por ejemplo, no hagas excesivo uso de características limitantes de la POO: Prioriza la composición por sobre la herencia ya que esta última suele ser restrictiva en ciertos lenguajes. <br>Por otro lado, tu implementación no debe limitar el modo en que los desarrolladores escriben <em>unit tests</em>. Por ejemplo, evita que tu API exponga clases con referencias estáticas ya que dificultan el modo de ser provistos en forma de <em>mocks.</em></li><li><strong>Haz uso del Log: </strong>Otorga visibilidad de las operaciones que tu librería está efectuando. Utiliza los niveles de Log correctos. Es importante que los desarrolladores puedan hacer seguimiento de qué está ocurriendo e incluso qué está fallando. Haz uso de <em>Exceptions </em>con mensajes claros si alguna precondición de tu código no se está cumpliendo durante su uso.</li><li><strong>Evita colisiones: </strong>Asegúrate de que el código de tu librería no interfiera con el de la aplicación que la use. Por ejemplo, tus <em>resources </em>(<em>layouts</em>, <em>strings</em>, <em>drawables</em>, etc) podrían ser nombrados con un prefijo para que sean claramente identificables si necesitan ser sobreescritos y además, para que no ocurran conflictos de nombres.</li></ul><h4>Distribuye actualizaciones ágilmente</h4><p>Las librerías en Android resultan ser archivos <em>.aar </em>que pueden ser instaladas descargando el archivo e incluyéndolo manualmente en el proyecto aunque ésta no es la opción más conveniente ya que cada vez que quieras ofrecer una actualización dependerás de esta acción manual. Por eso es aconsejable que hagas uso de un <strong>repositorio de artefactos </strong>para que tu librería pueda ser descargada como una dependencia de Gradle. Algunos de los más populares son <em>Github Package</em>, <em>JitPack</em>, <em>Nexus</em> o <em>JFrog</em>.</p><p>Si distribuyes tu librería de esta forma, puedes aprovechar el <strong>chequeo de actualizaciones automático </strong>de Android Studio que notificará a tus usuarios sobre nuevas versiones. Además, puedes proveer <strong>dependencias transitivas </strong>que se descargarán automáticamente,<strong> </strong>manteniendo tu librería liviana.</p><h4>Piensa en la retrocompatibilidad</h4><p>Puede que tengas la necesidad de cambiar la firma de una función, el nombre de una clase, o borrar código después de un refactor. Ten en cuenta que estarás afectando la compatibilidad de aquellas aplicaciones que ya han adoptado tu librería. Por lo cual, por ejemplo, si identificas código que puede ser removido, sería una buena práctica que primero lo marques como <em>Deprecated</em>. Puedes mantenerlo durante algunas versiones más para darle tiempo a tus usuarios de que se adapten a la nueva API y asegurarte de que esto no sea un limitante para adoptar nuevas versiones.</p><p>Además es una buena práctica que la notación que utilices para definir versiones se condiga con los cambios introducidos. La notación más común consta de tres partes: <em>Major</em>, <em>minor</em> y <em>build</em>. Por ejemplo: 1.0.2. Si eres coherente en tu versionado, tus usuarios podrán obtener una primera impresión de los tipos de cambios que diferencian una versión de otra.</p><h4>Proporciona documentación</h4><p>Es importante que tu librería esté acompañada de instrucciones de configuración, algún ejemplo de uso básico y detalles de personalización para sacarle el máximo provecho. Si posee componentes gráficos las capturas de pantalla y los GIF suman mucho valor.</p><ul><li>Mantén un archivo <strong>README.md </strong>actualizado. Es el punto de entrada a tu librería y puede ser decisivo para su adopción o no.</li><li>No olvides llevar un registro de <strong>Changelog </strong>que detalle correctamente las nuevas funcionalidades incluidas, los bugs solucionados e incluso los <em>breaking changes</em>. El conjunto de toda esta información es comúnmente conocido como <em>release notes</em>.</li><li>Añade <em>Javadoc </em>a tus clases para facilitar su consulta durante el proceso de desarrollo.</li></ul><p>Además, para demostrar los posibles usos y el poder de tu librería, te recomiendo que la acompañes de un proyecto <em>sample</em> que pueda servir a otros programadores como punto de partida para hacer pruebas rápidas y asegurarse de que cumple con las necesidades del negocio.</p><h4>Pon atención en la seguridad</h4><p>Aunque la interfaz de tu librería debe ser clara para su uso, sabe separar aquello que quieres encapsular. Utiliza correctamente los modificadores de acceso de las funciones para prevenir el mal uso. Incluso, puedes utilizar <em>Proguard </em>para ofuscar el código que <strong>no debe </strong>ser visible para los programadores que utilizarán tu librería.</p><p>Un consejo más es que en la medida de lo posible ofrezcas algún medio por el cual tus usuarios puedan colaborar dándote <em>feedback. </em>Sin duda te ayudarán a mejorar proporcionando ideas y reportando <em>bugs</em>. Como en todo desarrollo de software, entiende que es un proceso y será cambiante. Ofrece soporte y manténla actualizada.</p><p>Ya estás listo para escribir tu librería. ¡La comunidad de desarrolladores seguramente te lo agradecerá!</p><h4>Enlaces útiles</h4><ul><li><a href="https://developer.android.com/studio/projects/android-library">Create an Android Library</a></li><li><a href="https://en.m.wikipedia.org/wiki/Software_versioning">Software versioning</a></li><li><a href="https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html">How to write Doc comments for the Javadoc tool</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc2ecae410fe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/programar-para-programadores-desarrollando-una-librer%C3%ADa-android-fc2ecae410fe">Programar para programadores: Desarrollando una librería Android</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cómo escribir tests unitarios de corutinas]]></title>
            <link>https://medium.com/droid-latam/c%C3%B3mo-escribir-tests-unitarios-de-corutinas-8290dba5ffa4?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/8290dba5ffa4</guid>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[coroutine-testing]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Tue, 01 Sep 2020 21:09:09 GMT</pubDate>
            <atom:updated>2020-09-01T21:18:23.690Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oi0iODqzr07T0lcz" /><figcaption>Photo by <a href="https://unsplash.com/@mreichelt?utm_source=medium&amp;utm_medium=referral">Marc Reichelt</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>La forma de desarrollar aplicaciones en Android ha evolucionado a través del tiempo. Como bien sabemos, en las aplicaciones modernas se adoptan distintos patrones de arquitectura que tienen como objetivo organizar mejor nuestro código, establecer responsabilidades acotadas y facilitar la creación de tests unitarios.</p><p>Sea cual sea el patrón que decidas usar, el principio es similar: quitar lógica de negocio de nuestras actividades y fragmentos y delegar ese comportamiento a clases independientes del framework (como un Presenter en MVP, o un ViewModel en MVVM). Con “independientes del framework” nos referimos a que no deben tener referencias a, por ejemplo, instancias de `Context`, `Activity`, `Fragment`, etc. Y cuando logramos este desacoplamiento y diseñamos correctamente, resulta muy sencillo realizar tests unitarios ya que terminamos probando funciones de lógica acotada.</p><p>Esto fluye naturalmente cuando probamos funciones que realizan un procesamiento secuencial en el <em>thread</em> principal. Pero demos un paso más: Kotlin introdujo las corutinas. Desde Agosto del 2020, esta es la forma recomendada por Google de hacer trabajo en segundo plano en Android. A grandes rasgos, es una forma de ejecutar código de forma asíncrona, con la posibilidad de especificar en qué hilo queremos que realice cada una de las sentencias.</p><h4>El concepto de Dispatcher</h4><p>Las corutinas se encuentran definidas en lo que se conoce como <em>Coroutine Context </em>el cual especifica mediante un <em>dispatcher</em> en qué hilo de ejecución se ejecutarán sus funciones. Por ejemplo, utilizamos <strong>Dispatchers.Main </strong>para aquellos procesos que deban ser ejecutados en el <em>main thread</em> (como actualizaciones en la UI) y <strong>Dispatchers.IO</strong> para operaciones que se realicen en <em>background</em> por requerir una mayor duración (como accesos a la base de datos u operaciones de red).</p><p>Cada sentencia de una corutina será ejecutada en el hilo especificado, lo que hace que esto pueda cambiar constantemente por lo cual la misma función puede ejecutar algunas tareas en primer o segundo plano.</p><p>Por ejemplo:</p><pre><em>CoroutineScope</em>(Dispatchers.<strong>IO</strong>).<em>launch </em><strong>{<br>    // Las tareas que estén aquí se realizarán en background<br>    </strong>withContext(Dispatchers.<strong>Main</strong>) <strong>{<br>        // Este bloque cambiará su ejecución al hilo de la UI<br>    }<br>    // Se vuelve a background para ejecutar lo que haya aquí<br>}</strong></pre><h3>Tests unitarios</h3><p>Es importante incluir tests unitarios de las funciones de tu proyecto que contengan lógica de negocio. El hilo en el cual se ejecuten no debería ser un impedimento.</p><p>Lo primero que debes hacer para comenzar a trabajar es añadir la siguiente dependencia:</p><pre>testImplementation <strong>&quot;org.jetbrains.kotlinx:kotlinx-coroutines-test:</strong>$<strong>{</strong>coroutinesVersion<strong>}&quot;</strong></pre><h4>Escribiendo el test</h4><p>El primer obstáculo que enfrentaremos derivará en un error de compilación. Como bien sabemos, una corutina puede ser lanzada desde otra corutina o bien, desde una <em>suspend function</em>. Por supuesto que nuestros tests, como los solemos hacer, no cumplen con esas condiciones, por lo cual, debemos proveer de un <em>scope </em>que nos permita invocar una corutina dentro de él. Para ello utilizaremos <strong>TestCoroutineScope</strong>. Simplemente declaramos nuestro test de la siguiente forma:</p><pre>@Test<br><strong>fun </strong>`la ejecucion de mi corutina es correcta`() {<br>    <em>runBlockingTest </em><strong>{<br>        // Estructura típica de un test unitario</strong><br>    <strong>}<br></strong>}</pre><p>Básicamente, `runBlockingTest` permite que puedas ejecutar <em>suspend functions</em> en tu test, con lo cual nos deshacemos del error de compilación. ✔️</p><h4>Ejecutando el test</h4><p>A la hora de escribir nuestros tests unitarios, enfrentamos el problema de que el código que estamos tratando de probar, debe ejecutarse de forma secuencial. Cuando tenemos bloques que se ejecutan en background, el test no tiene la capacidad de <em>esperar </em>a que termine para posteriormente evaluar el resultado. Lo que sucederá al ejecutarlo es un error de este tipo:</p><p><strong>java.lang.IllegalStateException: This job has not completed yet</strong></p><p>Esto quiere decir que la ejecución del test finalizó… ¡pero la corutina aún continúa haciendo su trabajo! Y esto tiene sentido, ya que puede estar ejecutando funciones en el <em>background thread</em>.</p><p>Como vimos anteriormente, el hilo de ejecución lo decide el <strong>CoroutineDispatcher </strong>que estemos asignando. Por lo tanto, debemos proporcionar un dispatcher de forma que podamos usarlo únicamente en nuestros tests.</p><p>Para esto, usaremos una instancia de `TestCoroutineDispatcher`.</p><p>Resulta una buena práctica inyectar la instancia del <strong>CoroutineDispatcher</strong> ya sea mediante el constructor de la clase o como parámetro de la función que lo usará. Gracias a Kotlin, podemos definir un dispatcher default, y proporcionar uno distinto sólo en nuestras pruebas. De esta forma, una función de este tipo:</p><pre><strong>fun </strong>execute() {<br>    <em>CoroutineScope</em>(Dispatchers.<strong>IO</strong>).<em>launch </em><strong>{<br>        // Bloque a ejecutarse en background thread<br>    }<br></strong>}</pre><p>podría transformarse a una así:</p><pre><strong>fun </strong>execute(dispatcher: CoroutineDispatcher = Dispatchers.<strong>IO</strong>) {<br>    <em>CoroutineScope</em>(dispatcher).<em>launch </em><strong>{<br>        // Bloque a ejecutarse, por default, en background thread<br>    }<br></strong>}</pre><p>Como el parámetro tiene un valor por <em>default</em>, continuará respetando la firma anterior, por lo cual no afectará a los usos actuales que pueda tener. Y nos permitirá realizar un test de esta forma:</p><pre>@Test<br><strong>fun </strong>`la ejecucion de mi corutina es correcta`() {<br>    <em>runBlockingTest </em><strong>{<br>        </strong>theInstance.execute(<strong>TestCoroutineDispatcher()</strong>)<br>    <strong>}<br></strong>}</pre><p>Gracias a ello, sólo en el contexto de nuestras pruebas, el código se ejecutará de forma secuencial ✔️</p><p>¡Ya no hay excusas! ¡A testear corutinas!</p><h3>Enlaces de interés</h3><ul><li><a href="https://kotlinlang.org/docs/reference/coroutines-overview.html">Documentación oficial: Kotlin coroutines</a></li><li><a href="https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/">Documentación de la dependencia kotlinx-coroutines-test</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8290dba5ffa4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/c%C3%B3mo-escribir-tests-unitarios-de-corutinas-8290dba5ffa4">Cómo escribir tests unitarios de corutinas</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tu aplicación Android de Java a Kotlin ¿Por dónde empezar?]]></title>
            <link>https://medium.com/droid-latam/tu-aplicaci%C3%B3n-android-de-java-a-kotlin-por-d%C3%B3nde-empezar-6190a8f6a16b?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/6190a8f6a16b</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Wed, 12 Aug 2020 14:34:38 GMT</pubDate>
            <atom:updated>2020-08-12T21:46:11.230Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wahlqSgUIsehRAHl" /><figcaption>Photo by <a href="https://unsplash.com/@indiablue?utm_source=medium&amp;utm_medium=referral">Stephen Frank</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Ya es de público conocimiento que Kotlin es el lenguaje de programación estándar para desarrollar en Android. Es totalmente retrocompatible con Java, fue reconocido por Google durante el evento Google I/O 2017 y hoy en día se presentan librerías en modo <em>Kotlin first</em>,<em> </em>es decir, permitiendo aprovechar las ventajas de este lenguaje.</p><p>Pero antes de llegar al punto de poder obtener el máximo provecho de Kotlin hay un camino que recorrer. Es necesario saber que aún hay muchos equipos de desarrollo manteniendo aplicaciones que ya llevan varios años de existencia y que, naturalmente, han sido escritas en Java. Entonces, si este es tu caso y te gustaría comenzar a convertir tu aplicación a Kotlin, es esperable que tu inquietud sea: <strong>¿Por dónde empiezo?</strong></p><p>Es importante que, para estar tomar la decisión sin miedo, sepas que:</p><ul><li>Kotlin es compatible con Java: Es decir, puedes comenzar convirtiendo algunas pocas clases y tu proyecto continuará funcionando. Es normal que en tus proyectos convivan ambos lenguajes.</li><li>Para comenzar, no necesitas total conocimiento sobre el lenguaje. Android Studio contiene una herramienta de conversión automática de Java a Kotlin que se ejecuta cuando pegas código Java en un archivo <em>.kt </em>o bien puedes ejecutar manualmente seleccionando cualquier archivo<em> .java </em>y seleccionando <em>Convert Java file to Kotlin file</em>. Es recomendable que reescribas tu código a conciencia, pero si estás en una etapa de aprendizaje, esto puede ayudarte con tus primeros pasos. Adicionalmente es posible que el código generado requiera algunas modificaciones para su optimización.</li><li>Para mantener el ritmo de aprendizaje y llevar a cabo definitivamente la migración de tu proyecto a Kotlin, te recomiendo que cada vez que tengas que escribir una clase nueva, tomes como desafío escribirla en Kotlin. Al principio puede resultarte complicado, pero recuerda que tus conocimientos de Java son totalmente aprovechables. Puede llevarte un tiempo acostumbrarte a la nueva sintaxis, pero como todo, es cuestión de práctica.</li></ul><p>En este artículo aprenderás a migrar a Kotlin las clases más simples de tu proyecto, para familiarizarte con el lenguaje aplicado a tus clases más cortas y menos complejas.</p><h3>Entidades o clases de modelo</h3><p>Uno de los primeros cambios que puedes llevar a cabo, es migrar a Kotlin tus entidades de modelo y DTOs. Todas las clases que simplemente contengan sus atributos, <em>getters</em> y <em>setters </em>pueden ser fácilmente convertidas a una <strong>data class</strong>.</p><p>Veamos un ejemplo. Si tenemos una clase con el siguiente formato:</p><pre><strong>public class </strong>Usuario <strong>implements</strong> Serializable {<br><br>    <strong>private </strong>String <strong>nombre</strong>;<br>    <strong>private </strong>Long <strong>id</strong>;<br>    @SerializedName(&quot;urlAvatar&quot;)<br>    <strong>private </strong>String <strong>avatar</strong>;<br>    <br>    <strong>public </strong>String getNombre() {<br>        <strong>return nombre</strong>;<br>    }<br><br>    <strong>public void </strong>setNombre(String nombre) {<br>        <strong>this</strong>.<strong>nombre </strong>= nombre;<br>    }<br><br>    <strong>public </strong>Long getId() {<br>        <strong>return id</strong>;<br>    }<br><br>    <strong>public void </strong>setId(Long id) {<br>        <strong>this</strong>.<strong>id </strong>= id;<br>    }<br><br>    <strong>public </strong>String getAvatar() {<br>        <strong>return avatar</strong>;<br>    }<br><br>    <strong>public void </strong>setAvatar(String avatar) {<br>        <strong>this</strong>.<strong>avatar </strong>= avatar;<br>    }<br>}</pre><p>podemos convertirla a:</p><pre><strong>data class </strong>Usuario (<br>    <strong>var nombre</strong>: String?,<br>    <strong>var id</strong>: Long?, <br>    @SerializedName(&quot;urlAvatar&quot;) <br>    <strong>var avatar</strong>: String?) : Serializable</pre><p><strong>A saber: </strong>Kotlin introduce el concepto de <strong>data class</strong>. Es decir, clases que “guardan” datos. Los <em>getter</em> y <em>setters</em> son generados automáticamente. Pero no solamente eso: Además genera automáticamente los métodos hashCode(), equals()<em>, </em>toString() y<em> </em>copy()<em>.</em></p><p>De esta forma, puedes comenzar convirtiendo, por ejemplo, las clases que modelan el <em>body</em> de un <em>request</em> o un <em>response</em>.</p><h3>Interfaces</h3><p>Puedes comenzar la migración en las partes de tu proyecto que contengan menos (o nada de) lógica. Además de las clases de modelo, puedes convertir las interfaces.</p><p>Por ejemplo, partiendo de un ejemplo como el siguiente:</p><pre><strong>public interface </strong>RepositorioUsuarios {<br>    List&lt;Usuario&gt;<strong> </strong>obtenerTodos();<br>    Usuario<strong> </strong>obtener(Long id);<br>    void guardar(Usuario usuario);<br>}</pre><p>podríamos convertirlo a:</p><pre><strong>interface </strong>RepositorioUsuarios {<br>    <strong>fun </strong>obtenerTodos(): List&lt;Usuario&gt;<br>    <strong>fun </strong>obtener(id: Long?): Usuario?<br>    <strong>fun </strong>guardar(usuario: Usuario)<br>}</pre><p><strong>A saber: </strong>Este es un ejemplo típico en el cual la migración no conlleva grandes modificaciones. Sin embargo, el concepto de interfaz en Kotlin difiere del de Java. Una gran diferencia es que en Kotlin las interfaces permiten incluir implementación de sus funciones.</p><h3>Singleton</h3><p>Seguramente tu proyecto contiene alguna o varias clases <em>util </em>o, por ejemplo, el cliente de networking, que pueden estar implementados siguiendo el patrón de diseño <em>Singleton</em>. Kotlin ha facilitado la implementación de este patrón, permitiéndonos definir una única instancia de cierta clase.</p><p>Supongamos que queremos migrar una clase como la siguiente:</p><pre><strong>public class </strong>FechaUtil {<br><br>    <strong>private static final </strong>FechaUtil <strong><em>instance </em></strong>= <strong>new </strong>FechaUtil();<br><br>    <strong>private </strong>FechaUtil() {}<br><br>    <strong>public static </strong>FechaUtil getInstance() {<br>        <strong>return <em>instance</em></strong>;<br>    }<br><br>    <strong>public </strong>String format(Date date) {<br>        <strong>return new </strong>SimpleDateFormat(<strong>&quot;dd/MM/yyyy&quot;</strong>).format(date);<br>    }<br>}</pre><p>Podríamos obtener una versión en Kotlin que quedaría de la siguiente forma:</p><pre><strong>object </strong>FechaUtil {<br>    <br>    <strong>fun </strong>format(date: Date) = <br>         SimpleDateFormat(<strong>&quot;dd/MM/yyyy&quot;</strong>).format(date)<br>}</pre><p><strong>A saber:</strong> Kotlin introduce el concepto de <strong>object </strong>que permite definir una única implementación de un objeto que será accesible desde todo el proyecto, como una única instancia. Es decir, siguiendo el patrón de diseño <em>Singleton</em>.</p><p>Los anteriores ejemplos han sido algunos consejos de cambios fáciles que podemos realizar, en líneas generales, rápidamente como para comenzar a introducir código Kotlin en nuestro proyecto. ¡Desde luego que hay mucho más por hacer!. Algunas consideraciones que puedes tener en cuenta para dar algunos pasos más son:</p><ul><li>Convirtiendo nuestras actividades o fragmentos a Kotlin, podemos deshacernos de los molestos findViewById()<em> </em>o<em>, </em>si la utilizas, de la librería<em> Butterknife </em>y acceder a los <em>Views</em> de tu layout directamente por id. Verás que se importará automáticamente:</li></ul><pre><strong>import </strong>kotlinx.android.synthetic.main.actividad_login.*</pre><ul><li>Convertir tus adapters (de <em>RecyclerView</em> o <em>ViewPagers</em>, por ejemplo) debería resultarte relativamente sencillo, ya que usualmente en esas clases encontramos código <em>boilerplate </em>que Kotlin puede ayudarte a escribir en menos líneas.</li><li>Haciendo uso de la librería <em>Android KTX</em> (<em>Kotlin extensions</em>) puedes lograr mejoras en la claridad de tu código. Por ejemplo, veamos cómo podemos cambiar la visibilidad de un View desde Java:</li></ul><pre>opcion1.setVisibility(View.<strong><em>VISIBLE</em></strong>)</pre><p>y cómo podemos reducir la expresión gracias a KTX:</p><pre>opcion1.isVisible = <strong>true</strong></pre><p>Espero que estos consejos te hayan servido como motivación para iniciar la migración de tu proyecto. ¡Realmente vale la pena!</p><h3>Enlaces de interés</h3><ul><li><a href="https://kotlinlang.org/docs/reference/data-classes.html">Documentación oficial: Kotlin Data Class</a></li><li><a href="https://kotlinlang.org/docs/reference/interfaces.html">Documentación oficial: Kotlin interfaces</a></li><li><a href="https://kotlinlang.org/docs/reference/object-declarations.html">Documentación oficial: Kotlin objects</a></li><li><a href="https://developer.android.com/kotlin/ktx">Android KTX: Kotlin Extensions</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6190a8f6a16b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/tu-aplicaci%C3%B3n-android-de-java-a-kotlin-por-d%C3%B3nde-empezar-6190a8f6a16b">Tu aplicación Android de Java a Kotlin ¿Por dónde empezar?</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reglas de seguridad en Cloud Firestore: Protección de escritura en campos de un documento]]></title>
            <link>https://medium.com/droid-latam/reglas-de-seguridad-en-cloud-firestore-protecci%C3%B3n-de-escritura-en-campos-de-un-documento-a3069ad3d4d7?source=rss-68bf06349384------2</link>
            <guid isPermaLink="false">https://medium.com/p/a3069ad3d4d7</guid>
            <category><![CDATA[cloud-firestore]]></category>
            <category><![CDATA[firestore]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[firebase-firestore]]></category>
            <category><![CDATA[firebasesecurityrules]]></category>
            <dc:creator><![CDATA[Maribel Maisano]]></dc:creator>
            <pubDate>Fri, 21 Feb 2020 20:59:28 GMT</pubDate>
            <atom:updated>2020-05-01T18:38:27.789Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OzGu7_NpamIN0CjZ" /><figcaption>Photo by <a href="https://unsplash.com/@zenking?utm_source=medium&amp;utm_medium=referral">Rob King</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Si haces uso de la base de datos en tiempo real de Firebase en tus aplicaciones, es posible que alguna vez hayas recibido la notificación de que tu implementación contiene reglas inseguras. Esto quiere decir que los documentos de tu base de datos son accesibles sin límite de algún tipo. De esta forma, cualquier usuario malintencionado que logre averiguar el ID de tu proyecto será capaz de leer, modificar o borrar los datos.</p><p>Pero ¿qué tipo de seguridad podemos aplicar entonces?</p><p>Para comenzar a comprender, debemos saber que podemos limitar cuatro tipos de operaciones sobre nuestros documentos:</p><ul><li>Lectura</li><li>Creación</li><li>Modificación</li><li>Borrado</li></ul><p>Las reglas que podemos aplicar se encuentran fuertemente ligadas a la implementación de Firebase Authentication en nuestra aplicación, ya que de esta manera podemos saber <strong>cuál es el usuario</strong> que intenta realizar una operación y saber si<strong> tiene permiso</strong> para hacerla o no.</p><p>Escribiremos nuestras reglas desde la consola de Firebase o bien localmente para luego desplegarlas a través de Firebase CLI. De ambas formas, la sintaxis es la misma.</p><h3>Ejemplo de aplicación de reglas</h3><p>Tomemos el ejemplo de una aplicación de tipo multijugador. Tendremos una colección de partidas que contendrá, entre otra información, el uid de cada jugador que participa y el puntaje de cada uno de ellos como campos que llamaremos: idJugador1, idJugador2, puntajeJugador1, puntajeJugador2.</p><p>Definamos inicialmente las reglas que permiten que cualquier jugador que haya iniciado sesión puede leer la tabla partidas y crear nuevas, pero ninguno de ellos puede borrar una partida:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1a5727ed8a11c1c1d7f798290c628214/href">https://medium.com/media/1a5727ed8a11c1c1d7f798290c628214/href</a></iframe><p>Observemos que debemos especificar la ruta de la colección que queremos limitar y las operaciones por separado. Dentro de request.auth tenemos información sobre el usuario que está realizando la petición. Estas reglas que especificamos son a nivel documento.</p><p>Ahora digamos que queremos restringir la operación de edición para que cada usuario pueda modificar únicamente el puntaje que le pertenece y no el de su oponente. Comencemos por especificar que si el request proviene del jugador 1 solamente puede modificar el campo puntajeJugador1.</p><p>Para ello, vamos a definir una función que:</p><ol><li>Verifique cuál es el puntaje que se está intentando modificar.</li><li>Decida si el usuario que está intentando hacerlo tiene permiso.</li></ol><p>Por el momento, para saber cuál es el campo que se está queriendo modificar en la petición, la única forma que tenemos de hacerlo es comprobar si el valor que está contenido en la base de datos difiere del que proviene del request. Accedemos a los campos del documento guardado a través de resource.data<strong> </strong>y al payload del request en request.resource.data. Para saber si se está modificando el campo puntajeJugador1 o puntajeJugador2 compararemos los valores de la base de datos con los del request. Por último, dependiendo cuál sea, comprobaremos si el uid del usuario que intenta hacer la modificación coincide con el usuario dueño de ese puntaje.</p><p>Nuestras reglas actualizadas quedarían de la siguiente forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/67a50dffc8dc9ba6ce8e352ad62317e2/href">https://medium.com/media/67a50dffc8dc9ba6ce8e352ad62317e2/href</a></iframe><p>De esta forma hemos logrado que:</p><ul><li>Cualquier usuario que haya iniciado sesión pueda leer las partidas y crear nuevas</li><li>Ningún usuario pueda eliminar partidas</li><li>Un usuario pueda modificar el puntaje solamente si le pertenece.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3069ad3d4d7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/droid-latam/reglas-de-seguridad-en-cloud-firestore-protecci%C3%B3n-de-escritura-en-campos-de-un-documento-a3069ad3d4d7">Reglas de seguridad en Cloud Firestore: Protección de escritura en campos de un documento</a> was originally published in <a href="https://medium.com/droid-latam">Droid LATAM</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>