reis-mobile 0.3.5

package/skills/firebase-crashlytics/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: firebase-crashlytics
+description: Integrates Firebase Crashlytics into Flutter apps. Use when setting up crash reporting, handling fatal and non-fatal errors, customizing crash reports with keys/logs/user identifiers, or configuring opt-in reporting.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Crashlytics Skill
+
+This skill defines how to correctly use Firebase Crashlytics in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up Crashlytics in a Flutter project.
+* Configuring fatal and non-fatal error handling.
+* Customizing crash reports with keys, logs, and user identifiers.
+* Testing crash reporting or configuring opt-in data collection.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_crashlytics
+flutter pub add firebase_analytics  # enables breadcrumb logs for better crash context
+```
+
+Run `flutterfire configure` to update your Firebase configuration and add the required Crashlytics Gradle plugin for Android.
+
+```dart
+import 'package:firebase_crashlytics/firebase_crashlytics.dart';
+```
+
+**Obfuscated code:**
+- For apps built with `--split-debug-info` and/or `--obfuscate`, upload symbol files for readable stack traces.
+- **iOS:** Flutter 3.12.0+ and Crashlytics Flutter plugin 3.3.4+ handle symbol upload automatically.
+- **Android:** Use Firebase CLI (v11.9.0+) to upload Flutter debug symbols before reporting crashes:
+
+```bash
+firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/symbols
+```
+
+---
+
+## 2. Error Handling
+
+**Fatal Flutter errors:**
+
+```dart
+void main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await Firebase.initializeApp();
+
+  // Pass all uncaught fatal errors from the framework to Crashlytics
+  FlutterError.onError = FirebaseCrashlytics.instance.recordFlutterFatalError;
+
+  runApp(MyApp());
+}
+```
+
+**Non-fatal Flutter errors:** use `recordFlutterError` instead of `recordFlutterFatalError`.
+
+**Async errors not caught by the Flutter framework:**
+
+```dart
+PlatformDispatcher.instance.onError = (error, stack) {
+  FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
+  return true;
+};
+```
+
+**Isolate errors:**
+
+```dart
+Isolate.current.addErrorListener(RawReceivePort((pair) async {
+  final List<dynamic> errorAndStacktrace = pair;
+  await FirebaseCrashlytics.instance.recordError(
+    errorAndStacktrace.first,
+    errorAndStacktrace.last,
+    fatal: true,
+  );
+}).sendPort);
+```
+
+**Caught exceptions (non-fatal):**
+
+```dart
+await FirebaseCrashlytics.instance.recordError(
+  error,
+  stackTrace,
+  reason: 'a non-fatal error',
+  information: ['further diagnostic information about the error', 'version 2.0'],
+);
+```
+
+- Crashlytics only stores the **most recent 8 non-fatal exceptions** per session — older ones are discarded.
+
+---
+
+## 3. Crash Report Customization
+
+**Custom keys** (max 64 key/value pairs, up to 1 kB each):
+
+```dart
+FirebaseCrashlytics.instance.setCustomKey('str_key', 'hello');
+FirebaseCrashlytics.instance.setCustomKey('bool_key', true);
+FirebaseCrashlytics.instance.setCustomKey('int_key', 1);
+```
+
+**Custom log messages** (limit: 64 kB per session):
+
+```dart
+FirebaseCrashlytics.instance.log("User tapped on payment button");
+```
+
+**User identifier:**
+
+```dart
+FirebaseCrashlytics.instance.setUserIdentifier("user-123");
+// Clear by setting to blank string
+FirebaseCrashlytics.instance.setUserIdentifier("");
+```
+
+- Avoid putting unique values (user IDs, timestamps) directly in exception messages — use custom keys instead.
+
+---
+
+## 4. Performance and Optimization
+
+- Crashlytics processes exceptions on a **dedicated background thread** to minimize performance impact.
+- **Fatal** reports are sent in real-time without requiring an app restart.
+- **Non-fatal** reports are written to disk and sent with the next fatal report or on app restart.
+- Crashlytics rate-limits reports from a device to reduce network traffic if necessary.
+- Use breadcrumb logs (requires Firebase Analytics) to understand user actions leading up to a crash.
+
+**Disable Crashlytics in debug builds:**
+
+```dart
+if (kReleaseMode) {
+  await FirebaseCrashlytics.instance.setCrashlyticsCollectionEnabled(true);
+} else {
+  await FirebaseCrashlytics.instance.setCrashlyticsCollectionEnabled(false);
+}
+```
+
+---
+
+## 5. Testing and Debugging
+
+Force a test crash to verify your setup:
+
+```dart
+FirebaseCrashlytics.instance.crash();
+```
+
+- Test both fatal and non-fatal error reporting.
+- Verify stack traces are properly symbolicated when using code obfuscation.
+- Check that custom keys, logs, and user identifiers are associated with crash reports.
+- Monitor the Crashlytics dashboard regularly and set up alerts for new issues or regressions.
+
+---
+
+## 6. Opt-in Reporting
+
+By default, Crashlytics automatically collects crash reports for all users.
+
+To give users control over data collection:
+- Disable automatic reporting and enable it only via `setCrashlyticsCollectionEnabled(true)` when users opt in.
+- The override value **persists** across all subsequent app launches.
+- To opt a user out, pass `false` — this applies from the next app launch.
+- When disabled, crash info is **stored locally**; if later enabled, locally stored crashes are sent to Crashlytics.
+
+---
+
+## References
+
+- [Firebase Crashlytics Flutter documentation](https://firebase.google.com/docs/crashlytics/get-started?platform=flutter)
+- [Customize crash reports](https://firebase.google.com/docs/crashlytics/customize-crash-reports?platform=flutter)

package/skills/firebase-data-connect/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: firebase-data-connect
+description: Integrates Firebase Data Connect into Flutter apps. Use when setting up Data Connect, designing queries, handling errors, or applying security and performance best practices.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Data Connect Skill
+
+This skill defines how to correctly use Firebase Data Connect in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up and configuring Firebase Data Connect in a Flutter project.
+* Designing schemas, queries, and mutations for Data Connect.
+* Handling network failures, data inconsistencies, and offline scenarios.
+* Applying security and performance best practices.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_data_connect
+```
+
+```dart
+import 'package:firebase_data_connect/firebase_data_connect.dart';
+```
+
+- Ensure your Firebase project is properly configured for Data Connect services.
+- Initialize Firebase before using any Data Connect features.
+
+**Platform support:**
+
+| Platform | Support |
+|---|---|
+| iOS | Full |
+| Android | Full |
+| Web | Full |
+| Other platforms | Not supported |
+
+---
+
+## 2. Best Practices
+
+- Follow Firebase Data Connect documentation for proper **schema design** and **query optimization**.
+- Design efficient queries to minimize data transfer and processing time.
+- Implement **pagination** for large datasets to improve app responsiveness.
+- Use real-time listeners judiciously to avoid unnecessary network usage.
+- Consider **offline capabilities** for critical app functionality.
+- Use **caching strategies** to improve performance and reduce costs.
+
+---
+
+## 3. Error Handling
+
+- Handle **connection errors** gracefully with appropriate retry mechanisms.
+- Implement proper error messages for data validation failures.
+- Handle **offline scenarios** and implement appropriate fallback behavior.
+- Monitor error rates and investigate recurring issues.
+
+---
+
+## 4. Security
+
+- Configure **Firebase Security Rules** for Data Connect to control data access.
+- Use **Firebase Authentication** integration for user-based access control.
+- Implement proper **data validation** on both client and server sides.
+- Follow data privacy best practices when handling user information.
+
+---
+
+## References
+
+- [Firebase Data Connect documentation](https://firebase.google.com/docs/data-connect)

package/skills/firebase-database/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: firebase-database
+description: Integrates Firebase Realtime Database into Flutter apps. Use when setting up Realtime Database, structuring JSON data, querying, performing read/write operations, implementing offline capabilities, or applying security rules.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Realtime Database Skill
+
+This skill defines how to correctly use Firebase Realtime Database in Flutter applications.
+
+## When to Use
+
+Use this skill when working with Firebase Realtime Database for **simple data models**, **low-latency sync**, or **presence functionality**. For rich data models requiring complex queries and high scalability, use Cloud Firestore instead.
+
+---
+
+## 1. Database Selection
+
+Choose **Realtime Database** when your app needs:
+- Simple data models with simple lookups.
+- Extremely low-latency synchronization (typical response times under 10ms).
+- Deep queries that return an entire subtree by default.
+- Access to data at any granularity, down to individual leaf-node values.
+- Frequent state-syncing with built-in presence functionality.
+
+Choose **Cloud Firestore** instead for rich data models requiring queryability, scalability, and high availability.
+
+---
+
+## 2. Setup and Configuration
+
+```
+flutter pub add firebase_database
+```
+
+```dart
+import 'package:firebase_database/firebase_database.dart';
+
+// After Firebase.initializeApp():
+final DatabaseReference ref = FirebaseDatabase.instance.ref();
+```
+
+- Select the database location closest to your users.
+- Enable persistence for offline capabilities:
+
+```dart
+FirebaseDatabase.instance.setPersistenceEnabled(true);
+FirebaseDatabase.instance.setPersistenceCacheSizeBytes(10000000); // 10MB
+```
+
+---
+
+## 3. Data Structure
+
+- Structure data as a **flattened JSON tree** — avoid deep nesting.
+- Maximum nesting depth is **32 levels**.
+- Design your data structure to support your most common queries.
+- Use **push IDs** for unique identifiers in list-type data:
+
+```dart
+final newPostKey = FirebaseDatabase.instance.ref().child('posts').push().key;
+```
+
+- **Denormalize** data when necessary — Realtime Database doesn't support joins.
+- Custom keys must be UTF-8 encoded, max 768 bytes, and cannot contain `.` `$` `#` `[` `]` `/` or ASCII control characters 0–31 or 127.
+
+---
+
+## 4. Indexing and Querying
+
+- Queries can sort **or** filter on a property, but not both in the same query.
+- Use `.indexOn` in security rules to index frequently queried fields:
+
+```json
+{
+  "rules": {
+    "dinosaurs": {
+      ".indexOn": ["height", "length"]
+    }
+  }
+}
+```
+
+- Queries are **deep** by default and return the entire subtree.
+- Sort with `orderByChild()`, `orderByKey()`, or `orderByValue()`:
+
+```dart
+final query = FirebaseDatabase.instance.ref("dinosaurs").orderByChild("height");
+```
+
+- Limit results with `limitToFirst()` or `limitToLast()`:
+
+```dart
+final query = ref.orderByChild("height").limitToFirst(10);
+```
+
+---
+
+## 5. Read and Write Operations
+
+**Read once:**
+
+```dart
+final snapshot = await FirebaseDatabase.instance.ref('users/123').get();
+if (snapshot.exists) {
+  print(snapshot.value);
+}
+```
+
+**Real-time listener:**
+
+```dart
+FirebaseDatabase.instance.ref('users/123').onValue.listen((event) {
+  final data = event.snapshot.value;
+  print(data);
+});
+```
+
+A `DatabaseEvent` fires every time data changes at the reference, including changes to children.
+
+**Write (replace):**
+
+```dart
+await ref.set({
+  "name": "John",
+  "age": 18,
+});
+```
+
+**Update (partial):**
+
+```dart
+await ref.update({"age": 19});
+```
+
+**Atomic transaction:**
+
+```dart
+FirebaseDatabase.instance.ref('posts/123/likes').runTransaction((currentValue) {
+  return (currentValue as int? ?? 0) + 1;
+});
+```
+
+**Multi-path atomic update:**
+
+```dart
+final updates = <String, dynamic>{
+  'posts/$postId': postData,
+  'user-posts/$uid/$postId': postData,
+};
+FirebaseDatabase.instance.ref().update(updates);
+```
+
+- Keep individual write operations under **256KB**.
+- Use listeners for real-time updates rather than polling.
+
+---
+
+## 6. Designing for Scale
+
+- Realtime Database scales to ~200,000 concurrent connections and 1,000 writes/second per database. For higher scale, **shard** data across multiple database instances.
+- Avoid storing large blobs — use **Firebase Storage** for files.
+- Use **server timestamps** for consistent time tracking:
+
+```dart
+FirebaseDatabase.instance.ref('posts/123/timestamp').set(ServerValue.timestamp);
+```
+
+- Implement **fan-out patterns** for data accessed from multiple paths.
+- Avoid deep nesting — it leads to performance issues when retrieving data.
+
+---
+
+## 7. Offline Capabilities
+
+```dart
+FirebaseDatabase.instance.setPersistenceEnabled(true);
+
+// Keep critical paths synced when offline
+FirebaseDatabase.instance.ref('important-data').keepSynced(true);
+
+// Detect connection state
+FirebaseDatabase.instance.ref('.info/connected').onValue.listen((event) {
+  final connected = event.snapshot.value as bool? ?? false;
+  print('Connected: $connected');
+});
+```
+
+- Use value events (`onValue`) to read data and get notified of updates — optimized for online/offline transitions.
+- Use `get()` only when you need data once; it probes local cache if the server is unavailable.
+
+---
+
+## 8. Security
+
+```json
+{
+  "rules": {
+    "users": {
+      "$uid": {
+        ".read": "$uid === auth.uid",
+        ".write": "$uid === auth.uid"
+      }
+    }
+  }
+}
+```
+
+- Use `.read`, `.write`, `.validate`, and `.indexOn` to control access and validate data.
+- Read and write rules **cascade** in Realtime Database.
+- Use the `auth` variable to authenticate users in security rules.
+- Test rules thoroughly using the Firebase console's rules simulator.
+- Use the **Firebase Emulator Suite** for local testing.
+
+---
+
+## References
+
+- [Firebase Realtime Database Flutter documentation](https://firebase.google.com/docs/database/flutter/start)
+- [Structure data](https://firebase.google.com/docs/database/flutter/structure-data)
+- [Read and write data](https://firebase.google.com/docs/database/flutter/read-and-write)

package/skills/firebase-in-app-messaging/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: firebase-in-app-messaging
+description: Integrates Firebase In-App Messaging into Flutter apps. Use when setting up in-app messaging, triggering or suppressing messages, managing user privacy and opt-in data collection, or testing campaigns.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase In-App Messaging Skill
+
+This skill defines how to correctly use Firebase In-App Messaging in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up Firebase In-App Messaging in a Flutter project.
+* Triggering or suppressing in-app messages programmatically.
+* Implementing opt-in data collection for user privacy.
+* Testing campaigns with specific devices.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_in_app_messaging
+```
+
+```dart
+import 'package:firebase_in_app_messaging/firebase_in_app_messaging.dart';
+```
+
+- Initialize Firebase before using any In-App Messaging features.
+- In-App Messaging **retrieves messages from the server once per day** by default to conserve power.
+
+**Finding your Installation ID for testing:**
+- **Android:** Look for `I/FIAM.Headless: Starting InAppMessaging runtime with Installation ID YOUR_INSTALLATION_ID` in logcat (filter by "FIAM.Headless").
+- **iOS:** Enable debug mode by adding `-FIRDebugEnabled` as a runtime argument in Xcode's scheme settings; find `[Firebase/InAppMessaging][I-IAM180017]` in Xcode console logs.
+
+---
+
+## 2. Message Triggering and Display
+
+Use Google Analytics events to trigger in-app messages without additional code. For programmatic triggering:
+
+```dart
+FirebaseInAppMessaging.instance.triggerEvent("eventName");
+```
+
+**Suppress messages during critical flows** (e.g., payment processing):
+
+```dart
+FirebaseInAppMessaging.instance.setMessagesSuppressed(true);
+// Re-enable when appropriate:
+FirebaseInAppMessaging.instance.setMessagesSuppressed(false);
+```
+
+- Suppression is **automatically turned off** on app restart.
+- Suppressed messages are ignored — their trigger conditions must be met again after suppression is lifted.
+- Platform-specific message interaction callbacks (iOS/Android) are not directly accessible from Flutter; use native APIs for those.
+
+---
+
+## 3. User Privacy and Opt-In Data Collection
+
+By default, In-App Messaging automatically delivers messages to all targeted users.
+
+**Disable automatic collection — iOS** (`Info.plist`):
+```
+FirebaseInAppMessagingAutomaticDataCollectionEnabled = NO
+```
+
+**Disable automatic collection — Android** (`AndroidManifest.xml`):
+```xml
+<meta-data
+    android:name="firebase_inapp_messaging_auto_data_collection_enabled"
+    android:value="false" />
+```
+
+**Enable for users who opt in:**
+```dart
+FirebaseInAppMessaging.instance.setAutomaticDataCollectionEnabled(true);
+```
+
+- Manually set preferences **persist through app restarts**, overriding configuration file values.
+
+---
+
+## 4. Testing and Debugging
+
+- Use the Firebase console's **"Test on your Device"** feature, entering the app's Firebase Installation ID to send test messages on demand.
+- Always test on **actual devices** for proper rendering and behavior.
+
+---
+
+## 5. Campaign Management
+
+- Create campaigns in the Firebase console under **Messaging**.
+- Message types: **modal**, **banner**, **card**, or **image-only**.
+- Use **custom metadata** (key-value pairs) to pass additional info accessible when users interact with messages.
+- Target based on user segments, app version, language, and Analytics-based conditions.
+- Use **A/B testing** to optimize message content and delivery.
+- Monitor campaign performance through Firebase console analytics.
+
+---
+
+## References
+
+- [Firebase In-App Messaging Flutter documentation](https://firebase.google.com/docs/in-app-messaging/get-started?platform=flutter)