DEV Community: Jorge Castro

Triggering Jenkins Jobs Remotely via API with Ease

Jorge Castro — Sat, 24 Aug 2024 23:53:41 +0000

👋 Hello everyone! In this article, I’ll guide you through the process of remotely triggering Jenkins builds with ease. Whether you’re automating deployments 🚀, integrating with other tools 🔗, or simply looking to streamline your workflow 🛠️, knowing how to execute Jenkins jobs remotely can be a powerful addition to your toolkit. Let’s dive into the steps and best practices to make this process as smooth and efficient as possible.

Step 1: Create a New User

From the Jenkins dashboard, click on Manage Jenkins on the left side.
In the Manage Jenkins page, click on Users option.

Click on + Create User
Fill out the required fields:
- Username: The desired username for the new user.
- Password: Enter a strong password.
- Confirm Password: Re-enter the password.
- Full Name: The full name of the user.
- Email Address: The email address of the user.
Click on Create User to finish creating the new user.

Step 2: Generate an API Token

After the user is created, log in as the new user or continue if you are still logged in as an admin.
Click on your username in the upper right corner of the Jenkins dashboard to open the options menu and select Security. You can also 3. click on the username to go to the user profile where you will find the same options.
Click on Add new Token Enter a name for the token to identify it (e.g., “My API Token”).
Click on Generate
A new API token will be generated. Copy the token and save it in a secure location. (Note: Copy this token now, because it cannot be recovered in the future)

Step 3: Use the API Token

You can now use this API token as a password when making API calls to Jenkins. Combine it with your username to authenticate requests.

curl JENKINS_URL/job/JOB_NAME/buildWithParameters \
  --user USER:TOKEN \
  --data param1=123 --data param2=value

Another example — sending a File Parameter:

curl JENKINS_URL/job/JOB_NAME/buildWithParameters \
  --user USER:PASSWORD \
  --form FILE_LOCATION_AS_SET_IN_JENKINS=@PATH_TO_FILE

Now, let’s take a quick look at an example. In this case, we have a job called Android Regression that we want to run remotely via the API using curl.

What we will do is the following:

curl https://JENKINS_SERVER_IP:JENKINS_PORT/job/Android%20Regression/buildWithParameters \
  --user USER:USER_TOKEN \
  --data param1=value1 --data param2=value2

The command above triggers the Jenkins build asynchronously using POST, without retrieving an output response. There’s no need to specify the request type with -X POST since curl automatically infers it when parameters are passed with --data.

You can also add the -i option, which tells curl to include the HTTP headers in the response output:

curl -i -X POST http://JENKINS_SERVER_IP:JENKINS_PORT/job/Android%20Regression/buildWithParameters \
  --user USER:USER_TOKEN \
  --data param1=value1 --data param2=value2

By running the command above, you’ll receive a response in the output with headers that provide relevant information. Below is an example of what the response might look like:

HTTP/1.1 201 Created
Date: Sat, 17 Aug 2024 18:32:49 GMT
X-Content-Type-Options: nosniff
Location: https://JENKINS_SERVER_IP:JENKINS_PORT/queue/item/ITEM_ID/
Vary: Accept-Encoding
Content-Length: 0
Server: Jetty(10.0.21)

At this point, the most important header to note is Location: https://JENKINS_SERVER_IP:JENKINS_PORT/queue/item/ITEM_ID/.

This header is significant because the URL returned in the Location field points to the item in the Jenkins queue. You can use this link to check the status of the job in the queue.

Now, let’s see how we can retrieve information about the Jenkins build once it’s created. We’ll use a local instance (127.0.0.1:8080) for this part of the tutorial. Here’s how you can do it: once you have the headers from the build execution, we’ll request the build information. Let’s get started!

First, we need to request a crumb to authorize our request:

curl -u USER_NAME:USER_TOKEN "http://127.0.0.1:8080/crumbIssuer/api/json"

If everything is set up correctly, you should receive a response like this:

{"_class":"hudson.security.csrf.DefaultCrumbIssuer","crumb":"CRUMB_VALUE","crumbRequestField":"Jenkins-Crumb"}

This response includes the crumb (CSRF protection token) and the field name used to include the crumb in subsequent requests.

The crumb, or CSRF (Cross-Site Request Forgery) token, is used to protect systems from cross-site request forgery attacks. In the context of Jenkins, the crumb helps prevent attackers from executing unauthorized requests on behalf of an authenticated user.

Finally, to retrieve information about the generated build from the headers obtained earlier (specifically from the Location header), use the following command:

curl --user USER_NAME:USER_TOKEN \
  -H "Jenkins-Crumb: CRUMB_VALUE" \
  "http://127.0.0.1:8080/queue/item/item_id/api/json"

This command includes the CSRF crumb in the header to authorize the request and fetch the build details.

If everything goes well, you will see a response like the following:

{
    "_class": "hudson.model.Queue$LeftItem",
    "actions": [
        {
            "_class": "hudson.model.ParametersAction",
            "parameters": [
                {
                    "_class": "hudson.model.StringParameterValue",
                    "name": "param1",
                    "value": "value1"
                },
                {
                    "_class": "hudson.model.StringParameterValue",
                    "name": "param2",
                    "value": "value2"
                }
            ]
        },
        {
            "_class": "hudson.model.CauseAction",
            "causes": [
                {
                    "_class": "hudson.model.Cause$UserIdCause",
                    "shortDescription": "Started by user Automation",
                    "userId": "test",
                    "userName": "Test"
                }
            ]
        }
    ],
    "blocked": false,
    "buildable": false,
    "id": 67,
    "inQueueSince": 1723933184774,
    "params": "\u000aparam1=value1\u000aparam2=value2",
    "stuck": false,
    "task": {
        "_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
        "name": "Android Regression",
        "url": "http://localhost:8080/job/Android%20Regression/",
        "color": "red_anime"
    },
    "url": "queue/item/51/",
    "why": null,
    "cancelled": false,
    "executable": {
        "_class": "org.jenkinsci.plugins.workflow.job.WorkflowRun",
        "number": 35,
        "url": "http://localhost:8080/job/Android%20Regression/35/"
    }
}

Resources

Remote Access API

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

X: @devjcastro
Linkedin: devjcastro

KotlinConf ’23 Recap

Jorge Castro — Tue, 18 Apr 2023 10:27:18 +0000

KotlinConf is JetBrains’ main event for developers interested in the Kotlin programming language and related technologies. It includes talks, workshops, and networking opportunities. For ’23, the event was held in Amsterdam.

KotlinConf lets us see once again how the number of Kotlin repositories on Github has been consistently growing significantly.

Kotlin Everywhere!

Is it true that Kotlin’s great adoption has been largely due to Android? In the following graph we can get an idea of the usage proportions.

Kotlin is in 95% of the most used apps in the Play Store 🙀

Google uses Kotlin extensively in its projects. As indicated in this article, 45% of its engineers use Kotlin and are creating integrations for all their tools so that they can be used with Kotlin.

Kotlin 2.0 is getting closer with performance improvements in compilation times. We will have a next version 1.9 and then we will have version 1̶.̶1̶0̶ 2.0.

The kotlin team has taken the feedback from the community very seriously and has been working on a new architecture for K2 Compiler that reduces the bottleneck presented in the compiler frond end.

The frontend is the part of the compiler that parses your code and performs the semantic analysis, data flow analysis, call resolution, and type inference. This is the part of the compiler that you, the developer, interact with the most. It’s also the part of the compiler that continuously runs inside your IDE, reports all error and warning messages, and helps you with tasks like auto completion, semantic-aware inspections, intentions, and refactorings
— Roman Elizarov

After approximately one year since the official launch of Jetpack Compose, we already have 23% of the apps in the Play Store using Jetpack Compose.

Kotlin DSL

Groovy will accompany Java in sharing the second place, in the upcoming versions of Android Studio we will have Kotlin DSL by default.

Most Desired Features

Static Extensions

Currently, if we want to add a static function to a class through an extension, it is necessary to have a companion object defined within the class.

For example:

fun main() {
    MyFile.greet("Hello from Kotlin")
}

fun MyFile.Companion.greet(message: String) {
    println(message)
}

class MyFile {
    companion object {
        // empty companion object body
    }
}

But this is not the case when we want to apply it to third-party classes, we don’t have the possibility to do it.

So suppose that we want to create a static extension for the File class our code would not compile with the following:

So static extensions provide a solution for those cases using the syntax:

Collection Literals

Collection literals are a commonly utilized characteristic in modern programming languages such as Python, JS, Go, Swift, and Rust, to mention just a few examples. Without collection literals you’ll have to remember, by heart, a separate function to create each type of collection. listOf, mapOf, setOf, intArrayOf, etc.

Name-Based Destructuring

In Kotlin you can unstructure a class into variables, the problem is very easy to make mistakes when the order of the properties is inverted, for example being the product of a refactor, the kotlin team is working on solving this and it is possible that it will come out after kotlin version 2.0

Context Receivers

Since its release in the experimental phase in kotlin 1.6.20, a lot of feedback has been obtained and they hope to have a stable version in the first versions of kotlin 2.0

you can check more here

Explicit Fields

Explicit Fields solve the problem of creating redundant properties within a class by defining a single property instead of separate mutable and immutable properties.

Kotlin Multiplatform

Kotlin Multiplatform is here to stay! The idea is to have its stable ecosystem by 2024.

Compose Multiplatform

Two important announcements:

The first is that Compose for Desktop is already stable.

The second is that Compose Multiplatform is now targeting iOS!

Sources

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

Install JetBrains Toolbox on Linux

Jorge Castro — Sun, 05 Mar 2023 04:38:50 +0000

Hello everyone, Welcome to a small article where we will learn how to install JetBrains Toolbox in our Linux distribution. In my case, I’m using Fedora 37, but I think you won’t have any inconvenience if you use another distribution.

But why do we need to install JetBrains Toolbox? If I’m an Android developer, do I need to install the JetBrains Toolbox?

The answers are simple: You do not need to have them installed to be able to work with Android Studio or any other IDE from the JetBrains family. But having JetBrains Toolbox installed gives us a number of advantages:

Easy management of multiple JetBrains tools
Easy upgrade of your JetBrains tools
Quick access to multiple versions of the same tool
Integration with other services such as GitHub and GitLab

Having said that, let’s start with the steps…

First, we need to download the JetBrains Toolbox App from the official site

In the download folder, you should see a file with a name similar to the following: jetbrains-toolbox-{version}.tar.gz

Later, we will uncompress the downloaded file inside the opt/ folder, and we will use the following command:

sudo tar -xvzf ~/Downloads/jetbrains-toolbox-{version}.tar.gz

Change {version} to the version in your file name. At the moment of creating this article, the current version is 1.27.3.14493.

If you want, you could rename the extracted folder the following way:

sudo mv jetbrains-toolbox-{version} jetbrains

Ready! Now open JetBrains Toolbox and run your executable with the following command:

/opt/jetbrains/jetbrains-toolbox

Add quick access

If you simply want to see JetBrains Toolbox in your list of applications, we will perform the following steps:

First, download the JetBrains Toolbox logo; I leave an alternative here; then move the image to the /opt/jetbrains/ directory.

sudo mv ~/Downloads/jetbrains-toolbox-icon.png /opt/jetbrains/

Then we will create a shortcut to be able to start JetBrains Toolbox from the applications menu. To do this, we will create a .desktop file as follows: in your terminal, run the following command:

sudo vi /usr/share/applications/jetbrains-toolbox.desktop

Inside the newly created file, paste the following code:

[Desktop Entry]
Type=Application
Name=JetBrains Toolbox
Exec=/opt/jetbrains/jetbrains-toolbox
Icon=/opt/jetbrains/jetbrains-toolbox-icon.png

Save the file :wq

Now you can use the application menu to search for JetBrains Tools.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

Update your Android app signing key from a new Keystore with Play App Signing.

Jorge Castro — Fri, 17 Feb 2023 22:36:52 +0000

Hello everyone! Today, I would like to talk to you about a topic that is rarely discussed in our work as Android engineers but is one of the most important things we should consider in case the need arises: updating your app signing key. 🔑

It is important to clarify that this article assumes that you are using Play App Signing; beforehand, it would be ideal to use this feature in the Google Play Console. On the other hand, we are going to carry out the process by generating the new certificate from a new Keystore.

Play App Signing

It is a service offered to Android developers by the Google Play Console that allows you to store your app’s signing key in Google’s secure infrastructure and offers upgrade options to increase security.

See more information here

But why would I have to change my signature key?

You should consider changing your signing key if you suffer a loss of it or if it is compromised by people outside your organization. Another scenario would be when the application changes ownership and you want to ensure that only authorized people have access to the key; and finally, if your signing key collides with another App Signing Key.

First we will create a new Keystore to generate the new app signing key. You can generate a Keystore from Android Studio or from the command line with help of keytool.

If you want to use Android Studio, check out the Android documentation here.

On the other hand if you want to use the keytool then you could copy the following command

keytool -genkey -v -keystore new_keystore.jks -alias new_alias -keyalg RSA -keysize 2048 -validity 10000

A keystore with the specified name and the private key associated with the specified alias will be generated. In the creation process, you will be asked for some details, such as the name and location of the organization, the common name of the issuer, etc.
Now go to the Play App Signing page and select the App signing tab. (Release > Setup > App integrity > App signing tab).
Then, request to update the signing key and select the option Upload a new app signing key from Java Keystore and execute the suggested steps:

Download the PEPK tool
Copy the command shown in the Play Console and replace only the parameters highlighted in bold
Once the certificate is generated, upload it to the Play Store Console

PEPK tool is an encryption tool provided by Google for protecting private keys of Android applications. PEPK stands for "Private Key Encryption Protection" and is a file format that contains an encrypted private key with a master password.
Let's explain a little more detailed the command that we must execute. Open your terminal and paste the command copied from the Google Play console

java -jar pepk.jar \
    --keystore=foo.keystore \
    --alias=foo \
    --output=output.zip \
    --signing-keystore=uploadkey.keystore \
    --signing-key-alias=upload-key-alias \
    --encryptionkey=generated-encryption-key

Next I explain what each argument means.

keystore: specifies the location and filename of the new keystore that will be used to sign the encrypted private key output by the PEPK tool. This keystore should contain a private key with the alias specified by the alias parameter.
alias: This is the alias of the private key in the keystore file that will be used in the signed file.
output: This parameter is used to specify the name of the signed file.
signing-keystore: specifies the location and filename of the existing keystore that contains the private key that will be used to sign the APK file after it is processed by the PEPK tool. The keystore specified here should contain a private key with the alias specified by the signing-key-alias parameter.
signing-key-alias: This parameter specifies the alias of the private key in the keystore file that will be used to sign the file.
encryptionkey: Encryption key to use to encrypt the output file.

📝: signing-keystore and signing-key-alias are parameters that correspond to the keystore that contains the upload key certificate. If by mistake you put in all the parameters only the data of the new keystore you will get the following error:

If everything was done correctly we should be able to see our certificate created

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

RSS reader in Python for Discord

Jorge Castro — Sun, 05 Feb 2023 06:17:24 +0000

Hey guys, I hope everyone is having a good day. Today I want to create a short article on how to read RSS feeds with Python and notify a Discord channel using Webhook. First of all I wanted to use some of the Discord bot alternatives on the market, but the free options were very limited for what I wanted 😅, it’s not bad to pay for the use of tools that make your life easier, but honestly I took this as an excuse to do some coding over the weekend. It is my hobby! ❤️.

Let’s start

To get started, we need to search for any site with RSS support; in my case i searched for sources for android development and for this example i will use the following URL:

https://medium.com/feed/@devjorgecastro

Once the project is created, we need to install the **feedparser **library to read rss with python.

pip install feedparser

Next, we’ll create our main.py, add the webhook, username, and avatar url.

import feedparser

webhook = "https://discord.com/webhooks/{webhook_id}/{webhook_token}"
username = "Androd News"
avatar_url = "https://source.android.com/static/docs/setup/images/Android_symbol_green_RGB.png"

feed = feedparser.parse(feed_url)
print(feed)

If everything is ok, when you run the program you should be able to see a terminal output similar to the following image

Let’s continue, the next thing we will do is create a class to manage our Discord data and have the ability to launch notifications. We will call our class discord_module/DiscordNews.py

import requests

class DiscordNews:

    def __init__(self, webhook, username, avatar_url, feed):
        self.webhook = webhook
        self.username = username
        self.avatar_url = avatar_url
        self.feed = feed

    def prepare_and_notify(self):
        for entry in self.feed.entries:
            self.__notify_to_discord_channel(entry)

    def __notify_to_discord_channel(self, data):
        # Code for notify to Discord channel

As you may have noticed we have 2 parameters in the class constructor: avatar_url and username, these are used to customize the posting of the message in the Discord channel; with avatar_url we specify a url of an image that will be the icon of our bot and username will be its name.

The next thing is to import our class into main.py and call the function prepare_and_notify

discord = DiscordNews(webhook, username, avatar_url, feed)
discord.prepare_and_notify()

Finally, we run the program.

python main.py

Result

See the full code here

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

Modern Android Development in 2023

Jorge Castro — Mon, 23 Jan 2023 23:35:35 +0000

Hello everyone 👋🏻, I’d like to share with you how to build Android apps with the latest trends for the year 2023.

Disclaimer

This is an article from my opinion and professional experience, taking into account different opinions among the Android developer community, also constantly reviewing the guides provided by Google for Android.

I have to make it clear that there are very interesting tools, patterns and architectures that I may not mention but it does not mean that they cannot be other interesting alternatives to develop Android applications.

What is android?

Android is an open-source operating system based on the Linux kernel and developed by Google. It’s used in a wide variety of devices, including smartphones, tablets, TVs, and smartwatches.

Currently, Android is the operating system most used in the world for mobile devices; according to a report by statcounter with a sample of the last 12 months, Android has a market share of 71.96%.

Next, I will mention a list of tools, libraries, architectures, guides, and other utilities that I consider important to building modern applications on Android.

Kotlin ❤️

Kotlin is a programming language developed by JetBrains. Recommended by Google who officially announced it in May 2017 (see publication here). It is a modern programming language that has compatibility with Java and can run on the JVM, which has made its adoption in the development of Android applications very fast.

Whether you are new to Android or not, you should consider Kotlin as your first choice, don’t swim against the tide 🏊🏻 😎, Google announced this approach at Google I/O 2019. With Kotlin, you will be able to use all the features of a modern language, including the power of Coroutines and the use of modern libraries developed for the Android ecosystem.

Official kotlin documentation here

Jetpack Compose 😍

Jetpack Compose is Android’s recommended modern toolkit for building native UI. It simplifies and accelerates UI development on Android.
_ Jetpack Compose documentation

Jetpack Compose is part of the Android Jetpack library and uses the Kotlin programming language to easily create a native user interface. Also, it integrates with other Android Jetpack libraries, such as LiveData and ViewModel, to make it easier to build reactive and maintainable Android applications.

Some key features of Jetpack Compose include:

Declarative UI.
Customizable widgets.
Easy integration with existing code.
Live preview.
Improved performance.

Resources:

Jetpack Compose documentation

Android Jetpack

Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.
_ Android Jetpack documentation

Some of its most common tools are:

Material Design

Material Design is an adaptable system of guidelines, components, and tools that support the best practices of user interface design. Backed by open-source code, Material Design streamlines collaboration between designers and developers, and helps teams quickly build beautiful products.
_ Material Design Site

Material Design is backed by designers and developers from Google and will allow us to have a guide to work on our UI/UX for Android, Flutter and Web.

Currently, the last version for Material Design is 3, you can see more here

Clean Architecture

The concept of "Clean Architecture" was introduced by Robert C. Martin. It is based on the separation of responsibilities through the division of software into layers.

Characteristics

Independent of Frameworks.
Testable.
Independent of UI.
Independent of Database.
Independent of any external agency.

The Dependency Rule

The dependency rule is described very well by the author in his piece, The Clean Code Blog

The overriding rule that makes this architecture work is The Dependency Rule. This rule says that source code dependencies can only point inwards. Nothing in an inner circle can know anything at all about something in an outer circle. In particular, the name of something declared in an outer circle must not be mentioned by the code in the an inner circle. That includes, functions, classes. variables, or any other named software entity.

The Clean Code Blog

Clean Architecture in Android

Presentation: Activities, Fragments, View Models, others view components.
Domain: Use Cases, Entities, Repositories, others domain components.
Data: Repository implementations, Mappers, DTO’s, etc.

Architecture Patterns for Presentation Layer

An architecture pattern is a higher-level strategy that aims to help design a software architecture and is characterized by being a solution within a reusable framework for common architectural problems. Architectural patterns are similar to design patterns, but they are larger in scale and address more global issues such as the overall structure of the system, the relationships between components, and the way that data is managed.

Within the Presentation layer, we have some architecture patterns, of which I would like to highlight the following:

MVVM
MVI

I do not want to go into explaining each one because on the internet you find too much information about this. 😅

In addition, you can also see the guide to app architecture

Dependency Injection

Dependency injection is a software design pattern that allows a client to obtain its dependencies from an external source rather than creating them itself. It is a technique for achieving Inversion of Control (IoC) between objects and their dependencies.

Hilt ❤️
Dagger
Koin

Modularization

Modularization is a software design technique that allows you to divide an application into independent modules, each with its own functionality and responsibility.

Benefits of modularization

Reusability: By having independent modules, they can be reused in different parts of the application or even in other applications.

Strict visibility control: Modules enable you to easily control what you expose to other parts of your codebase.

Customizable delivery: Play Feature Delivery uses the advanced capabilities of app bundles, allowing you to deliver certain features of your app conditionally or on demand.

Scalability: By having independent modules, functionalities can be added or removed without affecting other parts of the application.

Ease of maintenance: By dividing the application into independent modules, each with its own functionality and responsibility, it is easier to understand and maintain the code.

Ease of testing: By having independent modules, they can be tested in isolation, which makes it easy to detect and fix errors.

Architecture improvement: Modularizing helps to improve the architecture of the application, allowing a better organization and structure of the code.

Improve collaboration: By having independent modules, developers can work on different parts of the application simultaneously and without interference.

Build Time: Some Gradle functionalities such as incremental build, build cache or parallel build, can leverage modularity to improve build performance.

See more in the official documentation.

Network

Serialization

In this section I would like to mention two important tools in my opinion: Moshi widely used in conjunction with Retrofit and Kotlin Serialization, the bet of the Kotlin team at Jetbrain.

Moshi and Kotlin Serialization are two serialization/deserialization libraries for Kotlin and Java that allow you to convert objects to JSON or another serialization format and vice versa. Both provide a user-friendly interface optimized for use in mobile and desktop applications. Moshi primarily focuses on JSON serialization, while Kotlin Serialization has support for various serialization formats, including JSON.

Image Loading

To load an image from the internet, there are several third-party libraries available to help you handle the process. Image loading libraries do a lot of the heavy lifting for you; they handle both caching (so you don’t download the image multiple times) and networking logic to download the image and display it on screen.
_ Official Android Documentation

Coil
Glide

Reactivity / Thread Management

When we talk about reactive programming and asynchronous processes, our first option is Kotlin Coroutines; thanks to the Suspension Functions and Flow we can cover all these needs. However, I believe that in this section it is worth highlighting the importance of RxJava even within the development of Android applications. For those of us who have been working with Android for a couple of years, we know that RxJava is a very powerful tool with a very large set of functions for working with data streams. I still consider RxJava to be an interesting alternative to consider today.

Local Store

An important point when building mobile applications is having the ability to persist data locally, such as some session data or cache data, among others. It is important to choose the right storage option based on the needs of your application. We could store unstructured data like key-value or structured data like a database. Keep in mind that this point does not mention all the types of local storage that we have available (such as file storage), only the tools that allow us to save data.

Suggestions:

~~S̶h̶a̶r̶e̶d̶P̶r̶e̶f̶e̶r̶e̶n̶c̶e̶s̶~~
DataStore
EncryptedSharedPreferences

Testing

R8 optimizations

R8 is the default compiler that converts your project’s Java bytecode into the DEX format that runs on the Android platform. It is a tool that helps us to obfuscate and reduce the code of our application by shortening the names of the classes and their properties, eliminating unused code and resources within the project. To see more, check the Android documentation about Shrink, obfuscate, and optimize your app.

Image by androidtopics.dipien.com

Code shrinking
Resource shrinking
Obfuscation
Optimization

Play Feature Delivery

Google Play’s app serving model, called Dynamic Delivery, uses Android App Bundles to generate and serve optimized APKs for each user’s device configuration, so users download only the code and resources they need to run your app.
_ Android Documentation

Adaptive layouts

With the growth in the use of mobile devices with different form factors, we need to have tools that allow us to work with our Android applications adapted to different types of screens. That is why Android provides us with Window Size Classes, which, in a simple way, are three large groups of screen formats that mark critical points for us to develop our designs. With this we avoid the complexity of thinking about many screen designs to reduce our possibilities to 3 groups which are: Compat, Medium and Expanded.

Window Size Classes

Support different screen sizes

Another important resource that we have are the Canonical Layouts, which are predefined screen designs that can be used for most scenarios in our Android applications and also show us a guide on how to adapt them to large screens.

Other related resources

Form-Factor Training

Form Factors at Google I/O 2022 (2)

Performance

While we develop applications for Android, we must ensure that the user experience is better, not only at the beginning of the application but also throughout its execution. For this reason, it is important to have tools that allow us to carry out a preventive analysis and constant monitoring of cases that may affect the performance of the application, so here is a list of tools that will help you with this purpose:

In-App Updates

When your users keep your app up to date on their devices, they can try new features, as well as benefit from performance improvements and bug fixes. Although some users enable background updates when their device is connected to an unmetered connection, other users might need to be reminded to install updates. In-app updates is a Google Play Core libraries feature that prompts active users to update your app.
The in-app updates feature is supported on devices running Android 5.0 (API level 21) or higher. Additionally, in-app updates are only supported for Android mobile devices, Android tablets, and Chrome OS devices.
_ In-App Updates documentation

In-App Reviews

The Google Play In-App Review API lets you prompt users to submit Play Store ratings and reviews without the inconvenience of leaving your app or game.
Generally, the in-app review flow can be triggered at any time throughout the user journey of your app. During the flow, the user has the ability to rate your app using the 1 to 5 star system and to add an optional comment. Once submitted, the review is sent to the Play Store and eventually displayed.
To protect user privacy and avoid API misuse, there are strict guidelines that your app should follow about when to request in-app reviews and the design of the review prompt.
_ In-App Reviews documentation

Accessibility

Accessibility is an important feature in the design and construction of software that provides the ability for people with accessibility needs to use the application, in addition to improving their user experience. Some disabilities that this concept aims to improve are: people with vision problems, color blindness, hearing problems, dexterity problems, and cognitive disabilities, among others.

Considerations:

Increase text visibility (Color contrast, Resizable Text)
Use large, simple controls
Describe each UI element

Check Accessibility — Android doc.

Security

Security is one, if not the most important aspect, that we must take into account when developing applications that protect the integrity of the device, the security of the data, and the trust of the user, which is why I list below a series of tips that will help you with this purpose.

Encrypt sensitive data and files: Use EncryptedSharedPreferences and EncryptedFile.
Apply signature-based permissions:
Use signature-based permissions when sharing data between apps you have control over.

package="com.example.myapp">
android:protectionLevel="signature" />
Do not put keys, tokens, or sensitive data required for your application’s configuration directly inside files or classes that are inside the project repository. Use local.properties instead.

Version Catalogs

Gradle provides a standard way to centrally manage project dependencies called the version catalog; it was experimentally introduced in version 7.0 and officially released in version 7.4.

Advantage:

For each catalog, Gradle generates type-safe accessors so that you can easily add dependencies with autocompletion in the IDE.
Each catalog is visible to all projects of a build. It is a central place to declare a version of a dependency and to make sure that a change to that version applies to every subproject.
Catalogs can declare dependency bundles, which are “groups of dependencies” that are commonly used together.
Catalogs can separate the group and name of a dependency from its actual version and use version references instead, making it possible to share a version declaration between multiple dependencies.

Logger

A logger is a software tool used to register information about the execution of a program; important events, errors debug messages and other information that may be useful in diagnosing problems or understanding how a program is working. Loggers can be configured to write messages to different locations, such as a log file, to the console, to a database, or by sending the messages to a logging server.

Timber

Linter

Linter is a programming tool that is used to analyze the program source code to find potential problems or bugs in the code. These issues can be syntactic, inappropriate code style, lack of documentation, security issues, and so on, and they can have an impact on the quality and maintainability of the code.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

Add blur effect to Image in Jetpack Compose

Jorge Castro — Mon, 09 Jan 2023 01:43:49 +0000

Hi guys, today I want to share this little article where I briefly explain how to create a blurry image on Android. Without so much introduction, let’s get to the point. 😎

Blur is a visual effect that is often used in graphics software to reduce the clarity or sharpness of an image or video. It can be used for a variety of purposes, such as to reduce distractions in the background of a photo or to create a more visually pleasing composition.

Photo by Unsplash

As developers, at some point we may have a need to create blurry images, so today I want to share with you a solution that is backward compatible with Android API 31.

When we work with Jetpack Compose, we can apply a blur effect in a very simple way using the blur extension function of the Modifier interface.

The problem with the example above is that if it runs on versions below Android 12, we will not see any effect because this implementation is only allowed in Android 12 (API level 31) or higher versions.

So we will have to verify if we are running the application on versions equal to or greater than Android 12.

The first thing we will do is create our code for versions prior to Android 12. For this, we will use RenderScript and ScriptIntrinsicBlur. We will create a composable function called “LegacyBlurImage” that will give us an Image product of a previously processed bitmap.



@Composable
private fun LegacyBlurImage(
  bitmap: Bitmap,
  blurRadio: Float,
  modifier: Modifier = Modifier.fillMaxSize()
) {

  val renderScript = RenderScript.create(LocalContext.current)
  val bitmapAlloc = Allocation.createFromBitmap(renderScript, bitmap)
  ScriptIntrinsicBlur.create(renderScript, bitmapAlloc.element).apply {
      setRadius(blurRadio)
      setInput(bitmapAlloc)
      forEach(bitmapAlloc)
  }
  bitmapAlloc.copyTo(bitmap)
  renderScript.destroy()

  BlurImage(bitmap, modifier)
}

We will also create a composable function that we will call “BlurImage” with which we will create the composable for the image we want to display.



@Composable
fun BlurImage(
    bitmap: Bitmap,
    modifier: Modifier = Modifier.fillMaxSize(),
) {
    Image(
      bitmap = bitmap.asImageBitmap(),
      contentDescription = null,
      contentScale = ContentScale.Crop,
      modifier = modifier
    )
}

Finally we call our functions checking the version of Android that the device has.



val bitmap = BitmapFactory
  .decodeResource(LocalContext.current.resources, R.drawable.custom_image)

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
    LegacyBlurImage(bitmap, 25f)
} else {
    BlurImage(
        bitmap,
        Modifier
            .fillMaxSize()
            .blur(radiusX = 15.dp, radiusY = 15.dp)
    )
}

Result

You can see the complete code here.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro
Linkedin: dev-jorgecastro

Generic MongoDB function in Rust

Jorge Castro — Sun, 13 Nov 2022 08:46:18 +0000

Hello guys!. As an Android Developer 🤖❤️, I find myself learning Rust and it seems more and more entertaining to play in my spare time with this language. Today I want to write a bit and this time we will create a small utility to work with MongoDB cursors in Rust in a generic way.

While having fun with Rust and doing a couple of queries with MongoDB I realized that I was repeating the same pattern in different places: a listing of N things that follow an identical query structure in MongoDB. Giving a little more context, when we want to retrieve a set of data from a Mongo collection, we get a cursor of the type of data we want. Based on that scenario, I wanted to create a small function that would help me convert that cursor to an array of data of type T, where T is a generic type; that is, when calling my function T, it will take the specific type that it needs at that moment.

Generic Data Types

We use generics to create definitions for items like function signatures or structs, which we can then use with many different concrete data types.

you can see more about the generic data types here.

Let’s get to the point

First of all, I want to start from the fact that it is not a tutorial that starts from scratch, I am assuming that you know and understand the most basic concepts of Rust such as: how to create a project, functions and modules in Rust, among other small concepts . Having said all of the above, let’s continue with the article.

We’ll start by defining our generic function that will receive a generic cursor Cursor::<T> and return a data set Vec<T>. To define our generic function we will create a module mod.rs (You name it to your liking). For this example we will call our function extract_data and add the code below.

use mongodb::Cursor;
use futures::stream::StreamExt;
use rocket::serde::DeserializeOwned;

pub async fn extract_data<T: DeserializeOwned + Unpin + Send + Sync>(mut cursor: Cursor::<T>) -> Vec<T> {
    let mut result = Vec::new();
    while let Some(doc) = cursor.next().await {
        let item = doc.unwrap();
        result.push(item)
    }
    result
}

Let’s create a small function to get a list of users. Don’t focus on the content of the function; surely you can make better code. We will call this function get_users_cursor.

async fn get_users_cursor() -> Cursor<UserModel> {
  let mut client_options = ClientOptions::parse(DATABASE_URI)?;
  client_options.app_name = Some(APP_NAME.to_string());
  let client = Client::with_options(client_options)?;
  let database = client.database(DATABASE_NAME);

  let collection: Collection<UserModel> = client.database(DATABASE_NAME)
    .collection::<UserModel>("users");

  collection.find(None, None).await.unwrap()
}

Finally, it’s time to call our generic function to obtain a dataset of the generic type, which in our example is UserModel.

pub async fn fetch_detail(&self) -> Vec<UserModel> {
  let cursor = self.get_users_cursor().await;
  extract_data::<UserModel>(cursor).await
}

Remember to import the module path where you defined the extract_data generic function.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro

Live Reloading in Rust with Cargo Watch and Docker

Jorge Castro — Tue, 18 Oct 2022 16:19:46 +0000

Helo everyone 👋🏻
Today I want to share with you how we can observe changes in Rust using Docker Containers. This is a continuation of the article Hot Reload in Rust with Cargo Watch

1 - First and foremost, we must create a DockerFile in the project's root directory and include the code below.

# Using official rust base image
FROM rust:alpine3.16

# Set the application directory
WORKDIR /app

# Install musl-tools to make many crates compile successfully
RUN apk add --no-cache musl-dev

# Install cargo-watch
RUN cargo install cargo-watch

# Copy the files to the Docker image
COPY ./ ./

Dockerfile is a plain text file that contains instructions that Docker will use to build an image. see more

2 - ~~The following step is to create the image using the command below~~.

docker build -t rust-observable-image .

You should then see on your terminal the response confirming that the image has been successfully built.
[+] Building 430.0s (10/10) FINISHED

We can verify that the image is created.

docker images

3 - The next step would be to run the container and run the "cargo watch" command inside the container, but we're going to do something more automated using Docker Compose. So we don't need to run step 2 because when we start the container with Docker Compose it will run automatically.

So we need to create a docker-compose.yml file inside the root directory of the project and add the following instructions:

version: "3.9"
services:
    app:
        build: .
        container_name: "cargo-watch-example"
        volumes:
            - .:/app
        command: sh -c "cargo watch -x run"

4 - The final step is run the container with Docker Compose

docker compose up

From now on you will be able to make changes to your project and observe the changes from your container.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro

Live Reloading in Rust with Cargo Watch

Jorge Castro — Sun, 16 Oct 2022 21:47:03 +0000

Helo everyone 👋🏻
When we are developing a Rust application, sometimes we have the need to reduce the time of the cycle of changes, compilation, and execution. It sounds a bit complicated, but today I am going to show you a tool that does it in a very simple and automatic way. This tool is called cargo watch, and it reduces the time of each cycle of changes in the background.

Cargo Watch

Cargo Watch creates a listener on your project changes and runs Cargo commands when they occur. At the time of writing this article the latest version is 8.1.2.
Cargo Watch doc
Github Project

Disclaimer

For this tutorial I am assuming you are familiar with using Cargo.

Cargo is Rust’s build system and package manager. Most Rustaceans use this tool to manage their Rust projects because Cargo handles a lot of tasks for you, such as building your code, downloading the libraries your code depends on, and building those libraries

You can read more about cargo here

Change Cycle

We start by creating a new project. For our example we will call it cargo-watch-example

cargo new cargo-watch-example

If the project was created correctly you should see the following message in the terminal
Created binary (application)cargo-watch-examplepackage

Install Cargo Watch

cargo install cargo-watch

Run project and observe changes

Inside the root directory:

cargo watch -x run

If you want to only listen for changes from only the working directory add the -w option to specify a file or directory from which you want to listen for changes.

cargo watch -w src -x run

Demo

The previous example was the simplest configuration observing changes on the whole project or on a specific directory, but you can do much more, Here's a copy of the help:

USAGE:
    cargo watch [FLAGS] [OPTIONS]

FLAGS:
    -c, --clear              Clear the screen before each run
    -h, --help               Display this message
        --ignore-nothing     Ignore nothing, not even target/ and .git/
        --debug              Show debug output
        --why                Show paths that changed
    -q, --quiet              Suppress output from cargo-watch itself
        --no-gitignore       Don’t use .gitignore files
        --no-ignore          Don’t use .ignore files
        --no-restart         Don’t restart command while it’s still running
        --poll               Force use of polling for file changes
        --postpone           Postpone first run until a file changes
    -V, --version            Display version information
        --watch-when-idle    Ignore events emitted while the commands run.
                             Will become default behaviour in 8.0.

OPTIONS:
    -x, --exec <cmd>...
            Cargo command(s) to execute on changes [default: check]

    -s, --shell <cmd>...           Shell command(s) to execute on changes

    -d, --delay <delay>
            File updates debounce delay in seconds [default: 0.5]

        --features <features>
            List of features passed to cargo invocations

    -i, --ignore <pattern>...      Ignore a glob/gitignore-style pattern

    -B <rust-backtrace>
            Inject RUST_BACKTRACE=VALUE (generally you want to set it to 1)
            into the environment

        --use-shell <use-shell>
            Use a different shell. E.g. --use-shell=bash. On Windows, try
            --use-shell=powershell, which will become the default in 8.0.

    -w, --watch <watch>...
            Watch specific file(s) or folder(s) [default: .]

    -C, --workdir <workdir>
            Change working directory before running command [default: crate root]

ARGS:
    <cmd:trail>...    Full command to run. -x and -s will be ignored!

Cargo commands (-x) are always executed before shell commands (-s). You can use
the `-- command` style instead, note you'll need to use full commands, it won't
prefix `cargo` for you.

By default, your entire project is watched, except for the target/ and .git/
folders, and your .ignore and .gitignore files are used to filter paths.

On Windows, patterns given to -i have forward slashes (/) automatically
converted to backward ones (\) to ease command portability.

In the next tutorial we will apply this example using Docker Containers 😎

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro

Strategies to have fun while learning technology

Jorge Castro — Sun, 09 Oct 2022 15:10:02 +0000

First of all, I want to say that this article is more focused on technology topics, but it could be applied to other contexts. It is just a personal opinion from the point of view of a technology lover ❤️ and, in particular, a Software Engineer 💻.

Some people ask me what is my strategy to keep learning all the time? well, today I want to share a little about this.

It is very normal that when we need to learn a new topic, the first thing we think is to go to the official documentation, check the Stackoverflow page and watch some videos. But sometimes this could just be a bit boring, so here are the most common things I do when I want to stay focused and learn a new topic in a fun way.

Follow people with common interests.
Participate in a technology community.
Discuss.
Create a test project.
Write an Article.

There are other ways, but these are the ones I usually use the most, and we don't want to extend this article much, right? 😅.

Follow people with common interests. 👤

Photo by Free Walking Tour Salzburg on Unsplash

To keep myself updated and, as a user of different platforms or social networks, I usually follow the content and publications of different people who take the time to share valuable and relevant content of my interest. Some of my favorite content platforms are: Github, Linkedin, Medium, Dev community and Twitter. In this way, I can see and compare what I am learning with what other people have already learned and who surely have a higher technical level.

Participate in a technology community. 👥

Photo by Windows on Unsplash

This section is one of my favorites because I like to meet people, get to know different cultures, listen to different opinions, share a bit of my professional experience, and try to help solve doubts and problems that other members have.

I really enjoy being part of tech communities and helping them grow by sharing ideas and topics that I’m learning about that I find interesting and useful to other members of the community.

Discuss. 💬

The debate with other people who share similar knowledge is another interesting way to validate what has been learned. This helps to correct ambiguities and, of course, generate new ideas from different points of view. On the other hand, it helps to improve assertive communication, which is essential for our personal and professional growth.

Create a test project 💻

fn main() {
    println!("Hello World!");
}

Obviously, for most cases, the above example is too basic, but the main idea is to put into practice the acquired knowledge. Many people say that if it is not put into practice, then it is forgotten, and I believe it 🙂

When I start to learn a new technology, I do a small project to apply the acquired knowledge. It's great fun for me. I feel that it's a hobby and I can spend hours having fun while I learn. I also re-practice previously acquired knowledge 🤓.

Write an article. 📖

Wait, wait! Write? We are supposed to want to learn. Well, I think that one of the best ways to keep knowledge active is through writing. It's a fun way to post what we've learned. Honestly, to date, it is a new path that I am putting into practice, and that is why I have decided to write articles about the things that I am learning in the world of technology. The main purpose of this is to spare other people certain complexities that I have gone through in learning certain topics. On the other hand, when we write, we can also create our own record of knowledge.

At the end of the day, there are many ways to maintain your focus while improving your learning experience. The important thing is to apply a strategy to your personal taste that helps you achieve your goal in the most fun way possible. It is also important that you keep in mind that discipline and perseverance are essential for learning to become effective.

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰

Follow me in

Twitter: @devjcastro