OpenParable
Skip to content
← Back to skills

Firebase Mobile

Apps & Automation

Firebase Mobile is an Agent Skill for apps & automation published in the a5c-ai/babysitter repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Firebase backend services integration for mobile apps

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/a5c-ai/babysitter/blob/HEAD/library/specializations/mobile-development/skills/firebase-mobile/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/firebase-mobile, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Firebase Mobile Skill

Overview

This skill provides Firebase backend services integration for mobile applications. It enables configuration of Authentication, Firestore, Storage, Cloud Functions, and other Firebase services.

Allowed Tools

  • bash - Execute Firebase CLI commands
  • read - Analyze Firebase configurations
  • write - Generate security rules and configurations
  • edit - Update Firebase implementations
  • glob - Search for Firebase files
  • grep - Search for patterns

Capabilities

Firebase Authentication

  1. Auth Methods

    • Email/password authentication
    • OAuth providers (Google, Apple, Facebook)
    • Phone authentication
    • Anonymous authentication
    • Custom token authentication
  2. Auth State

    • Handle auth state changes
    • Token refresh
    • Session persistence
    • Multi-factor authentication

Cloud Firestore

  1. Database Operations

    • Document CRUD operations
    • Collection queries
    • Real-time listeners
    • Batch operations
    • Transactions
  2. Security Rules

    • Write Firestore rules
    • Test rules with emulator
    • Handle role-based access
    • Validate data structure

Firebase Storage

  1. File Operations
    • Upload files with progress
    • Download files
    • Generate download URLs
    • Handle metadata
    • Configure security rules

Cloud Functions

  1. Function Integration
    • Call HTTPS functions
    • Call callable functions
    • Handle function responses
    • Configure timeouts

Remote Config

  1. Feature Flags
    • Fetch remote config
    • Configure defaults
    • Handle fetch intervals
    • A/B testing setup

Performance Monitoring

  1. Performance Tracking
    • Automatic traces
    • Custom traces
    • Network request monitoring
    • Screen rendering metrics

Target Processes

  • firebase-backend-integration.js - Firebase integration
  • firebase-cloud-messaging.js - Push notifications
  • mobile-analytics-setup.js - Analytics

Dependencies

  • Firebase SDK
  • Firebase CLI
  • Google Cloud account

Usage Examples

Firebase Setup (iOS)

// AppDelegate.swift
import FirebaseCore
import FirebaseAuth
import FirebaseFirestore

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        FirebaseApp.configure()
        return true
    }
}

// AuthService.swift
class AuthService: ObservableObject {
    @Published var user: User?
    private var handle: AuthStateDidChangeListenerHandle?

    init() {
        handle = Auth.auth().addStateDidChangeListener { [weak self] _, user in
            self?.user = user
        }
    }

    func signIn(email: String, password: String) async throws {
        try await Auth.auth().signIn(withEmail: email, password: password)
    }

    func signUp(email: String, password: String) async throws {
        try await Auth.auth().createUser(withEmail: email, password: password)
    }

    func signOut() throws {
        try Auth.auth().signOut()
    }
}

Firestore Repository (Android)

// data/repository/PostRepository.kt
class PostRepository @Inject constructor(
    private val firestore: FirebaseFirestore
) {
    private val postsCollection = firestore.collection("posts")

    fun observePosts(): Flow<List<Post>> = callbackFlow {
        val listener = postsCollection
            .orderBy("createdAt", Query.Direction.DESCENDING)
            .addSnapshotListener { snapshot, error ->
                if (error != null) {
                    close(error)
                    return@addSnapshotListener
                }
                val posts = snapshot?.documents?.mapNotNull { it.toObject<Post>() } ?: emptyList()
                trySend(posts)
            }
        awaitClose { listener.remove() }
    }

    suspend fun createPost(post: Post): String {
        val docRef = postsCollection.add(post).await()
        return docRef.id
    }

    suspend fun updatePost(postId: String, updates: Map<String, Any>) {
        postsCollection.document(postId).update(updates).await()
    }

    suspend fun deletePost(postId: String) {
        postsCollection.document(postId).delete().await()
    }
}

Security Rules

// firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    function isAuthenticated() {
      return request.auth != null;
    }

    function isOwner(userId) {
      return isAuthenticated() && request.auth.uid == userId;
    }

    match /users/{userId} {
      allow read: if isAuthenticated();
      allow write: if isOwner(userId);
    }

    match /posts/{postId} {
      allow read: if true;
      allow create: if isAuthenticated()
        && request.resource.data.authorId == request.auth.uid;
      allow update, delete: if isOwner(resource.data.authorId);
    }
  }
}

Firebase Emulator

# Start emulators
firebase emulators:start

# Run with emulator in code
if ProcessInfo.processInfo.environment["USE_FIREBASE_EMULATOR"] == "YES" {
    Auth.auth().useEmulator(withHost: "localhost", port: 9099)
    Firestore.firestore().useEmulator(withHost: "localhost", port: 8080)
    Storage.storage().useEmulator(withHost: "localhost", port: 9199)
}

Quality Gates

  • Security rules tested with emulator
  • Authentication flows verified
  • Offline persistence tested
  • Error handling comprehensive

Related Skills

  • push-notifications - FCM integration
  • mobile-analytics - Firebase Analytics
  • mobile-security - Security patterns

Version History

  • 1.0.0 - Initial release