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

3. Database Operations

   • Document CRUD operations
   • Collection queries
   • Real-time listeners
   • Batch operations
   • Transactions

4. Security Rules

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

Firebase Storage

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

Cloud Functions

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

Remote Config

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

Performance Monitoring

8. 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