Flavors y Builds: Configuración para Apps Android

Compiling Android applications for different environments is a crucial process in software development that ensures the quality and stability of our products. Mastering tools like Flavors allows us to create specific versions for testing, development and production without compromising the integrity of our real data. Let's see how to implement this professional strategy in our projects.

What is end-to-end testing and why is it important?

End to end testing represents the most complete level of validation for our applications. Unlike unit or integration tests, these tests:

• Are executed from real devices
• Validate the complete operation of the application
• Include interaction with services and back end
• Simulate real end-user behavior

To perform these tests effectively without affecting the production environment, it is essential to create specific copies for testing, known as development and staging environments. These environments allow us to validate the behavior of our application in production-like conditions, but without the risk of compromising real data.

How to configure Flavors in Android Studio for different environments?

Android Flavors is a powerful tool that allows us to compile different versions of our application with specific configurations for each environment. Let's see how to implement it:

Creating a new Flavor for staging

1. We open Android Studio and navigate to the "Build" tab.
2. Select "Edit" and then "Edit Flavors".
3. We notice that there are already two flavors: premium and full
4. Create a new one called "Staging" to compile in this environment.
5. We keep the same application ID to avoid changes in Firebase
6. Click OK to confirm the creation

// Basic Flavors configuration structure in build.gradleflavorDimensions "version"productFlavors { full { dimension "version" applicationId "com.example.calorytracker" } premium { dimension "version" applicationId "com.example.calorytracker" } staging { dimension "version" applicationId "com.example.calorytracker" }}

BuildConfig configuration for each environment

To differentiate the configuration for each environment, we use BuildConfig:

1. We enable BuildConfig in our build.gradle file:

buildFeatures { buildConfig true}

2. We add specific variables for each flavor:

productFlavors { staging { buildConfigField "String", "API_URL", "https://staging.example.com/api/" } full { buildConfigField "String", "API_URL", "https://production.example.com/api/" } }}

It is crucial to synchronize Gradle after making these changes so that they are applied correctly in our project.

How to sign and generate bundles for different environments?

Application signing is an essential step before publishing to Google Play. Let's see how to generate signed bundles for our different environments:

Signing process for the production version

1. Go to "Build" and select "Generate Signed Bundle/APK".
2. We choose "Android App Bundle" as the format (recommended over APK)
3. Select an existing signature or create a new one:
   • If we create a new one, we specify location, password, alias and validity.
   • Validity is critical: if it expires, we would lose our presence on Google Play
4. Select the flavor "fullRelease" for the production version
5. Click on "Create" to generate the bundle

Signing process for the staging version

1. Repeat the previous process
2. In the variant selection, we choose "stagingRelease".
3. Verify that the configuration is correct (package names, URLs)
4. Generate the staging bundle

If we find errors during compilation, such as discrepancies in project names (for example, "calorytracker" vs "Calorytracker"), we must correct them in the configuration of our flavors and synchronize again.

// Error correction instaging configuration { buildConfigField "String", "PROJECT_NAME", "\"calorytracker"" // Corrected to lowercase}

Signature generation can also be performed via command line, which facilitates automation in continuous integration environments. This approach is especially useful for teams that implement CI/CD processes in their development.

Flavors in Android are a powerful tool that allows us to maintain multiple configurations for different environments, facilitating the testing process and ensuring the quality of our applications before reaching production. Have you implemented this strategy in your projects? Share your experience in the comments.