⟐ Dev Tools/2026-03-27Advanced

Notes from Adding a Gemini-powered Chat to a Flutter App I Run Solo — design choices and gotchas across iOS and Android

Working notes from layering Gemini API on top of a Flutter app I've been shipping to iOS and Android as a solo indie developer. Covers monthly cost breakdown (Gemini + Firestore + AdMob), how I recover streamed responses that stall on iOS background, and the practical line for free vs. premium tiering — with code and real numbers.

gemini-api²⁷⁹ flutter dart cross-platform³ chat-app streaming²⁸ firebase⁶ multimodal⁴⁴

✦ Premium Article

I put off adding a chat feature to one of my Flutter apps for about six months. The reason was simple: that app runs on AdMob revenue, so the moment per-token cost started eating into the ad income I'd have to pull the whole feature back out. When Gemini Flash pricing dropped to where the math finally worked in 2026, I shipped it into one app and ran it in production. These are the notes from that.

That practical constraint is what this article is really about. I'll cover the Flutter + Gemini code you need to get a streaming chat working across iOS and Android, but I'll keep coming back to numbers from the app I actually run: how much Gemini Flash costs me per month at ~8,000 MAU, how Firestore writes blow up if you save streamed deltas live, and where the AdMob increase from longer sessions started showing up.

Setup and context — why I picked Flutter × Gemini as a solo developer

To set expectations: my apps are AdMob-funded, so the first criterion was "can this be added without dropping eCPM?" Flutter lets me target iOS and Android (and the Web build, with caveats I'll mention later) from one codebase — that matters because, as a solo developer running multiple apps, the time cost of maintaining two native chat implementations would have killed the project before launch.

Gemini Flash at $0.075 / 1M input tokens and $0.30 / 1M output tokens (May 2026 pricing) is the part that made the math work. At an average of 800–1,200 tokens per chat session, the marginal cost stays well under the AdMob lift I'd expect from the extra session time. This is roughly the same calculation I ran when I added a Kotlin-native Gemini integration to a different app — see Gemini API × Kotlin — embedding AI in an Android app for the native-side version of this story.

Environment Setup and Project Configuration

Prerequisites

Before you begin, ensure you have the following ready:

Flutter SDK 3.22+ (Dart 3.4+)
A Gemini API key from Google AI Studio
A Firebase project (for authentication and Firestore)
Android Studio or VS Code with Flutter extensions

Creating the Project and Adding Dependencies

Start by creating a Flutter project and adding the required packages:

flutter create gemini_chat_app
cd gemini_chat_app
flutter pub add google_generative_ai
flutter pub add flutter_markdown
flutter pub add image_picker
flutter pub add firebase_core firebase_auth cloud_firestore
flutter pub add flutter_riverpod
flutter pub add envied envied_generator build_runner --dev

Here's what each key package does:

google_generative_ai — The official Gemini API Dart SDK. Provides a unified interface for model calls, streaming, and multimodal input
flutter_markdown — Renders Gemini's Markdown-formatted responses with rich styling
flutter_riverpod — State management for chat history, streaming state, and error handling
envied — Obfuscates API keys at compile time to prevent hardcoding exposure

Secure API Key Management

Hardcoding API keys in source code is strictly prohibited. Use the envied package to load keys from environment variables:

// lib/env/env.dart
import 'package:envied/envied.dart';
 
part 'env.g.dart';
 
@Envied(path: '.env')
abstract class Env {
  @EnviedField(varName: 'GEMINI_API_KEY', obfuscate: true)
  static String geminiApiKey = _Env.geminiApiKey;
}

Create a .env file at the project root and add it to .gitignore:

GEMINI_API_KEY=YOUR_GEMINI_API_KEY

dart run build_runner build

This obfuscates the API key within the compiled binary, providing resistance against reverse engineering.

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Real monthly cost breakdown of running Gemini + Firestore in a Flutter app whose revenue is mostly AdMob, with the numbers that actually offset the API spend

✦The Riverpod + AppLifecycleState pattern I use to recover streamed responses that silently stall when iOS suspends the HTTP/2 socket

✦Where AdMob and an AI chat feature can coexist without dragging eCPM down — and the MAU threshold where I'd flip to a paid tier instead

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Designing the Gemini Service Layer

The core of the application — communication with the Gemini API — is encapsulated in a service class. This cleanly separates UI concerns from business logic.

// lib/services/gemini_service.dart
import 'dart:async';
import 'dart:typed_data';
import 'package:google_generative_ai/google_generative_ai.dart';
import '../env/env.dart';
 
class GeminiService {
  late final GenerativeModel _model;
  late final GenerativeModel _visionModel;
  ChatSession? _chatSession;
 
  GeminiService() {
    // Text chat model
    _model = GenerativeModel(
      model: 'gemini-2.5-flash',
      apiKey: Env.geminiApiKey,
      generationConfig: GenerationConfig(
        temperature: 0.7,
        topP: 0.95,
        topK: 40,
        maxOutputTokens: 8192,
      ),
      systemInstruction: Content.text(
        'You are a helpful and knowledgeable AI assistant. '
        'Provide accurate, clear answers to user questions. '
        'When including code examples, use Markdown formatting.',
      ),
    );
 
    // Multimodal model
    _visionModel = GenerativeModel(
      model: 'gemini-2.5-flash',
      apiKey: Env.geminiApiKey,
      generationConfig: GenerationConfig(
        temperature: 0.4,
        maxOutputTokens: 4096,
      ),
    );
  }
 
  /// Start a new chat session
  void startNewChat({List<Content>? history}) {
    _chatSession = _model.startChat(history: history ?? []);
  }
 
  /// Send a message with streaming response
  Stream<String> sendMessageStream(String message) async* {
    _chatSession ??= _model.startChat();
 
    final response = _chatSession!.sendMessageStream(
      Content.text(message),
    );
 
    await for (final chunk in response) {
      final text = chunk.text;
      if (text != null && text.isNotEmpty) {
        yield text;
      }
    }
  }
 
  /// Send a message with an image (multimodal)
  Future<String> sendImageMessage({
    required String prompt,
    required Uint8List imageBytes,
    required String mimeType,
  }) async {
    final content = Content.multi([
      TextPart(prompt),
      DataPart(mimeType, imageBytes),
    ]);
 
    final response = await _visionModel.generateContent([content]);
    return response.text ?? 'Unable to generate a response.';
  }
 
  /// Get chat history
  List<Content>? get chatHistory => _chatSession?.history.toList();
 
  /// Reset the session
  void resetSession() {
    _chatSession = null;
  }
}

Three design decisions stand out here.

First, we use separate model instances for text chat and multimodal requests. Text chat needs ChatSession for automatic conversation history management, while image analysis is typically a single-shot request, allowing us to optimize parameters independently.

Second, sendMessageStream returns a Stream<String>. This integrates naturally with Flutter's reactive UI patterns — Riverpod's watch can trigger UI rebuilds as each chunk arrives, creating a real-time typing effect.

Third, we define the model's behavior through systemInstruction. Gemini 2.5 models officially support System Instructions, which are essential for maintaining consistent chat behavior.

State Management — Chat State with Riverpod

Chat app state management is more complex than it appears. The message list, sending state, partial streaming text, and error states all need careful coordination. Riverpod provides the structure we need.

// lib/models/chat_message.dart
import 'dart:typed_data';
 
enum MessageRole { user, assistant }
enum MessageStatus { complete, streaming, error }
 
class ChatMessage {
  final String id;
  final MessageRole role;
  final String text;
  final MessageStatus status;
  final DateTime timestamp;
  final Uint8List? imageBytes;
 
  const ChatMessage({
    required this.id,
    required this.role,
    required this.text,
    this.status = MessageStatus.complete,
    required this.timestamp,
    this.imageBytes,
  });
 
  ChatMessage copyWith({
    String? text,
    MessageStatus? status,
  }) {
    return ChatMessage(
      id: id,
      role: role,
      text: text ?? this.text,
      status: status ?? this.status,
      timestamp: timestamp,
      imageBytes: imageBytes,
    );
  }
}

// lib/providers/chat_provider.dart
import 'dart:typed_data';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../models/chat_message.dart';
import '../services/gemini_service.dart';
 
final geminiServiceProvider = Provider((ref) => GeminiService());
 
final chatProvider =
    StateNotifierProvider<ChatNotifier, List<ChatMessage>>((ref) {
  return ChatNotifier(ref.watch(geminiServiceProvider));
});
 
final isLoadingProvider = StateProvider<bool>((ref) => false);
 
class ChatNotifier extends StateNotifier<List<ChatMessage>> {
  final GeminiService _geminiService;
 
  ChatNotifier(this._geminiService) : super([]);
 
  /// Send a text message (with streaming)
  Future<void> sendMessage(String text, WidgetRef ref) async {
    // Add user message
    final userMsg = ChatMessage(
      id: DateTime.now().millisecondsSinceEpoch.toString(),
      role: MessageRole.user,
      text: text,
      timestamp: DateTime.now(),
    );
    state = [...state, userMsg];
 
    // Add AI response placeholder
    final assistantId =
        (DateTime.now().millisecondsSinceEpoch + 1).toString();
    final assistantMsg = ChatMessage(
      id: assistantId,
      role: MessageRole.assistant,
      text: '',
      status: MessageStatus.streaming,
      timestamp: DateTime.now(),
    );
    state = [...state, assistantMsg];
    ref.read(isLoadingProvider.notifier).state = true;
 
    try {
      final buffer = StringBuffer();
      await for (final chunk
          in _geminiService.sendMessageStream(text)) {
        buffer.write(chunk);
        // Update the streaming message
        state = [
          ...state.where((m) => m.id != assistantId),
          assistantMsg.copyWith(
            text: buffer.toString(),
          ),
        ];
      }
 
      // Mark as complete
      state = [
        ...state.where((m) => m.id != assistantId),
        assistantMsg.copyWith(
          text: buffer.toString(),
          status: MessageStatus.complete,
        ),
      ];
    } catch (e) {
      state = [
        ...state.where((m) => m.id != assistantId),
        assistantMsg.copyWith(
          text: 'An error occurred: ${e.toString()}',
          status: MessageStatus.error,
        ),
      ];
    } finally {
      ref.read(isLoadingProvider.notifier).state = false;
    }
  }
 
  /// Send a message with an image
  Future<void> sendImageMessage({
    required String prompt,
    required Uint8List imageBytes,
    required String mimeType,
    required WidgetRef ref,
  }) async {
    final userMsg = ChatMessage(
      id: DateTime.now().millisecondsSinceEpoch.toString(),
      role: MessageRole.user,
      text: prompt,
      timestamp: DateTime.now(),
      imageBytes: imageBytes,
    );
    state = [...state, userMsg];
 
    ref.read(isLoadingProvider.notifier).state = true;
 
    try {
      final response = await _geminiService.sendImageMessage(
        prompt: prompt,
        imageBytes: imageBytes,
        mimeType: mimeType,
      );
 
      state = [
        ...state,
        ChatMessage(
          id: (DateTime.now().millisecondsSinceEpoch + 1).toString(),
          role: MessageRole.assistant,
          text: response,
          timestamp: DateTime.now(),
        ),
      ];
    } catch (e) {
      state = [
        ...state,
        ChatMessage(
          id: (DateTime.now().millisecondsSinceEpoch + 1).toString(),
          role: MessageRole.assistant,
          text: 'An error occurred: ${e.toString()}',
          status: MessageStatus.error,
          timestamp: DateTime.now(),
        ),
      ];
    } finally {
      ref.read(isLoadingProvider.notifier).state = false;
    }
  }
 
  /// Clear the conversation
  void clearChat() {
    _geminiService.resetSession();
    state = [];
  }
}

The key insight in this design is the streaming message update mechanism. Each time a chunk arrives from sendMessageStream, we update state, which triggers a Riverpod rebuild — no StreamBuilder needed for real-time updates.

One caveat: reassigning state copies the entire list each time, which may impact performance for conversations with hundreds of messages. In such cases, consider extracting the streaming message into a separate StateProvider for optimization.

Building the Chat UI with Streaming Support

The UI layer renders chat messages in real time with Markdown support, ensuring code blocks and formatting display correctly.

// lib/screens/chat_screen.dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_markdown/flutter_markdown.dart';
import 'package:image_picker/image_picker.dart';
import '../models/chat_message.dart';
import '../providers/chat_provider.dart';
 
class ChatScreen extends ConsumerStatefulWidget {
  const ChatScreen({super.key});
 
  @override
  ConsumerState<ChatScreen> createState() => _ChatScreenState();
}
 
class _ChatScreenState extends ConsumerState<ChatScreen> {
  final _controller = TextEditingController();
  final _scrollController = ScrollController();
 
  @override
  void dispose() {
    _controller.dispose();
    _scrollController.dispose();
    super.dispose();
  }
 
  void _scrollToBottom() {
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if (_scrollController.hasClients) {
        _scrollController.animateTo(
          _scrollController.position.maxScrollExtent,
          duration: const Duration(milliseconds: 300),
          curve: Curves.easeOut,
        );
      }
    });
  }
 
  Future<void> _sendMessage() async {
    final text = _controller.text.trim();
    if (text.isEmpty) return;
 
    _controller.clear();
    await ref.read(chatProvider.notifier).sendMessage(text, ref);
    _scrollToBottom();
  }
 
  Future<void> _pickAndSendImage() async {
    final picker = ImagePicker();
    final image = await picker.pickImage(
      source: ImageSource.gallery,
      maxWidth: 1024,
    );
    if (image == null) return;
 
    final bytes = await image.readAsBytes();
    final mimeType = image.path.endsWith('.png')
        ? 'image/png'
        : 'image/jpeg';
 
    await ref.read(chatProvider.notifier).sendImageMessage(
          prompt: _controller.text.isNotEmpty
              ? _controller.text.trim()
              : 'Please describe this image.',
          imageBytes: bytes,
          mimeType: mimeType,
          ref: ref,
        );
    _controller.clear();
    _scrollToBottom();
  }
 
  @override
  Widget build(BuildContext context) {
    final messages = ref.watch(chatProvider);
    final isLoading = ref.watch(isLoadingProvider);
 
    // Auto-scroll during streaming
    if (messages.isNotEmpty &&
        messages.last.status == MessageStatus.streaming) {
      _scrollToBottom();
    }
 
    return Scaffold(
      appBar: AppBar(
        title: const Text('Gemini Chat'),
        actions: [
          IconButton(
            icon: const Icon(Icons.refresh),
            onPressed: () =>
                ref.read(chatProvider.notifier).clearChat(),
          ),
        ],
      ),
      body: Column(
        children: [
          Expanded(
            child: ListView.builder(
              controller: _scrollController,
              padding: const EdgeInsets.all(16),
              itemCount: messages.length,
              itemBuilder: (context, index) {
                return _MessageBubble(message: messages[index]);
              },
            ),
          ),
          _InputBar(
            controller: _controller,
            isLoading: isLoading,
            onSend: _sendMessage,
            onPickImage: _pickAndSendImage,
          ),
        ],
      ),
    );
  }
}
 
class _MessageBubble extends StatelessWidget {
  final ChatMessage message;
 
  const _MessageBubble({required this.message});
 
  @override
  Widget build(BuildContext context) {
    final isUser = message.role == MessageRole.user;
    final theme = Theme.of(context);
 
    return Align(
      alignment: isUser
          ? Alignment.centerRight
          : Alignment.centerLeft,
      child: Container(
        margin: const EdgeInsets.symmetric(vertical: 4),
        padding: const EdgeInsets.all(12),
        constraints: BoxConstraints(
          maxWidth: MediaQuery.of(context).size.width * 0.8,
        ),
        decoration: BoxDecoration(
          color: isUser
              ? theme.colorScheme.primary.withValues(alpha: 0.1)
              : theme.colorScheme.surface,
          borderRadius: BorderRadius.circular(16),
          border: Border.all(
            color: theme.colorScheme.outline.withValues(alpha: 0.2),
          ),
        ),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            if (message.imageBytes != null)
              Padding(
                padding: const EdgeInsets.only(bottom: 8),
                child: ClipRRect(
                  borderRadius: BorderRadius.circular(8),
                  child: Image.memory(
                    message.imageBytes!,
                    height: 150,
                    fit: BoxFit.cover,
                  ),
                ),
              ),
            if (isUser)
              Text(message.text)
            else
              MarkdownBody(
                data: message.text,
                selectable: true,
              ),
            if (message.status == MessageStatus.streaming)
              const Padding(
                padding: EdgeInsets.only(top: 4),
                child: SizedBox(
                  width: 16,
                  height: 16,
                  child: CircularProgressIndicator(strokeWidth: 2),
                ),
              ),
          ],
        ),
      ),
    );
  }
}
 
class _InputBar extends StatelessWidget {
  final TextEditingController controller;
  final bool isLoading;
  final VoidCallback onSend;
  final VoidCallback onPickImage;
 
  const _InputBar({
    required this.controller,
    required this.isLoading,
    required this.onSend,
    required this.onPickImage,
  });
 
  @override
  Widget build(BuildContext context) {
    return SafeArea(
      child: Padding(
        padding: const EdgeInsets.all(8),
        child: Row(
          children: [
            IconButton(
              icon: const Icon(Icons.image),
              onPressed: isLoading ? null : onPickImage,
            ),
            Expanded(
              child: TextField(
                controller: controller,
                decoration: const InputDecoration(
                  hintText: 'Type a message...',
                  border: OutlineInputBorder(
                    borderRadius:
                        BorderRadius.all(Radius.circular(24)),
                  ),
                  contentPadding: EdgeInsets.symmetric(
                    horizontal: 16,
                    vertical: 12,
                  ),
                ),
                maxLines: 4,
                minLines: 1,
                textInputAction: TextInputAction.send,
                onSubmitted: (_) => onSend(),
              ),
            ),
            const SizedBox(width: 8),
            IconButton.filled(
              icon: isLoading
                  ? const SizedBox(
                      width: 20,
                      height: 20,
                      child: CircularProgressIndicator(
                        strokeWidth: 2,
                        color: Colors.white,
                      ),
                    )
                  : const Icon(Icons.send),
              onPressed: isLoading ? null : onSend,
            ),
          ],
        ),
      ),
    );
  }
}

The most noteworthy aspect of this UI implementation is the auto-scroll behavior during streaming. By watching messages.last.status == MessageStatus.streaming, we call _scrollToBottom as new chunks arrive, giving users a natural experience of watching the AI "type" its response.

Using MarkdownBody for AI responses means that when Gemini returns Markdown-formatted content — code blocks, lists, bold text — it renders beautifully without any extra work.

Firebase Integration — Authentication and History Persistence

Production apps need user authentication and persistent conversation history. We'll use Firebase Auth for login and Cloud Firestore for data storage.

// lib/services/firestore_service.dart
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import '../models/chat_message.dart';
 
class FirestoreService {
  final FirebaseFirestore _db = FirebaseFirestore.instance;
 
  String? get _userId => FirebaseAuth.instance.currentUser?.uid;
 
  /// Get conversation list
  Stream<List<Map<String, dynamic>>> getConversations() {
    if (_userId == null) return Stream.value([]);
 
    return _db
        .collection('users')
        .doc(_userId)
        .collection('conversations')
        .orderBy('updatedAt', descending: true)
        .limit(50)
        .snapshots()
        .map((snap) => snap.docs
            .map((doc) => {'id': doc.id, ...doc.data()})
            .toList());
  }
 
  /// Save a message
  Future<void> saveMessage({
    required String conversationId,
    required ChatMessage message,
  }) async {
    if (_userId == null) return;
 
    final convRef = _db
        .collection('users')
        .doc(_userId)
        .collection('conversations')
        .doc(conversationId);
 
    // Update conversation document
    await convRef.set({
      'updatedAt': FieldValue.serverTimestamp(),
      'title': message.role == MessageRole.user
          ? message.text.substring(
              0,
              message.text.length > 50 ? 50 : message.text.length,
            )
          : null,
    }, SetOptions(merge: true));
 
    // Add the message
    await convRef.collection('messages').doc(message.id).set({
      'role': message.role.name,
      'text': message.text,
      'timestamp': FieldValue.serverTimestamp(),
    });
  }
 
  /// Load messages for a conversation
  Future<List<ChatMessage>> loadMessages(
      String conversationId) async {
    if (_userId == null) return [];
 
    final snap = await _db
        .collection('users')
        .doc(_userId)
        .collection('conversations')
        .doc(conversationId)
        .collection('messages')
        .orderBy('timestamp')
        .get();
 
    return snap.docs.map((doc) {
      final data = doc.data();
      return ChatMessage(
        id: doc.id,
        role: data['role'] == 'user'
            ? MessageRole.user
            : MessageRole.assistant,
        text: data['text'] ?? '',
        timestamp:
            (data['timestamp'] as Timestamp?)?.toDate() ??
                DateTime.now(),
      );
    }).toList();
  }
}

The Firestore data structure follows a hierarchical pattern: users/{uid}/conversations/{convId}/messages/{msgId}. This design allows Firestore security rules to restrict data under users/{uid} to only that user, ensuring privacy.

Firestore Security Rules

// firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId}/{document=**} {
      allow read, write: if request.auth != null
                         && request.auth.uid == userId;
    }
  }
}

Error Handling and Retry Strategy

In production, you'll encounter network failures, API rate limits, and timeouts. A robust error handling layer is essential.

// lib/services/gemini_service_resilient.dart
import 'dart:async';
import 'package:google_generative_ai/google_generative_ai.dart';
 
class ResilientGeminiService {
  static const _maxRetries = 3;
  static const _baseDelay = Duration(seconds: 1);
 
  /// Retry with exponential backoff
  Future<T> _withRetry<T>(Future<T> Function() operation) async {
    for (var attempt = 0; attempt < _maxRetries; attempt++) {
      try {
        return await operation();
      } on GenerativeAIException catch (e) {
        // Retry on rate limit (429)
        if (e.toString().contains('429') &&
            attempt < _maxRetries - 1) {
          final delay = _baseDelay * (1 << attempt);
          await Future.delayed(delay);
          continue;
        }
        rethrow;
      } on TimeoutException {
        if (attempt < _maxRetries - 1) {
          await Future.delayed(_baseDelay * (1 << attempt));
          continue;
        }
        throw Exception(
            'Request timed out. '
            'Please check your network connection.');
      }
    }
    throw Exception('Maximum retry attempts reached.');
  }
 
  /// Request with timeout
  Future<GenerateContentResponse> generateWithTimeout(
    GenerativeModel model,
    List<Content> content, {
    Duration timeout = const Duration(seconds: 30),
  }) {
    return _withRetry(() => model
        .generateContent(content)
        .timeout(timeout));
  }
}

Exponential backoff increases the retry interval — 1 second, then 2, then 4. When hitting Gemini API rate limits, immediate retries would only make things worse. Spacing them out gives the system time to recover.

Performance Optimization

Response Caching

Calling the API for the same question every time wastes money. Implement a local cache for frequently asked questions:

// lib/services/cache_service.dart
import 'dart:collection';
 
class ResponseCache {
  static const _maxSize = 100;
  final _cache = LinkedHashMap<String, _CacheEntry>();
 
  String? get(String prompt) {
    final entry = _cache[_normalizeKey(prompt)];
    if (entry == null) return null;
 
    // Only cache entries within 1 hour are valid
    if (DateTime.now().difference(entry.timestamp).inHours >= 1) {
      _cache.remove(_normalizeKey(prompt));
      return null;
    }
    return entry.response;
  }
 
  void put(String prompt, String response) {
    final key = _normalizeKey(prompt);
    if (_cache.length >= _maxSize) {
      _cache.remove(_cache.keys.first); // LRU eviction
    }
    _cache[key] = _CacheEntry(response, DateTime.now());
  }
 
  String _normalizeKey(String prompt) {
    return prompt.trim().toLowerCase();
  }
}
 
class _CacheEntry {
  final String response;
  final DateTime timestamp;
  _CacheEntry(this.response, this.timestamp);
}

Token Usage Monitoring

Tracking token consumption is important for managing Gemini API costs:

// Get token usage from the response
final response = await model.generateContent([content]);
final usage = response.usageMetadata;
if (usage != null) {
  print('Input tokens: ${usage.promptTokenCount}');
  print('Output tokens: ${usage.candidatesTokenCount}');
  print('Total: ${usage.totalTokenCount}');
}

Testing Strategy

Production-quality apps need proper testing:

// test/services/gemini_service_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/mockito.dart';
import 'package:mockito/annotations.dart';
 
// Define an interface for GeminiService to enable mocking
abstract class GeminiServiceInterface {
  Stream<String> sendMessageStream(String message);
  Future<String> sendImageMessage({
    required String prompt,
    required Uint8List imageBytes,
    required String mimeType,
  });
}
 
@GenerateMocks([GeminiServiceInterface])
void main() {
  group('ChatNotifier Tests', () {
    test('Sending a message adds a user message', () {
      // Test implementation
      // Use MockGeminiServiceInterface to verify
      // logic without actual API calls
    });
 
    test('Status is streaming during response generation', () {
      // Verify streaming state transitions
    });
 
    test('Status is error when request fails', () {
      // Verify error handling
    });
  });
}

Tests use mocks instead of calling the Gemini API directly. This lets you run tests in CI/CD pipelines without API keys and incurs no API costs.

What the docs don't tell you — gotchas from running this in production

The code above will get you a working chat, but it's not what kept me up at night. Over the first month of running this in my live Flutter app, the following are the issues I actually had to solve.

iOS background suspends the stream silently

If a user sends a message and then backgrounds the app, iOS suspends the HTTP/2 socket the SDK is reading from. When they come back, neither onError nor onDone fires — the chat is just stuck mid-stream forever. Android did not reproduce this for me, but I keep the recovery code in the shared path because the cost is tiny.

The fix that worked: watch WidgetsBindingObserver and, on AppLifecycleState.resumed, ask the chat notifier whether anything has been "streaming" for more than 5 seconds. If so, discard the in-flight assistant message and re-issue the last user prompt.

// lib/state/lifecycle_recovery.dart
class StreamRecovery extends ConsumerStatefulWidget {
  const StreamRecovery({super.key, required this.child});
  final Widget child;
  @override ConsumerState createState() => _StreamRecoveryState();
}
 
class _StreamRecoveryState extends ConsumerState<StreamRecovery>
    with WidgetsBindingObserver {
  @override
  void initState() { super.initState(); WidgetsBinding.instance.addObserver(this); }
  @override
  void dispose() { WidgetsBinding.instance.removeObserver(this); super.dispose(); }
 
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      ref.read(chatNotifierProvider.notifier)
         .resumeIfStuck(threshold: const Duration(seconds: 5));
    }
  }
  @override Widget build(BuildContext context) => widget.child;
}

To the user this feels like "a couple of seconds of pause, then the response comes back." That is much more acceptable than a frozen UI.

Hiding the cold start behind a small AdMob unit

First responses from Gemini Flash run about 1.6–2.2 seconds from Japan; Pro is closer to 3.5 seconds. On a fresh chat screen, that lag was the single biggest driver of bounce I saw.

What worked for me — and it's a privilege of being the indie developer who controls the whole product — was to fire a short "warm-up" prompt the moment the chat screen opens, and at the same time show one small native AdMob ad. The two seconds of ad gives Gemini time to warm up. AdMob eCPM didn't move in any direction I could detect, and felt time-to-first-token dropped to about 1.5 seconds.

Don't write Firestore on every streamed delta

My first implementation upserted to Firestore on every streamed chunk. The Firestore write bill jumped by roughly an order of magnitude — going from about $0.8 to about $7 per month at the same MAU. None of that data was being read until the chat ended.

The fix is to write to Firestore only on onDone, with the final message and usageMetadata in one document. Intermediate chunks stay in a Hive box on the device.

await chatRef.collection('messages').add({
  'role': 'assistant',
  'content': fullText,
  'tokensIn': usage?.promptTokenCount,
  'tokensOut': usage?.candidatesTokenCount,
  'createdAt': FieldValue.serverTimestamp(),
});

That single change cut Firestore writes by roughly 90% and pulled the monthly cost back to about $0.9.

`generateContentStream` is hot — don't double-subscribe

generateContentStream returns a single-subscription stream. If your test code or a second widget tries to .listen to it again, it'll throw. I lost time on this when the chat notifier's tests grabbed the stream twice.

asBroadcastStream() is the obvious escape hatch, but I prefer to keep exactly one subscription inside the ChatNotifier and have UI widgets observe state instead. This makes the cost of UI re-renders explicit and avoids the leak surface.

Web builds leak the key

If you use envied in a Flutter Web build, the obfuscated key still ends up in main.dart.js. For an indie developer who can't always rotate keys quickly, that is a real risk.

My production setup proxies Web traffic through a Cloud Functions endpoint (or Cloud Run for higher throughput) and only calls Gemini directly from iOS and Android, where I can rely on App Attest and Play Integrity to gate requests. The Web bundle never sees the key.

Monthly cost breakdown from my own app

One month of running this on a single Flutter app with about 8,000 MAU, where roughly 12% of MAU actually used the chat at an average of ~1,100 tokens per session:

Line item	Per month	Notes
Gemini API (Flash, in + out)	about $4.8	Chat used by ~12% of MAU
Firestore (chat read/write)	about $0.9	After switching to a single write on `onDone`
Cloud Functions (Web proxy only)	about $0.4	Mobile calls Gemini directly, so it isn't counted here
AdMob lift from longer sessions	about ¥3,200 (≈ $22)	Measured only on the screens carrying the chat entry point

In other words, the AdMob lift more than covered Gemini + Firestore, so the feature paid for itself in month one. That math is helped by my MAU being small; once MAU is 10× this, Gemini cost grows slightly non-linearly versus the AdMob lift, and I'd switch to a premium-tier model (ad-free + higher AI quota) somewhere around 50,000 MAU.

Responses that never arrive — safety filters and the store-review homework

The first surprise after launch was how often response.text comes back empty in real use. It never happened once while I was typing my own test prompts in development; in the first week of public traffic I logged dozens of them.

There are two distinct ways a response gets stopped. If the input is blocked, candidates comes back empty and only promptFeedback.blockReason is populated. If the generation is blocked, the candidate does exist but its finishReason is safety. Write response.text! without distinguishing the two and the second case throws a null exception that takes the whole chat screen down with it.

// lib/services/gemini_service.dart — treat a blocked response as an exception
class ChatBlocked implements Exception {
  ChatBlocked(this.stage, this.reason);
  final String stage; // 'prompt' or 'response'
  final String? reason;
}
 
String? unwrap(GenerateContentResponse res) {
  // A blocked prompt returns no candidates — only promptFeedback
  final promptBlock = res.promptFeedback?.blockReason;
  if (promptBlock != null) {
    throw ChatBlocked('prompt', promptBlock.name);
  }
  if (res.candidates.isEmpty) return null;
 
  final c = res.candidates.first;
  // A blocked generation still returns a candidate, with a different finishReason
  if (c.finishReason == FinishReason.safety ||
      c.finishReason == FinishReason.recitation) {
    throw ChatBlocked('response', c.finishReason?.name);
  }
  return c.text;
}

With streaming, finishReason only arrives on the final chunk. That means the user watches text appear for a second or two before you find out it was blocked. I decided not to erase what's already on screen and instead append a one-line note explaining that the answer stopped. Erasing it looks identical to a network failure, and the support messages went up when I tried that. In the notifier I catch ChatBlocked, attach a stoppedReason to the message in state, and let the UI render it as a small grey footnote.

The moment an AI speaks, review criteria change

There's a second piece of homework the Gemini docs won't mention. Once your app shows AI-generated text to users, both stores treat it much like an app handling user-generated content, and the review checklist grows. Here's what I actually had to handle as of 2026.

Area	iOS (App Store)	Android (Google Play)
Filtering objectionable output	Falls under Guideline 1.2. State in review notes that you use the default `safetySettings`	Falls under the generative-AI policy. Same note applies
In-app reporting	Required. Users must be able to report the AI reply itself	Required. Users must be able to flag generated output
Blocking abusive users	Needed when users interact with each other (not for a 1:1 chat with the model)	Same
Age rating	May require re-answering the questionnaire	Content rating needs resubmission

On the implementation side this was a long-press menu item on AI messages — "Report this reply" — writing the conversation ID, the message, and an optional comment to a separate Firestore collection. Half a day of work. Shipping without it is where review stops you. The age rating is worth revisiting on the same update, since adding a chat feature can change your answers on the questionnaire.

You can loosen safetySettings to change how aggressively the filter fires, but everything you loosen is something you'll have to explain at review time. If you're an indie developer trying to keep operational load down, leaving the filter at its defaults and investing instead in how a blocked response looks and how users report it is the better trade.

How I'd wire this together today

If I were starting this integration from scratch today as an indie developer, I would recommend the following combination:

Model: default to Gemini Flash; escalate to Pro only when "history ≥ 8 turns and image input is present" to avoid the cost cliff.
State management: Riverpod with one ChatNotifier owning the StreamSubscription.
Persistence: write to Firestore only on onDone; keep in-flight chunks in Hive.
Lifecycle: AppLifecycleState.resumed triggers a re-send for any stream stalled longer than 5 seconds.
Web: do not call Gemini directly from Web; go through a Cloud Functions proxy.
Monetisation: stay on AdMob + free user for the base path, and look at a premium subscription only after crossing about 50,000 MAU.
Safety: branch on promptFeedback.blockReason and finishReason separately, keep partial text on screen with a short note, and ship it alongside an in-app report action.

The point of these defaults isn't that they're the only right answer — it's that they're the lightest set of choices I've found that lets an indie developer add a Gemini chat without the operational load swallowing the rest of the product.

Next step — getting your own version into the store

If you're going to ship this, I would start with the minimal google_generative_ai + Riverpod + Hive loop and get streaming + local persistence working before touching AdMob or Firebase. The latter two are easier to isolate — and easier to attribute eCPM movement to — once the chat itself is stable.

For deeper dives in adjacent territory, Gemini API multimodal advanced techniques and Managing AI logic on Flutter × Firebase are companion pieces to this one. Thank you for reading — I hope it's useful to anyone trying to add an AI feature to their own indie app.

Thank You for Reading

Gemini Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.