diff --git a/build.gradle.kts b/build.gradle.kts
index 08912624..d4ea1831 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,6 +1,3 @@
-import org.codehaus.groovy.runtime.DefaultGroovyMethods.step
-import org.jetbrains.kotlin.gradle.internal.builtins.StandardNames.FqNames.target
-
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
     alias(libs.plugins.gradle.versions)
@@ -94,7 +91,11 @@ allprojects {
         }
         format("xml") {
             target("**/*.xml")
-            targetExclude("**/build/**/*.xml", "spotless/**/*.xml")
+            targetExclude(
+                "**/build/**/*.xml",
+                "spotless/**/*.xml",
+                ".idea/**",
+            )
             // Look for the root tag or a tag that is a snippet
             licenseHeaderFile(rootProject.file("spotless/copyright.xml"), "(<[a-zA-Z])|(<!--\\s+(//\\s*)?\\[START)").skipLinesMatching(".*START.*")
         }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 5f1a3e9b..5517bdcc 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -40,10 +40,13 @@ compose-latest = "1.9.3"
 composeUiTooling = "1.5.3"
 coreSplashscreen = "1.0.1"
 coroutines = "1.10.2"
+firebase-bom = "34.4.0"
 glide = "1.0.0-beta08"
 google-maps = "19.2.0"
 gradle-versions = "0.53.0"
 guava = "33.5.0-jre"
+guava-android = "31.0.1-android"
+reactive-streams = "1.0.4"
 hilt = "2.57.2"
 horologist = "0.8.2-alpha"
 junit = "4.13.2"
@@ -176,11 +179,15 @@ appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat"
 coil-kt-compose = { module = "io.coil-kt:coil-compose", version.ref = "coil" }
 compose-foundation = { module = "androidx.wear.compose:compose-foundation", version.ref = "wearComposeFoundation" }
 compose-ui-tooling = { module = "androidx.wear.compose:compose-ui-tooling", version.ref = "composeUiTooling" }
+firebase-bom = { module = "com.google.firebase:firebase-bom", version.ref = "firebase-bom" }
+firebase-ai = { module = "com.google.firebase:firebase-ai" }
 glide-compose = { module = "com.github.bumptech.glide:compose", version.ref = "glide" }
 google-android-material = { module = "com.google.android.material:material", version.ref = "material" }
 googlemaps-compose = { module = "com.google.maps.android:maps-compose", version.ref = "maps-compose" }
 googlemaps-maps = { module = "com.google.android.gms:play-services-maps", version.ref = "google-maps" }
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
+guava-android = { module = "com.google.guava:guava", version.ref = "guava-android" }
+reactive-streams = { module = "org.reactivestreams:reactive-streams", version.ref = "reactive-streams" }
 hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hilt" }
 hilt-compiler = { module = "com.google.dagger:hilt-android-compiler", version.ref = "hilt" }
 horologist-compose-layout = { module = "com.google.android.horologist:horologist-compose-layout", version.ref = "horologist" }
diff --git a/misc/build.gradle.kts b/misc/build.gradle.kts
index cb090542..6a2dc60d 100644
--- a/misc/build.gradle.kts
+++ b/misc/build.gradle.kts
@@ -1,3 +1,4 @@
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
@@ -72,6 +73,10 @@ dependencies {
     implementation(libs.androidx.startup.runtime)
     implementation(libs.androidx.window.java)
     implementation(libs.appcompat)
+    implementation(platform(libs.firebase.bom))
+    implementation(libs.firebase.ai)
+    implementation(libs.guava.android)
+    implementation(libs.reactive.streams)
     testImplementation(libs.junit)
     testImplementation(kotlin("test"))
     androidTestImplementation(libs.androidx.test.ext.junit)
diff --git a/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippets.kt b/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippets.kt
new file mode 100644
index 00000000..56894510
--- /dev/null
+++ b/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippets.kt
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.snippets.ai
+
+import android.content.ContentResolver
+import android.graphics.Bitmap
+import android.net.Uri
+import com.google.firebase.Firebase
+import com.google.firebase.ai.ai
+import com.google.firebase.ai.type.GenerativeBackend
+import com.google.firebase.ai.type.ImagePart
+import com.google.firebase.ai.type.ResponseModality
+import com.google.firebase.ai.type.content
+import com.google.firebase.ai.type.generationConfig
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+object GeminiDeveloperApi25FlashModelConfiguration {
+    // [START android_gemini_developer_api_gemini_25_flash_model]
+    // Start by instantiating a GenerativeModel and specifying the model name:
+    val model = Firebase.ai(backend = GenerativeBackend.googleAI())
+        .generativeModel("gemini-2.5-flash")
+    // [END android_gemini_developer_api_gemini_25_flash_model]
+}
+
+object Gemini25FlashImagePreviewModelConfiguration {
+    // [START android_gemini_developer_api_gemini_25_flash_image_model]
+    val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
+        modelName = "gemini-2.5-flash-image-preview",
+        // Configure the model to respond with text and images (required)
+        generationConfig = generationConfig {
+            responseModalities = listOf(
+                ResponseModality.TEXT,
+                ResponseModality.IMAGE
+            )
+        }
+    )
+    // [END android_gemini_developer_api_gemini_25_flash_image_model]
+}
+
+@Suppress("unused")
+fun textOnlyInput(scope: CoroutineScope) {
+    val model = GeminiDeveloperApi25FlashModelConfiguration.model
+    // [START android_gemini_developer_api_text_only_input]
+    scope.launch {
+        val response = model.generateContent("Write a story about a magic backpack.")
+    }
+    // [END android_gemini_developer_api_text_only_input]
+}
+
+@Suppress("unused")
+fun textAndImageInput(scope: CoroutineScope, bitmap: Bitmap) {
+    val model = GeminiDeveloperApi25FlashModelConfiguration.model
+    // [START android_gemini_developer_api_multimodal_input]
+    scope.launch {
+        val response = model.generateContent(
+            content {
+                image(bitmap)
+                text("what is the object in the picture?")
+            }
+        )
+    }
+    // [END android_gemini_developer_api_multimodal_input]
+}
+
+@Suppress("unused")
+fun textAndAudioInput(
+    scope: CoroutineScope,
+    contentResolver: ContentResolver,
+    audioUri: Uri
+) {
+    val model = GeminiDeveloperApi25FlashModelConfiguration.model
+    // [START android_gemini_developer_api_multimodal_audio_input]
+    scope.launch {
+        contentResolver.openInputStream(audioUri).use { stream ->
+            stream?.let {
+                val bytes = it.readBytes()
+
+                val prompt = content {
+                    inlineData(bytes, "audio/mpeg") // Specify the appropriate audio MIME type
+                    text("Transcribe this audio recording.")
+                }
+
+                val response = model.generateContent(prompt)
+            }
+        }
+    }
+    // [END android_gemini_developer_api_multimodal_audio_input]
+}
+
+@Suppress("unused")
+fun textAndVideoInput(
+    scope: CoroutineScope,
+    contentResolver: ContentResolver,
+    videoUri: Uri
+) {
+    val model = GeminiDeveloperApi25FlashModelConfiguration.model
+    // [START android_gemini_developer_api_multimodal_video_input]
+    scope.launch {
+        contentResolver.openInputStream(videoUri).use { stream ->
+            stream?.let {
+                val bytes = it.readBytes()
+
+                val prompt = content {
+                    inlineData(bytes, "video/mp4") // Specify the appropriate video MIME type
+                    text("Describe the content of this video")
+                }
+
+                val response = model.generateContent(prompt)
+            }
+        }
+    }
+    // [END android_gemini_developer_api_multimodal_video_input]
+}
+
+@Suppress("unused")
+fun multiTurnChat(scope: CoroutineScope) {
+    val model = GeminiDeveloperApi25FlashModelConfiguration.model
+    // [START android_gemini_developer_api_multiturn_chat]
+    val chat = model.startChat(
+        history = listOf(
+            content(role = "user") { text("Hello, I have 2 dogs in my house.") },
+            content(role = "model") { text("Great to meet you. What would you like to know?") }
+        )
+    )
+
+    scope.launch {
+        val response = chat.sendMessage("How many paws are in my house?")
+    }
+    // [END android_gemini_developer_api_multiturn_chat]
+}
+
+@Suppress("unused")
+fun generateImageFromText(scope: CoroutineScope) {
+    val model = Gemini25FlashImagePreviewModelConfiguration.model
+    // [START android_gemini_developer_api_generate_image_from_text]
+    scope.launch {
+        // Provide a text prompt instructing the model to generate an image
+        val prompt =
+            "A hyper realistic picture of a t-rex with a blue bag pack roaming a pre-historic forest."
+        // To generate image output, call `generateContent` with the text input
+        val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
+            .candidates.first().content.parts.filterIsInstance<ImagePart>()
+            .firstOrNull()?.image
+    }
+    // [END android_gemini_developer_api_generate_image_from_text]
+}
+
+@Suppress("unused")
+fun editImage(scope: CoroutineScope, bitmap: Bitmap) {
+    val model = Gemini25FlashImagePreviewModelConfiguration.model
+    // [START android_gemini_developer_api_edit_image]
+    scope.launch {
+        // Provide a text prompt instructing the model to edit the image
+        val prompt = content {
+            image(bitmap)
+            text("Edit this image to make it look like a cartoon")
+        }
+        // To edit the image, call `generateContent` with the prompt (image and text input)
+        val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
+            .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
+        // Handle the generated text and image
+    }
+    // [END android_gemini_developer_api_edit_image]
+}
+
+@Suppress("unused")
+fun editImageWithChat(scope: CoroutineScope, bitmap: Bitmap) {
+    val model = Gemini25FlashImagePreviewModelConfiguration.model
+    // [START android_gemini_developer_api_edit_image_chat]
+    scope.launch {
+        // Create the initial prompt instructing the model to edit the image
+        val prompt = content {
+            image(bitmap)
+            text("Edit this image to make it look like a cartoon")
+        }
+        // Initialize the chat
+        val chat = model.startChat()
+        // To generate an initial response, send a user message with the image and text prompt
+        var response = chat.sendMessage(prompt)
+        // Inspect the returned image
+        var generatedImageAsBitmap: Bitmap? = response
+            .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
+        // Follow up requests do not need to specify the image again
+        response = chat.sendMessage("But make it old-school line drawing style")
+        generatedImageAsBitmap = response
+            .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
+    }
+    // [END android_gemini_developer_api_edit_image_chat]
+}
diff --git a/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippetsJava.java b/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippetsJava.java
new file mode 100644
index 00000000..691c2f39
--- /dev/null
+++ b/misc/src/main/java/com/example/snippets/ai/GeminiDeveloperApiSnippetsJava.java
@@ -0,0 +1,375 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.snippets.ai;
+
+import android.app.Application;
+import android.content.ContentResolver;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.util.Log;
+
+import com.example.snippets.R;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.firebase.ai.FirebaseAI;
+import com.google.firebase.ai.GenerativeModel;
+import com.google.firebase.ai.java.ChatFutures;
+import com.google.firebase.ai.java.GenerativeModelFutures;
+import com.google.firebase.ai.type.Content;
+import com.google.firebase.ai.type.GenerateContentResponse;
+import com.google.firebase.ai.type.GenerativeBackend;
+import com.google.firebase.ai.type.ImagePart;
+import com.google.firebase.ai.type.Part;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Executor;
+
+@SuppressWarnings("unused")
+public final class GeminiDeveloperApiSnippetsJava {
+
+    private static final String TAG = "GeminiDeveloperApiSnippetsJava";
+
+    private GeminiDeveloperApiSnippetsJava() {}
+
+    static final class GeminiDeveloperApi25FlashModelConfigurationJava {
+        public static GenerativeModelFutures model;
+
+        static {
+            // [START android_gemini_developer_api_gemini_25_flash_model_java]
+            GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
+                    .generativeModel("gemini-2.5-flash");
+
+            GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);
+            // [END android_gemini_developer_api_gemini_25_flash_model_java]
+            GeminiDeveloperApi25FlashModelConfigurationJava.model = model;
+        }
+    }
+
+    static final class Gemini25FlashImagePreviewModelConfigurationJava {
+        public static GenerativeModelFutures model;
+
+        static {
+            // [START android_gemini_developer_api_gemini_25_flash_image_model_java]
+            GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
+                    .generativeModel("gemini-2.5-flash");
+
+            GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);
+            // [END android_gemini_developer_api_gemini_25_flash_image_model_java]
+            Gemini25FlashImagePreviewModelConfigurationJava.model = model;
+        }
+
+    }
+
+    public static void textOnlyInput(Executor executor) {
+        GenerativeModelFutures model = GeminiDeveloperApi25FlashModelConfigurationJava.model;
+        // [START android_gemini_developer_api_text_only_input_java]
+        Content prompt = new Content.Builder()
+                .addText("Write a story about a magic backpack.")
+                .build();
+
+        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
+        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                String resultText = result.getText();
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_text_only_input_java]
+    }
+
+    public static void textAndImageInput(Executor executor, Bitmap bitmap) {
+        GenerativeModelFutures model = GeminiDeveloperApi25FlashModelConfigurationJava.model;
+        // [START android_gemini_developer_api_multimodal_input_java]
+        Content content = new Content.Builder()
+                .addImage(bitmap)
+                .addText("what is the object in the picture?")
+                .build();
+
+        ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
+        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                String resultText = result.getText();
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_multimodal_input_java]
+    }
+
+    public static void textAndAudioInput(Executor executor, Application applicationContext, Uri audioUri) {
+        GenerativeModelFutures model = GeminiDeveloperApi25FlashModelConfigurationJava.model;
+        // [START android_gemini_developer_api_multimodal_audio_input_java]
+        ContentResolver resolver = applicationContext.getContentResolver();
+
+        try (InputStream stream = resolver.openInputStream(audioUri)) {
+            File audioFile = new File(new URI(audioUri.toString()));
+            int audioSize = (int) audioFile.length();
+            byte[] audioBytes = new byte[audioSize];
+            if (stream != null) {
+                stream.read(audioBytes, 0, audioBytes.length);
+                stream.close();
+
+                // Provide a prompt that includes audio specified earlier and text
+                Content prompt = new Content.Builder()
+                        .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
+                        .addText("Transcribe what's said in this audio recording.")
+                        .build();
+
+                // To generate text output, call `generateContent` with the prompt
+                ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
+                Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+                    @Override
+                    public void onSuccess(GenerateContentResponse result) {
+                        String text = result.getText();
+                        Log.d(TAG, (text == null) ? "" : text);
+                    }
+                    @Override
+                    public void onFailure(Throwable t) {
+                        Log.e(TAG, "Failed to generate a response", t);
+                    }
+                }, executor);
+            } else {
+                Log.e(TAG, "Error getting input stream for file.");
+                // Handle the error appropriately
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to read the audio file", e);
+        } catch (URISyntaxException e) {
+            Log.e(TAG, "Invalid audio file", e);
+        }
+        // [END android_gemini_developer_api_multimodal_audio_input_java]
+    }
+
+    public static void textAndVideoInput(Executor executor, Application applicationContext, Uri videoUri) {
+        GenerativeModelFutures model = GeminiDeveloperApi25FlashModelConfigurationJava.model;
+        // [START android_gemini_developer_api_multimodal_video_input_java]
+        ContentResolver resolver = applicationContext.getContentResolver();
+
+        try (InputStream stream = resolver.openInputStream(videoUri)) {
+            File videoFile = new File(new URI(videoUri.toString()));
+            int videoSize = (int) videoFile.length();
+            byte[] videoBytes = new byte[videoSize];
+            if (stream != null) {
+                stream.read(videoBytes, 0, videoBytes.length);
+                stream.close();
+
+                // Provide a prompt that includes video specified earlier and text
+                Content prompt = new Content.Builder()
+                        .addInlineData(videoBytes, "video/mp4")
+                        .addText("Describe the content of this video")
+                        .build();
+
+                // To generate text output, call generateContent with the prompt
+                ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
+                Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+                    @Override
+                    public void onSuccess(GenerateContentResponse result) {
+                        String resultText = result.getText();
+                        System.out.println(resultText);
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        t.printStackTrace();
+                    }
+                }, executor);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        }
+        // [END android_gemini_developer_api_multimodal_video_input_java]
+    }
+
+    public static void multiTurnChat(Executor executor) {
+        GenerativeModelFutures model = GeminiDeveloperApi25FlashModelConfigurationJava.model;
+        // [START android_gemini_developer_api_multiturn_chat_java]
+        Content.Builder userContentBuilder = new Content.Builder();
+        userContentBuilder.setRole("user");
+        userContentBuilder.addText("Hello, I have 2 dogs in my house.");
+        Content userContent = userContentBuilder.build();
+
+        Content.Builder modelContentBuilder = new Content.Builder();
+        modelContentBuilder.setRole("model");
+        modelContentBuilder.addText("Great to meet you. What would you like to know?");
+        Content modelContent = modelContentBuilder.build();
+
+        List<Content> history = Arrays.asList(userContent, modelContent);
+
+        // Initialize the chat
+        ChatFutures chat = model.startChat(history);
+
+        // Create a new user message
+        Content.Builder messageBuilder = new Content.Builder();
+        messageBuilder.setRole("user");
+        messageBuilder.addText("How many paws are in my house?");
+
+        Content message = messageBuilder.build();
+
+        // Send the message
+        ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
+        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                String resultText = result.getText();
+                System.out.println(resultText);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_multiturn_chat_java]
+    }
+
+    public static void generateImageFromText(Executor executor) {
+        GenerativeModelFutures model = Gemini25FlashImagePreviewModelConfigurationJava.model;
+        // [START android_gemini_developer_api_generate_image_from_text_java]
+        // Provide a text prompt instructing the model to generate an image
+        Content prompt = new Content.Builder()
+                .addText("Generate an image of the Eiffel Tower with fireworks in the background.")
+                .build();
+        // To generate an image, call `generateContent` with the text input
+        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
+        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                // iterate over all the parts in the first candidate in the result object
+                for (Part part : result.getCandidates().get(0).getContent().getParts()) {
+                    if (part instanceof ImagePart) {
+                        ImagePart imagePart = (ImagePart) part;
+                        // The returned image as a bitmap
+                        Bitmap generatedImageAsBitmap = imagePart.getImage();
+                        break;
+                    }
+                }
+            }
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_generate_image_from_text_java]
+    }
+
+    public static void editImage(Executor executor, Resources resources) {
+        GenerativeModelFutures model = Gemini25FlashImagePreviewModelConfigurationJava.model;
+        // [START android_gemini_developer_api_edit_image_java]
+        // Provide an image for the model to edit
+        Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
+        // Provide a text prompt instructing the model to edit the image
+        Content promptcontent = new Content.Builder()
+                .addImage(bitmap)
+                .addText("Edit this image to make it look like a cartoon")
+                .build();
+        // To edit the image, call `generateContent` with the prompt (image and text input)
+        ListenableFuture<GenerateContentResponse> response = model.generateContent(promptcontent);
+        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                // iterate over all the parts in the first candidate in the result object
+                for (Part part : result.getCandidates().get(0).getContent().getParts()) {
+                    if (part instanceof ImagePart) {
+                        ImagePart imagePart = (ImagePart) part;
+                        Bitmap generatedImageAsBitmap = imagePart.getImage();
+                        break;
+                    }
+                }
+            }
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_edit_image_java]
+    }
+
+    public static void editImageWithChat(Executor executor, Resources resources) {
+        GenerativeModelFutures model = Gemini25FlashImagePreviewModelConfigurationJava.model;
+        // [START android_gemini_developer_api_edit_image_chat_java]
+        // Provide an image for the model to edit
+        Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
+        // Initialize the chat
+        ChatFutures chat = model.startChat();
+        // Create the initial prompt instructing the model to edit the image
+        Content prompt = new Content.Builder()
+                .setRole("user")
+                .addImage(bitmap)
+                .addText("Edit this image to make it look like a cartoon")
+                .build();
+        // To generate an initial response, send a user message with the image and text prompt
+        ListenableFuture<GenerateContentResponse> response = chat.sendMessage(prompt);
+        // Extract the image from the initial response
+        ListenableFuture<Bitmap> initialRequest = Futures.transform(response,
+                result -> {
+                    for (Part part : result.getCandidates().get(0).getContent().getParts()) {
+                        if (part instanceof ImagePart) {
+                            ImagePart imagePart = (ImagePart) part;
+                            return imagePart.getImage();
+                        }
+                    }
+                    return null;
+                }, executor);
+        // Follow up requests do not need to specify the image again
+        ListenableFuture<GenerateContentResponse> modelResponseFuture = Futures.transformAsync(
+                initialRequest,
+                generatedImage -> {
+                    Content followUpPrompt = new Content.Builder()
+                            .addText("But make it old-school line drawing style")
+                            .build();
+                    return chat.sendMessage(followUpPrompt);
+                }, executor);
+        // Add a final callback to check the reworked image
+        Futures.addCallback(modelResponseFuture, new FutureCallback<GenerateContentResponse>() {
+            @Override
+            public void onSuccess(GenerateContentResponse result) {
+                for (Part part : result.getCandidates().get(0).getContent().getParts()) {
+                    if (part instanceof ImagePart) {
+                        ImagePart imagePart = (ImagePart) part;
+                        Bitmap generatedImageAsBitmap = imagePart.getImage();
+                        break;
+                    }
+                }
+            }
+            @Override
+            public void onFailure(Throwable t) {
+                t.printStackTrace();
+            }
+        }, executor);
+        // [END android_gemini_developer_api_edit_image_chat_java]
+    }
+}
diff --git a/misc/src/main/java/com/example/snippets/ai/ImagenSnippets.kt b/misc/src/main/java/com/example/snippets/ai/ImagenSnippets.kt
new file mode 100644
index 00000000..2f55c4ad
--- /dev/null
+++ b/misc/src/main/java/com/example/snippets/ai/ImagenSnippets.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(PublicPreviewAPI::class)
+
+package com.example.snippets.ai
+
+import com.google.firebase.Firebase
+import com.google.firebase.ai.ai
+import com.google.firebase.ai.type.GenerativeBackend
+import com.google.firebase.ai.type.ImagenAspectRatio
+import com.google.firebase.ai.type.ImagenGenerationConfig
+import com.google.firebase.ai.type.ImagenImageFormat
+import com.google.firebase.ai.type.ImagenPersonFilterLevel
+import com.google.firebase.ai.type.ImagenSafetyFilterLevel
+import com.google.firebase.ai.type.ImagenSafetySettings
+import com.google.firebase.ai.type.PublicPreviewAPI
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+private object ImagenModelConfiguration {
+    // [START android_imagen_model_configuration]
+    val config = ImagenGenerationConfig(
+        numberOfImages = 2,
+        aspectRatio = ImagenAspectRatio.LANDSCAPE_16x9,
+        imageFormat = ImagenImageFormat.jpeg(compressionQuality = 100),
+        addWatermark = false,
+    )
+
+    // Initialize the Gemini Developer API backend service
+    // For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
+    val model = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
+        modelName = "imagen-4.0-generate-001",
+        generationConfig = config,
+        safetySettings = ImagenSafetySettings(
+            safetyFilterLevel = ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE,
+            personFilterLevel = ImagenPersonFilterLevel.BLOCK_ALL
+        ),
+    )
+    // [END android_imagen_model_configuration]
+}
+
+private fun generateImagesWithImagen(scope: CoroutineScope) {
+    val model = ImagenModelConfiguration.model
+    scope.launch {
+        // [START android_imagen_generate_images]
+        val imageResponse = model.generateImages(
+            prompt = "A hyper realistic picture of a t-rex with a blue bagpack in a prehistoric forest",
+        )
+        val image = imageResponse.images.first()
+        val bitmapImage = image.asBitmap()
+        // [END android_imagen_generate_images]
+    }
+}
diff --git a/misc/src/main/java/com/example/snippets/ai/ImagenSnippetsJava.java b/misc/src/main/java/com/example/snippets/ai/ImagenSnippetsJava.java
new file mode 100644
index 00000000..2c6a1213
--- /dev/null
+++ b/misc/src/main/java/com/example/snippets/ai/ImagenSnippetsJava.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.snippets.ai;
+
+import android.graphics.Bitmap;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.firebase.ai.FirebaseAI;
+import com.google.firebase.ai.java.ImagenModelFutures;
+import com.google.firebase.ai.type.GenerativeBackend;
+import com.google.firebase.ai.type.ImagenAspectRatio;
+import com.google.firebase.ai.type.ImagenGenerationConfig;
+import com.google.firebase.ai.type.ImagenGenerationResponse;
+import com.google.firebase.ai.type.ImagenImageFormat;
+import com.google.firebase.ai.type.ImagenInlineImage;
+import com.google.firebase.ai.type.ImagenPersonFilterLevel;
+import com.google.firebase.ai.type.ImagenSafetyFilterLevel;
+import com.google.firebase.ai.type.ImagenSafetySettings;
+import com.google.firebase.ai.type.PublicPreviewAPI;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+
+@SuppressWarnings("unused")
+@PublicPreviewAPI
+final class ImagenSnippetsJava {
+
+    private ImagenSnippetsJava() {}
+
+    static final class ImagenModelConfigurationJava {
+        public static ImagenModelFutures model;
+    }
+
+    static {
+        // [START android_imagen_model_configuration_java]
+        ImagenGenerationConfig config = new ImagenGenerationConfig.Builder()
+                .setNumberOfImages(2)
+                .setAspectRatio(ImagenAspectRatio.LANDSCAPE_16x9)
+                .setImageFormat(ImagenImageFormat.jpeg(100))
+                .setAddWatermark(false)
+                .build();
+
+        // For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
+        ImagenModelFutures model = ImagenModelFutures.from(
+                FirebaseAI.getInstance(GenerativeBackend.googleAI()).imagenModel(
+                        "imagen-4.0-generate-001",
+                        config,
+                        new ImagenSafetySettings(
+                                ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE,
+                                ImagenPersonFilterLevel.BLOCK_ALL))
+        );
+        // [END android_imagen_model_configuration_java]
+        ImagenModelConfigurationJava.model = model;
+    }
+
+    public static void generateImagesWithImagen(Executor executor) {
+        ImagenModelFutures model = ImagenModelConfigurationJava.model;
+        // [START android_imagen_generate_images_java]
+        ListenableFuture<ImagenGenerationResponse<ImagenInlineImage>> futureResponse =
+                model.generateImages(
+                        "A hyper realistic picture of a t-rex with a blue bagpack in a prehistoric forest");
+
+        try {
+            ImagenGenerationResponse<ImagenInlineImage> imageResponse = futureResponse.get();
+            List<ImagenInlineImage> images = null;
+            if (imageResponse != null) {
+                images = imageResponse.getImages();
+            }
+            if (images != null && !images.isEmpty()) {
+                ImagenInlineImage image = images.get(0);
+                Bitmap bitmapImage = image.asBitmap();
+                // Use bitmapImage
+            }
+        } catch (ExecutionException | InterruptedException e) {
+            e.printStackTrace();
+        }
+        // [END android_imagen_generate_images_java]
+    }
+}
diff --git a/misc/src/main/res/drawable/scones.xml b/misc/src/main/res/drawable/scones.xml
new file mode 100644
index 00000000..2eafb40a
--- /dev/null
+++ b/misc/src/main/res/drawable/scones.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright 2025 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          https://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<animated-image xmlns:android="http://schemas.android.com/apk/res/android">
+
+</animated-image>