Forem: Adham Lou

Analytics in Android

Adham Lou — Tue, 18 Feb 2025 11:01:22 +0000

Handling Multiple Analytics Providers in Android: The Struggle and the Solution

In today's mobile development landscape, analytics play a crucial role in understanding user behavior, improving app performance, and making data-driven decisions. However, integrating multiple analytics providers in an Android project can quickly become a nightmare. From managing different SDKs to dealing with various APIs, event structures, and data formats, developers often find themselves entangled in a complex web of tracking code.

The Challenges of Using Multiple Analytics Providers

Many Android apps rely on multiple analytics services such as Google Analytics, Firebase, Mixpanel, Amplitude, and others. While each of these tools provides valuable insights, handling them all at once introduces several challenges:

1. Inconsistent APIs and Event Structures

Each provider has its own way of tracking events, user properties, and sessions. This leads to redundancy in the codebase and makes it difficult to maintain consistency in event tracking across all platforms.

2. Increased Code Complexity

Manually integrating multiple SDKs means writing a lot of repetitive code to ensure each event is logged in all services. This results in bloated code and increased chances of errors.

3. Harder Debugging and Maintenance

When something goes wrong in event tracking, debugging can be a nightmare. Identifying whether the issue is with a specific provider’s SDK or the implementation itself becomes challenging.

4. Performance Overhead

Each analytics SDK adds some level of overhead to the app, leading to increased memory usage and potential performance bottlenecks.

Introducing Analytiks: A Unified Solution

To address these challenges, Analytiks provides a simple and elegant solution. Analytiks is an open-source library that acts as an abstraction layer, allowing developers to integrate multiple analytics providers seamlessly with a single, unified API.

Why Choose Analytiks?

Unified API: Define events once and dispatch them to multiple providers effortlessly.
Simplified Integration: Reduce boilerplate code by handling multiple analytics providers through a single interface.
Maintainability: Easier to manage and extend event tracking without modifying multiple SDK implementations.
Performance Optimization: Reduce redundant calls and optimize performance by controlling event dispatching efficiently.

How Analytiks Works

With Analytiks, integrating multiple analytics providers is as easy as:

Analytiks.Builder()
        .addClient(CustomAnalytiksAddon())
        .addClient(MixpanelAnalyticsClient(token = "YOUR_TOKEN"))
        .addClient(
            SegmentAnalyticsClient(
                token = "YOUR_TOKEN",
                flushIntervalInSeconds = 5,
                trackApplicationLifecycleEvents = true,
            )
        )

Initialize the addons

analytiks.initialize(this.applicationContext)

You're good to go!

analytiks.logEvent("your_event_name")
analytiks.pushAll()

By using Analytiks, developers can simplify event tracking, improve maintainability, and ensure consistent data collection across different platforms. If you're looking for a cleaner, more efficient way to handle analytics in your Android app, check out Analytiks on GitHub and start optimizing your analytics implementation today!

From Movie Night to Android App: Turning a Simple Idea into a Real Product

Adham Lou — Tue, 11 Feb 2025 17:14:47 +0000

Have you ever had a simple idea during a casual moment that turned into something bigger? That’s exactly what happened with MovieMatcher, my Android app designed to help friends, couples, or groups pick a movie together effortlessly. It all started with a frustrating movie night and ended with a full-fledged Android app.

The Problem: Movie Night Indecision

Like many, I love watching movies with friends and family. But every time we planned a movie night, we spent way too much time debating which movie to watch. Some liked action, others preferred drama, and we always ended up scrolling endlessly through streaming platforms without making a decision.

At one point, I thought: What if there was an app that helped us decide? Something simple, fun, and interactive.

The Idea: A Movie Matching App

The goal was clear: Create an app that helps two users agree on a movie quickly. The concept was simple:

Each user swipes through a set of movie options.
If both users like the same movie, it’s a match!
If not, they keep swiping until they find a common choice.

The Tech Behind the App

As an Android developer, I saw this as a great opportunity to build something practical while experimenting with modern Android tools. Here’s what I used:

Jetpack Compose: For a smooth and declarative UI experience.
Firebase: To handle real-time synchronization between users.
TMDB API: To fetch movie details dynamically.
Ktor Client: For efficient network requests.
DataStore Preferences: To store user preferences and settings.

Challenges and Solutions

Real-Time Syncing: Since two users needed to interact with the same session, I used Firebase’s real-time database to instantly update movie lists and matches.
Randomized Movie Lists: Instead of showing the same popular titles repeatedly, I implemented a system that fetches random movies in batches from TMDB.
Keeping It Lightweight: I focused on a simple, intuitive UI to ensure users could quickly navigate and make decisions without distractions.

Creating a Landing Page with AI

To help promote MovieMatcher, I decided to build a landing page. Instead of designing everything manually, I leveraged AI-powered tools to streamline the process:
Already talked about it in this article: Web developers you are cheating
You can check directly what it looks like:
moviematch.app

Lessons Learned

Building MovieMatcher reinforced some key principles for me:

Solve real problems – even a small frustration like movie indecision can inspire a useful app.
Keep it simple – the best apps focus on doing one thing well.
Use modern tools – leveraging Jetpack Compose, Firebase, and Ktor made development more efficient and scalable.

What’s Next?

I’m currently working on new features like filters for genres, watchlist integration, and personalized recommendations. The journey from a simple movie night struggle to a working Android app has been exciting, and I can’t wait to see where it goes next.

Shine Text Effect in Jetpack Compose

Adham Lou — Fri, 07 Feb 2025 23:00:22 +0000

Shimmer effects are a great way to enhance the user experience by indicating loading states with a smooth animated placeholder.
I always use it in the call-to-action events, it gave a more premium effect.

In this post, we will implement a shining text based on the shimmering effect in Jetpack Compose using this example from this gist and extend it with a method to update the shimmer color dynamically.

What is a Shimmer Effect?

A shimmer effect is an animated gradient overlay that creates an illusion of content loading. It gives users a visual cue that data is being fetched or processed.

Implementing Shimmer in Jetpack Compose

We will create a shimmer effect using a custom ShaderBrush that animates across the text.

Step 1: Define the ShimmeringText Composable

@Composable
fun ShimmeringText(
    text: String,
    shimmerColor: Color,
    modifier: Modifier = Modifier,
    textStyle: TextStyle = LocalTextStyle.current,
    animationSpec: DurationBasedAnimationSpec<Float> = tween(1000, 500, LinearEasing)
) {
    val infiniteTransition = rememberInfiniteTransition(label = "ShimmeringTextTransition")

    val shimmerProgress by infiniteTransition.animateFloat(
        initialValue = 0f,
        targetValue = 1f,
        animationSpec = infiniteRepeatable(animationSpec),
        label = "ShimmerProgress"
    )

    val brush = remember(shimmerProgress) {
        object : ShaderBrush() {
            override fun createShader(size: Size): Shader {
                val initialXOffset = -size.width
                val totalSweepDistance = size.width * 2
                val currentPosition = initialXOffset + totalSweepDistance * shimmerProgress

                return LinearGradientShader(
                    colors = listOf(Color.Transparent, shimmerColor, Color.Transparent),
                    from = Offset(currentPosition, 0f),
                    to = Offset(currentPosition + size.width, 0f)
                )
            }
        }
    }

    Text(
        text = text,
        modifier = modifier,
        style = textStyle.copy(brush = brush)
    )
}

Step 2: Updating Shimmer Color Dynamically

To enhance the shimmer effect, we will use a utility function to adjust the shimmer color dynamically. The brighter() function blends the color with white, creating a brighter effect:

fun Color.brighter(): Color {
    val blendRatio = 0.3f // Adjust to control brightness
    return Color(
        red = (this.red * (1 - blendRatio) + 1f * blendRatio).coerceIn(0f, 1f),
        green = (this.green * (1 - blendRatio) + 1f * blendRatio).coerceIn(0f, 1f),
        blue = (this.blue * (1 - blendRatio) + 1f * blendRatio).coerceIn(0f, 1f),
        alpha = this.alpha
    )
}

Now, we modify the ShimmeringText function to apply this color transformation:

@Composable
fun DynamicShimmeringText(
    text: String,
    baseColor: Color = Color.Gray,
    modifier: Modifier = Modifier,
    textStyle: TextStyle = LocalTextStyle.current
) {
    val shimmerColor = baseColor.brighter()
    ShimmeringText(
        text = text,
        shimmerColor = shimmerColor,
        modifier = modifier,
        textStyle = textStyle
    )
}

Step 3: Using the Shimmer Effect in a UI

@Composable
fun ShimmerScreen() {
    DynamicShimmeringText(text = "Book a Demo", baseColor = Color.Gray)
}

Final result ✨

this example is the adapted version of the tutorial

DeepSeek vs. ChatGPT in Jetpack Compose: Which One Generates the Best Results?

Adham Lou — Wed, 05 Feb 2025 11:46:12 +0000

Introduction

Jetpack Compose has revolutionized Android UI development by offering a declarative approach that simplifies UI creation. As AI-powered coding assistants become more prevalent, developers increasingly rely on tools like DeepSeek and ChatGPT to streamline their workflows. But which one provides the best results when generating Jetpack Compose code? In this post, we’ll compare these two AI assistants using real-world prompts and evaluate their strengths and weaknesses.

Test Scenarios

To make a fair comparison, we provided DeepSeek and ChatGPT with the following prompts and evaluated their outputs:

Create a to-do list with a decent UI – Evaluating UI quality, state management, and performance.

Convert an image into a composable – Testing adaptability and code accuracy.

Generate a paginated list with API calls – Checking efficiency in handling real-world scenarios.

Implement a dark mode toggle – Assessing how well state and UI updates are managed.

Handle user authentication in Jetpack Compose – Measuring security best practices and implementation correctness.

1. Create a To-Do List with a Decent UI

DeepSeek: Generated a functional to-do list with a modern UI, proper state management using remember, and followed Jetpack Compose best practices. The design was minimal yet effective.

ChatGPT: Produced a similar to-do list but with unnecessary complexity in state handling. Some UI elements were not as polished as DeepSeek's output.

Winner: DeepSeek – More concise and visually appealing UI.

2. Convert an Image into a Composable

DeepSeek: Accurately converted the image into a composable function, leveraging Canvas and ImageBitmap where necessary. It optimized performance by efficiently managing resources.

ChatGPT: Generated a working composable but occasionally misused Jetpack Compose drawing APIs, leading to suboptimal rendering performance.

Winner: DeepSeek – More accurate and optimized image conversion.

3. Generate a Paginated List with API Calls

DeepSeek: Implemented efficient pagination using LazyColumn and proper handling of API requests via ViewModel and remember. It followed recommended Kotlin Coroutines practices.

ChatGPT: Successfully implemented pagination but had minor inefficiencies in network call handling, leading to unnecessary recompositions.

Winner: DeepSeek – Better efficiency in API integration.

4. Implement a Dark Mode Toggle

DeepSeek: Used MaterialTheme and proper state management to ensure seamless dark mode switching, providing a smooth user experience.

ChatGPT: Achieved the same functionality but required additional refactoring to match best practices.

Winner: DeepSeek – More streamlined implementation.

5. Handle User Authentication in Jetpack Compose

DeepSeek: Generated a secure and modular authentication flow using Firebase Authentication with proper state and session handling.

ChatGPT: Created a functional authentication flow but included some redundant code and less secure token management practices.

Winner: DeepSeek – More secure and maintainable implementation.

Conclusion

Based on our test scenarios, DeepSeek consistently outperformed ChatGPT in generating Jetpack Compose code that is accurate, efficient, and adheres to best practices. While ChatGPT remains a strong contender, DeepSeek currently provides superior real-world Jetpack Compose development results.

Web developers... YOU are cheating!

Adham Lou — Tue, 04 Feb 2025 11:30:23 +0000

As an Android developer, I’ve spent years dealing with complex UI states, lifecycles, dependency injection, and, of course, the occasional Gradle sync nightmares. Web development? Never really touched it—always seemed like another world. But recently, I needed to create a landing page for my app, MovieMatcher, and let’s just say... web development feels like cheating.

How I Ended Up Making a Landing Page
I needed a simple way to showcase MovieMatcher. An app without a landing page? Doesn’t feel right. But writing HTML, CSS, and dealing with front-end frameworks? No, thanks. I wanted the easiest, most efficient way to get it done.

Enter V0.ai: My Personal Web Developer
I came across V0.ai, an AI-powered tool that basically builds a website for you. I described what I wanted—a clean, simple landing page with a hero section, feature highlights, and a call-to-action button—and within seconds, it spits out a fully responsive React-based page. That’s it. No XML layouts, no RecyclerViews, no worrying about different screen densities. Just text-to-UI magic.

Making It Fancy with Framer Motion
Now, the page worked, but it felt... plain. That’s where Framer Motion came in. Adding animations in Framer felt too easy compared to Android’s animation APIs. Want a smooth fade-in? One line of code. Slide effects? Another line. Meanwhile, in Android, I’d be dealing with state changes, remembering lifecycle quirks, and probably debugging some weird animation glitch.

Can you imagine that this page: www.moviematch.app is AI-generated?

Deploying? One-Click Magic with Netlify

The final step: putting it online. I pushed my code to GitHub, linked it to Netlify, and boom—it was live in minutes. No Firebase Hosting setup, no worrying about app bundles, just an instant deployment. Any update? Just push to GitHub, and Netlify handles the rest.

Final Thoughts: Is Web Development Just Easier?
After this experience, I have to say—web development is ridiculously smooth. Setting up a web project felt like a walk in the park compared to the hoops we jump through in Android development. I’m not saying I’m switching teams, but I definitely have a newfound appreciation for how effortless things can be on the web side.

Feature Flags in Android with Jetpack Compose

Adham Lou — Mon, 03 Feb 2025 09:54:49 +0000

Feature flags are an essential tool for controlling feature rollouts, enabling A/B testing, and managing experimental features without requiring a new app release. In this guide, we’ll implement feature flags in an Android app using Jetpack Compose, DataStore Preferences, and app flavors.

Why Use Feature Flags?

Feature flags allow you to:
Enable or disable features dynamically
Deploy incomplete features safely
Roll out features to specific user groups
Experiment with new ideas without affecting all users
Now, let's walk through the implementation!

Step 1: Setting Up App Flavors

We need to define app flavors in the build to manage different feature flag configurations based on the app version (e.g., free, paid, beta).gradle file:

android {
    flavorDimensions "version"
    productFlavors {
        free {
            dimension "version"
        }
        paid {
            dimension "version"
        }
    }
}

This setup allows us to maintain separate feature flag configurations for each flavor.

Step 2: Adding DataStore for Persistent Storage

Jetpack DataStore (Preferences) is ideal for storing feature flags because it is lightweight and supports asynchronous data reading and writing.

First, add the dependency to your build.gradle:

dependencies {
    implementation "androidx.datastore:datastore-preferences:1.0.0"
}

Next, create a DataStore helper class to manage feature flags:

private val Context.dataStore by preferencesDataStore(name = "feature_flags")

class FeatureFlagManager(
     private val context: Context
) {

    companion object {
        val FEATURE_X = booleanPreferencesKey("feature_x")
    }

    val isFeatureXEnabled: Flow<Boolean> = context.dataStore.data
        .map { preferences -> preferences[FEATURE_X] ?: false }

    suspend fun setFeatureX(enabled: Boolean) {
        context.dataStore.edit { it[FEATURE_X] = enabled }
    }
}

This class provides a Flow to observe feature flag changes and a function to update flags.

Step 3: Providing Different Feature Flags for Each Flavor

We’ll create separate JSON files for each flavor to predefine feature flags.

free/src/main/assets/feature_flags.json

{
  "feature_x": false
}

paid/src/main/assets/feature_flags.json

{
  "feature_x": true
}

Then, we can load these values at app startup.

fun Context.loadFeatureFlagsFromAssets(): Map<String, Boolean> {
    val assetName = "feature_flags.json"
    return try {
        val inputStream: InputStream = assets.open(assetName)
        val json = inputStream.bufferedReader().use { it.readText() }
        val jsonObject = JSONObject(json)
        jsonObject.keys().asSequence().associateWith { jsonObject.getBoolean(it) }
    } catch (e: Exception) {
        emptyMap()
    }
}

Step 4: Using Feature Flags in Jetpack Compose

We can now use the FeatureFlagManager to control UI elements dynamically in

@Composable
fun FeatureXScreen(featureFlagManager: FeatureFlagManager) {
    val isFeatureXEnabled by featureFlagManager.isFeatureXEnabled.collectAsState(initial = false)

    Column {
        Text("Feature X is ${if (isFeatureXEnabled) "Enabled" else "Disabled"}")
        if (isFeatureXEnabled) {
            Button(onClick = { /* Do something */ }) {
                Text("Try Feature X")
            }
        }
    }
}

Wrapping Up

By implementing feature flags with DataStore and app flavors, we gain greater flexibility in managing features dynamically. This approach enables safer releases and better control over feature rollouts. 🚀

5 weeks -> Android App

Adham Lou — Fri, 31 Jan 2025 14:43:13 +0000

Five weeks. That’s all it took to bring MovieMatch from concept to a fully functional app. When I first set out to build it, I knew I wanted a seamless way for users to match movies with friends or partners, but I had no idea how quickly it would come together.

The journey started with design. I spent the first week sketching out wireframes, defining the user flow, and ensuring the experience was intuitive. Given how many movie recommendation apps exist, I wanted MovieMatch to feel fresh—minimalistic yet engaging.

Once the design was ready, development kicked off. With Android native powering the mobile app and Firebase handling the real-time database, the app quickly took shape. The biggest challenge was synchronizing sessions between users in real-time while keeping performance smooth. But with Firebase’s real-time capabilities, the experience became seamless.

Testing and fine-tuning took up the final stretch. Handling edge cases, ensuring cross-device compatibility, and polishing UI interactions made sure the app felt refined.

For the landing page, I used Next.js and Tailwind, making deployment quick and styling effortless. The site needed to be lightweight yet visually appealing, and this stack delivered exactly that.

By the fifth week, MovieMatch was ready. What started as a simple idea turned into a fully functional app, built in just over a month. The journey reinforced that with the right tools and focus, shipping a quality product doesn’t have to take forever.

Web Development Feels Like Magic Compared to Android

Adham Lou — Thu, 30 Jan 2025 15:27:34 +0000

I’ve been a mobile developer for years, battling with OEM-specific bugs, App Store reviews, and the never-ending Android fragmentation. But recently, I decided to dip my toes into web development.

TL;DR: As a long-time mobile developer, I tried building a website using Next.js, Tailwind, and v0.ai. The process was surprisingly smooth, with instant deployment via Netlify and no platform-specific headaches. Best of all, it cost only $10 for the domain name. While mobile dev remains close to my heart, web development sometimes feels like the easier path.

I was curious about how easy it really was, I picked up Next.js and Tailwind CSS, using v0.ai to generate some components. Within minutes, I had a responsive layout, something that would have taken much longer on mobile. The best part? No XML, no Compose previews failing to render—just a smooth development experience.

Deploying the project was another revelation. With a simple setup, I had my app live on Netlify, accessible to anyone with a browser. No waiting for Play Store approvals, no worrying about different devices handling updates inconsistently. Debugging was a breeze too—hot reload worked instantly, and browser dev tools provided all the insights I needed. Even better, the entire website was free to host, and I only had to pay $10 for the domain name.

Of course, web development has its quirks—CSS specificity, browser inconsistencies, and learning new deployment pipelines. But compared to the hurdles I’ve faced in mobile, it felt almost too easy.

Does this mean I’m leaving mobile behind? Not at all. Mobile development has its own charm, and there’s something special about building apps people carry with them everywhere. But I’ll admit—sometimes, taking the easy route is tempting.

For those who want to see the results, you can check out the website here: moviematch.app