Image Generation with Gemini 2.5 Flash (Nano Banana) in Android App

As a developer, I spend a lot of time building apps that are functional, efficient, and solve real-world problems. But lately, I've been asking myself: where’s the magic? I became obsessed with the idea of creating an experience that wasn't just useful, but genuinely inspiring, something that would make a user pause and say, "Wow."

The idea came one evening while I was looking at all the amazing things people were building with AI, i.e. the creative projects, the art, the innovation everywhere. With all the incredible advancements happening in AI, I found myself wondering, could I use some of these latest technologies to let users create such art themselves, right inside my app? The thought of enabling text-to-image generation through an Android App felt both exciting and within reach, and I wanted to explore how I could bring that kind of creative power directly to users where imagination, not artistic skill, defines what they can make.

I knew this was an ambitious goal. A clunky interface that takes a lot of time to return an image would completely defeat the purpose. The experience had to feel instantaneous, like a conversation. My search for a powerful yet mobile-friendly solution led me down the rabbit hole of generative AI, and that’s where I first encountered Google's Gemini API. The ecosystem was vast, but one model, in particular, caught my eye for its promise of speed and efficiency: Gemini 2.5 Flash. It was nicknamed 'Nano Banana' and is positioned as the perfect engine for the kind of responsive, creative experience I wanted to build. My journey had found its starting point.

Two Paths for Image Generation

Before I could even create a new project in Android Studio, I faced a crucial decision. There were two distinct paths for image generation: the versatile Gemini family and the specialized Imagen model. The documentation described their differences, but as a developer, I needed to see and feel the results for myself. To make an informed choice, I decided to build a small, stripped-down prototype to put them head-to-head in a real-world test.

To give them a fair challenge, I chose a prompt with a rich mix of elements: atmosphere, structure, and fine detail. My test prompt was: "Generate an image of a medieval village in the rain." I wanted to see how each model would handle the moody atmosphere of the rain, the intricate textures of the old buildings, and the overall artistic composition.

I sent the prompt to Gemini 2.5 Flash (Nano Banana) first. The result that came back was fascinating. It was less of a photograph and more of a painting. The model had perfectly captured the feeling of a rainy medieval village, the cobblestones glistened with a soft, reflected light, the air felt heavy with moisture, and the overall style was artistic and evocative. It looked like a piece of high-quality concept art for a fantasy film or game. It was immediately clear that Gemini excelled at interpretation and storytelling, understanding the context and mood of my request on a deeper level.

Next, I fed the exact same prompt to Imagen. The difference was staggering. What I got back was photorealism. The level of detail was incredible, I could almost make out the individual splashes as raindrops hit the thatched roofs. The texture of the wet wooden beams and ancient stone walls was tangible, and the lighting was cinematic, as if captured by a professional photographer with a high-end camera. If Gemini was the artist, Imagen was the master photographer. It took my prompt literally and turned it into an image with amazing accuracy.

This simple test made my path forward crystal clear. For an e-commerce app needing flawless product shots or a marketing campaign requiring hyper-realistic visuals, Imagen would be the undisputed champion. But for my app, which was about fostering creativity, enabling rapid iteration, and encouraging artistic expression, Gemini's conversational and context-aware nature was the perfect fit. The decision was made. I would build my app's core experience using Gemini 2.5 Flash.

With the decision made, I dove into the code, setting up the Android Studio project, configuring Firebase, and writing the logic to make that first magical API call. This involved wiring up the Gemini API, building a simple Jetpack Compose interface, and handling the response to display an image. If you’d like to follow along with the detailed, step-by-step implementation, please refer to the appendix at the end of this article.

Once the basic application was working though, I quickly discovered that the journey was far from over. In fact, the most challenging and rewarding part was just beginning.

Choosing the right prompt

I thought that once the code was working, the job was done. I soon realized I was wrong. The real art of getting stunning results from Gemini wasn't in the Kotlin code; it was in the English prose of the prompts. My journey shifted from being just a programmer to becoming part-artist, part-photographer.

My first prompts were simple, just a list of keywords like "old man pottery sunlight." The results were technically correct, but they were generic and lacked life. They felt like stock photos. That’s when I dove into the official Gemini API documentation on prompting strategies, and it completely changed my perspective while experimenting.

Lesson 1: Be Descriptive, Not Just Keyword-Driven

I learned to paint a picture with my words. Instead of my lazy "old man pottery sunlight" prompt, I tried writing a full, narrative sentence as if I were describing a scene in a novel: "A photorealistic close-up of an elderly Japanese ceramicist, his hands weathered and covered in clay, shaping a pot on a wheel in a sunlit studio with dust motes dancing in the light." The result was breathtaking. The image had emotion, story, and a sense of place. The coherence and quality skyrocketed.

Lesson 2: Use the Language of Photography

To get lifelike images, I had to think like a photographer. I started incorporating camera and lighting terminology into my prompts. I wanted a simple image of a coffee mug, but "coffee mug on a table" was boring. So, I tried: "A high-resolution product shot of a ceramic coffee mug on a marble counter, studio-lit with a three-point softbox setup, shallow depth of field." The image that came back looked like it was pulled from a professional advertisement. The lighting was perfect, the focus was sharp, and the background was beautifully blurred.

Lesson 3: Experiment with Styles and Formats

Gemini's artistic range was incredible. I learned that by being explicit, I could get exactly what I wanted. If I needed an icon for my app, I wouldn't just say "happy panda." I would specify: "A kawaii-style sticker of a happy red panda holding a bamboo stalk, flat shading, bold outlines, transparent background." This level of detail gave me a clean, usable asset with a transparent background, saving me editing time later.

Lesson 4: Refine Through Iteration

My biggest realization was that the first result doesn't have to be the final one. Gemini excels at conversational editing. If I generated an image I liked but wasn't perfect, I didn't have to start over. I could follow up with simple, natural language instructions like, "That's great, but make the lighting warmer," or, "Keep everything the same, but change the character's expression to be more serious." This iterative process felt less like using a tool and more like collaborating with a creative partner. Mastering the prompt was a new skill, and it was just as rewarding as mastering a new coding library.

Conversational Editing and Multi-Modal Prompts

After mastering basic text-to-image generation, I discovered a feature that felt like pure science fiction: conversational, multi-modal editing. This was the moment my app evolved from a simple generator into a truly interactive creative canvas.

My first “mind-blown” moment came when I generated a village scene. The image was beautiful, but the sky looked dull and gray instead of the bright blue I had imagined. In any traditional workflow, this would mean starting over, tweaking the prompt, and hoping for the best. But with Gemini, the workflow was revolutionary. I could take the generated image, feed it back to the model along with a new text instruction, and have it edit the image in place.

I implemented this using the Content.builder(). It allowed me to create a single prompt that contained multiple parts: an initial instruction in text, and the base image I wanted to modify. The code looked surprisingly simple:

// Example: Editing an existing image
val baseImage: Bitmap = ... // The image I generated earlier
val editPrompt = Content.builder()
    .addText("Keep the village the same, but change the sky color to vibrant blue.")
    .addImage(baseImage) // I'm sending the image back to the model
    .build()

// The model understands the context and returns an edited image
val editedImage = model.generateContent(editPrompt) //... and extract image part

When I ran this code, the result was flawless. The model returned the exact same image, but now the sky color was a brilliant, vibrant blue. It had understood my natural language instruction in the context of the image I provided.

This opened up a whole new world of possibilities. I quickly expanded on this concept to implement image blending. What if a user could take a selfie and place themselves into a fantasy landscape they had just generated? The logic was the same. I used the Content.builder to combine two images and a text instruction.

// Example: Blending two images
val selfie: Bitmap = ... // From the user's camera
val landscape: Bitmap = ... // An image generated by the user
val fusionPrompt = Content.builder()
    .addText("Take the person from the first image and place them realistically into the scene of the second image.")
    .addImage(selfie)
    .addImage(landscape)
    .build()

val fusedImage = model.generateContent(fusionPrompt) //... and extract image part

This was the real magic. My app was no longer just about creating images from scratch; it was about remixing, refining, and personalizing them. I made sure to add progress indicators for these more complex tasks. But the power it gave my users was more than worth the wait. It transformed the app from a tool into a playground.

Unlocking these advanced features was exhilarating, but building a truly solid user experience required moving beyond the 'happy path.' In fact, the real work of a developer isn't just in making things work; it's in making them work reliably. And this next phase of the project was defined by the lessons learned when things didn't go as planned.

Hard-Learned Lessons: Best Practices & Navigating Limitations

Every development journey has its share of roadblocks and unexpected detours, and mine was no exception. Building with a cutting-edge AI model taught me some valuable lessons, the kind you only learn from experience.

Lesson-1: Crashes: Value of Error Handling

I'll never forget the time my app crashed repeatedly. After some debugging, I realized what was happening. The user was entering very ambiguous prompts. Sometimes, the model, unable to generate a coherent image, would return only a text response, like, "I'm sorry, I can't create that." My code, expecting an ImagePart, would find nothing and crash when it tried to access a null object. That's when I built a much more robust system to gracefully parse the response, check if an image exists, and if not, display the text response to the user as a helpful message. It was a hard-learned lesson in never trusting a network response blindly.

Lesson-2: Slowdowns: Why Monitoring Matters

After a week of intense personal testing, I finally checked the Firebase AI Monitoring dashboard. I was surprised to see the latency metrics. While most requests were fast, some were taking longer, leading to a bad user experience. This data pushed me to implement better user feedback. I added more granular loading indicators, progress bars for multi-image tasks, and clear timeouts. The monitoring dashboard became my early warning system, helping me spot issues before they impacted my users.

Lesson-3: Designing Around Constraints

I also had to learn to treat the model's limitations not as failures, but as creative constraints to design around.

• Image Size: The maximum output resolution is 1024x1024 pixels. At first, I was disappointed I couldn't generate massive, high-resolution art. But then I reframed it: my app was for mobile screens and social sharing, where 1024px is more than enough. I designed my UI around this constraint, ensuring the output always looked crisp and clear on the device.
• Language Support: Performance is best in a handful of languages, including English.
• No Audio/Video: The model doesn't support audio or video inputs. This clarified my app's focus: it would be the best-in-class tool for static image creation and editing, rather than trying to do everything at once.

Embracing these limitations allowed me to build a more focused, reliable, and honest user experience. It was a crucial step in moving from a fun prototype to a production-ready application.

Conclusion: My Journey and Your First Step

My journey started with a simple "what if" and a blank Android Studio project. It led me through the thrill of a first successful API call, the challenge of choosing the right tool, the artistry of mastering the prompt, and the joy of creating something that felt genuinely magical. I learned that building with generative AI is a unique blend of technical programming and creative collaboration.

What I find most exciting is that this incredible power is no longer science fiction or locked away in research labs. It's here, it's production-ready, and it's accessible to every Android developer through tools like the Firebase AI Logic SDK. With just a few lines of code, you can start experimenting and put powerful new features into the hands of your users.

The opportunities are wide open, from generating custom art and editing photos to building smarter shopping tools and creating dynamic game assets. Of course, there are limitations like resolution and language support to design around. But these are small hurdles on the path to creating truly next-generation experiences.

Now, it's your turn. Pick a use case, spin up a Firebase project, and start building. Don't be afraid to experiment, to fail, and to discover the creative potential waiting in these models. Your users will thank you!

Appendix: Step-by-Step Implementation Guide

Setting up the Workbench: Android Project & Firebase

After choosing the model, I finally launched Android Studio (I’m using Meerkat, and I’d recommend it or newer for the best experience). Staring at a new, empty project, I felt that familiar mix of excitement and determination. The first and most critical step wasn't writing a single line of Kotlin, but setting up the solid foundation in Firebase that would serve as the bridge to the Gemini API.

I headed to the Firebase Console, which would orchestrate the connection. The process was surprisingly smooth:

1. Project Creation: First, I created a new Firebase project. I gave it a name that echoed my app's creative spirit “StoryTellerApp”
2. Finding AI Logic: Inside the project dashboard, I found the AI Logic section in the left-hand menu and clicked 'Get Started.' This was my gateway
3. Enabling the API: The console wizard prompted me to enable the Gemini Developer API. I was relieved to see it included a generous free tier, which was perfect for my prototyping and development phase without any initial investment.
4. The API Key: Upon enabling the API, the console provided me with my unique API key. I made a crucial mental note here: never hardcode this key in the client-side app. For this initial build, I handled it carefully, but I knew that for a production app, I would need to manage this key on a secure server to protect it from being exposed.

Next, I had to register my Android app with this new Firebase project. This involved adding my app's unique package name and then downloading the all-important google-services.json file. I remember triple-checking that I had placed it in the correct app/ module directory. I've learned from experience that a small mistake there can lead to hours of frustrating initialization errors.

Next up was the familiar Android developer ritual: the Gradle file update. To get my app and Firebase talking, I needed to pull in a few essential toolkits.

First, in my app-level build.gradle.kts file, I added the following firebase related dependencies:

dependencies {
    implementation("com.google.firebase:firebase-ai")
    implementation(platform("com.google.firebase:firebase-bom:34.3.0"))
    implementation("com.google.firebase:firebase-analytics")
}

But that's just one half of the equation. I also had to add the Google Services plugin to my project-level build.gradle.kts file. This is the piece that actually processes that google-services.json file we downloaded earlier:

// In my root build.gradle.kts
plugins {
    id("com.google.gms.google-services") version "4.4.3" apply false
}

If you've ever set up Firebase before, this process will feel familiar, it's all laid out clearly in their official setup guide. With a quick Gradle sync, my project was now officially Firebase-aware.

The last piece of the setup puzzle was to initialize Firebase when my app starts. This ensures that the connection is ready the moment the user launches the app. I created a custom Application class and added the single line of code that starts everything:

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        FirebaseApp.initializeApp(this)
    }
}

With that, my workbench was set up. The plumbing was in place, the tools were laid out, and the foundation was solid. Now, it was time for the really fun part: making the magic happen.

The "Hello, World!" of Image Generation: My First API Call

This was the moment of truth. I needed to write the code that would take a string of text, send it to the cloud, and get a bitmap back.

My first attempt failed, of course. I confidently asked the model for an image and got... nothing. A crash. After an hour of debugging and actually reading the docs, I found the problem. The image models are "multimodal," which is a fancy way of saying they can send back both text and images. You have to tell them you're prepared to receive both, otherwise they might just send you a text. It was a simple one-line fix that felt like a huge discovery.

Back in my MainActivity.kt file, inside the onCreate method, I set up my connection to the Gemini model. This is where I defined which model to use and, crucially, added that important line to tell it I was expecting both text and images in the response. I learned that using the generationConfig { ... } builder makes the code super clean and readable.

// Inside MainActivity.kt

// First, I declared a lateinit var for the model at the class level
private lateinit var model: com.google.firebase.ai.GenerativeModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // ... other setup code

    // Then, I initialized the model right inside onCreate
    model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
        modelName = "gemini-2.5-flash-image",
        // Configure using the clean Kotlin DSL
        generationConfig = generationConfig {
            responseModalities = listOf(ResponseModality.TEXT, ResponseModality.IMAGE)
        }
    )

    // ... setContent call
}

With the model ready, I wrote the core function to actually perform the generation. I made it a private suspend fun inside my MainActivity so it could be easily called from a coroutine. The try-catch block here is my safety net; if anything goes wrong during the API call, it prints the error for debugging instead of crashing the whole app.

// Inside MainActivity.kt

// Generate image using Gemini
private suspend fun generateImage(prompt: String): Bitmap? {
    return try {
        val response = model.generateContent(prompt)
        response.candidates.first().content.parts
            .filterIsInstance<ImagePart>()
            .firstOrNull()?.image
    } catch (e: Exception) {
        // A simple way to see errors in Logcat during development
        e.printStackTrace()
        null
    }
}

I hooked this all up to a simple UI. I typed "a happy robot eating a taco." I clicked. A loading spinner spun. And then... a picture of a cheerful, metal robot with a taco appeared on my screen. It actually worked. This was indeed the magic I was looking for!

Building the Interface: A simple Canvas with Jetpack Compose

My first version of the UI was just a text box and a button. But I quickly realized it had a huge flaw: when you tapped 'Generate,' the app just... sat there. You couldn't tell if it was working or if it had crashed. It felt broken. I knew I needed to give the user some feedback.

So, I added a simple but effective isLoading state to my UI. When the user taps the button, isLoading becomes true, the button gets disabled to prevent spamming, and a CircularProgressIndicator appears. When the image comes back (or fails), isLoading flips back to false. It's a small change that makes a world of difference in user experience.

Here’s the complete ImageGeneratorScreen Composable I ended up with:

@Composable
fun ImageGeneratorScreen(
    modifier: Modifier = Modifier,
    onGenerate: (String, (Bitmap?) -> Unit) -> Unit
) {
    var prompt by remember { mutableStateOf("") }
    var image by remember { mutableStateOf<Bitmap?>(null) }
    var isLoading by remember { mutableStateOf(false) }

    Column(
        modifier = modifier.padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp)
    ) {
        OutlinedTextField(
            value = prompt,
            onChange = { prompt = it },
            label = { Text("Enter your prompt") },
            modifier = Modifier.fillMaxWidth()
        )

        Button(
            onClick = {
                isLoading = true
                onGenerate(prompt) { result ->
                    image = result
                    isLoading = false
                }
            },
            modifier = Modifier.fillMaxWidth(),
            enabled = !isLoading // The button is disabled while loading!
        ) {
            if (isLoading) {
                CircularProgressIndicator(modifier = Modifier.size(24.dp))
            } else {
                Text("Generate Image")
            }
        }

        image?.let {
            Image(
                bitmap = it.asImageBitmap(),
                contentDescription = null,
                modifier = Modifier
                    .fillMaxWidth()
                    .height(250.dp)
            )
        }
    }
}

Finally, I tied this UI to my logic inside `MainActivity` setContent block. I passed a lambda to my ImageGeneratorScreen that launches a coroutine on the lifecycleScope and calls my generateImage function. This is the glue that connects the UI to the AI.