reis-mobile 0.3.5

package/skills/firebase-messaging/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: firebase-messaging
+description: Integrates Firebase Cloud Messaging (FCM) into Flutter apps. Use when setting up push notifications, handling foreground/background messages, managing permissions, working with FCM tokens, or configuring platform-specific notification behavior.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Cloud Messaging Skill
+
+This skill defines how to correctly use Firebase Cloud Messaging (FCM) in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up push notifications with FCM in a Flutter project.
+* Handling messages in foreground, background, and terminated states.
+* Managing notification permissions and FCM tokens.
+* Configuring platform-specific notification display behavior.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_messaging
+```
+
+**iOS:**
+- Enable **Push Notifications** and **Background Modes** in Xcode.
+- Upload your **APNs authentication key** to Firebase before using FCM.
+- Do **not** disable method swizzling — it is required for FCM token handling.
+- Ensure the bundle ID for your APNs certificate matches your app's bundle ID.
+
+**Android:**
+- Devices must run **Android 4.4+** with Google Play services installed.
+- Check for Google Play services compatibility in both `onCreate()` and `onResume()`.
+
+**Web:**
+- Create and register a service worker file named `firebase-messaging-sw.js` in your `web/` directory:
+
+```js
+importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-app-compat.js");
+importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-messaging-compat.js");
+
+firebase.initializeApp({ /* your config */ });
+
+const messaging = firebase.messaging();
+
+messaging.onBackgroundMessage((message) => {
+  console.log("onBackgroundMessage", message);
+});
+```
+
+---
+
+## 2. Message Handling
+
+**Foreground messages:**
+
+```dart
+FirebaseMessaging.onMessage.listen((RemoteMessage message) {
+  print('Foreground message data: ${message.data}');
+  if (message.notification != null) {
+    print('Notification: ${message.notification}');
+  }
+});
+```
+
+**Background messages:**
+
+```dart
+@pragma('vm:entry-point')
+Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
+  // Initialize Firebase before using other Firebase services in background
+  await Firebase.initializeApp();
+  print("Background message: ${message.messageId}");
+}
+
+void main() {
+  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
+  runApp(MyApp());
+}
+```
+
+Background handler rules:
+- Must be a **top-level function** (not anonymous, not a class method).
+- Annotate with `@pragma('vm:entry-point')` (Flutter 3.3.0+) to prevent removal during tree shaking in release mode.
+- Cannot update app state or execute UI-impacting logic — runs in a separate isolate.
+- Call `Firebase.initializeApp()` before using any other Firebase services.
+
+---
+
+## 3. Permissions
+
+```dart
+NotificationSettings settings = await FirebaseMessaging.instance.requestPermission(
+  alert: true,
+  badge: true,
+  sound: true,
+  announcement: false,
+  carPlay: false,
+  criticalAlert: false,
+  provisional: false,
+);
+
+print('Authorization status: ${settings.authorizationStatus}');
+```
+
+- **iOS / macOS / Web / Android 13+:** Must request permission before receiving FCM payloads.
+- **Android < 13:** `authorizationStatus` returns `authorized` if the user has not disabled notifications in OS settings.
+- **Android 13+:** Track permission requests in your app — there's no way to determine if the user chose to grant/deny.
+- Use **provisional permissions** on iOS (`provisional: true`) to let users choose notification types after receiving their first notification.
+
+---
+
+## 4. Token Management
+
+**Get FCM registration token (use to send messages to a specific device):**
+
+```dart
+final fcmToken = await FirebaseMessaging.instance.getToken();
+```
+
+**Web — provide VAPID key:**
+
+```dart
+final fcmToken = await FirebaseMessaging.instance.getToken(
+  vapidKey: "BKagOny0KF_2pCJQ3m....moL0ewzQ8rZu"
+);
+```
+
+**Listen for token refresh:**
+
+```dart
+FirebaseMessaging.instance.onTokenRefresh.listen((fcmToken) {
+  // Send updated token to your application server
+}).onError((err) {
+  // Handle error
+});
+```
+
+**Apple platforms — ensure APNS token is available before FCM calls:**
+
+```dart
+final apnsToken = await FirebaseMessaging.instance.getAPNSToken();
+if (apnsToken != null) {
+  // Safe to make FCM plugin API requests
+}
+```
+
+---
+
+## 5. Platform-Specific Behavior
+
+- **iOS:** If the user swipes away the app from the app switcher, it must be **manually reopened** for background messages to work again.
+- **Android:** If the user force-quits from device settings, the app must be **manually reopened**.
+- **Android foreground notifications:** Create a **"High Priority"** notification channel to display notifications while the app is in the foreground.
+- **iOS foreground notifications:** Update presentation options to display notifications while the app is in the foreground.
+
+---
+
+## 6. Auto-Initialization Control
+
+**Disable auto-init — iOS** (`Info.plist`):
+```
+FirebaseMessagingAutoInitEnabled = NO
+```
+
+**Disable auto-init — Android** (`AndroidManifest.xml`):
+```xml
+<meta-data android:name="firebase_messaging_auto_init_enabled" android:value="false" />
+<meta-data android:name="firebase_analytics_collection_enabled" android:value="false" />
+```
+
+**Re-enable at runtime:**
+```dart
+await FirebaseMessaging.instance.setAutoInitEnabled(true);
+```
+
+- The auto-init setting **persists across app restarts** once set.
+
+---
+
+## 7. iOS Image Notifications
+
+> **Important:** The iOS simulator does **not** display images in push notifications. Test on a physical device.
+
+- Add a **Notification Service Extension** in Xcode.
+- Use `Messaging.serviceExtension().populateNotificationContent()` in the extension for image handling.
+- Swift: add the `FirebaseMessaging` Swift package to your extension target.
+- Objective-C: add the `Firebase/Messaging` pod to your Podfile.
+
+---
+
+## References
+
+- [Firebase Cloud Messaging Flutter documentation](https://firebase.google.com/docs/cloud-messaging/flutter/client)
+- [Receive messages in Flutter](https://firebase.google.com/docs/cloud-messaging/flutter/receive)

package/skills/firebase-remote-config/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: firebase-remote-config
+description: Integrates Firebase Remote Config into Flutter apps. Use when setting up Remote Config, managing parameter defaults, fetching and activating values, implementing real-time updates, or handling throttling and testing.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Remote Config Skill
+
+This skill defines how to correctly use Firebase Remote Config in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up Remote Config to configure your app without deploying updates.
+* Managing parameter defaults and remote values.
+* Fetching, activating, and listening to config updates.
+* Applying throttling, A/B testing, or conditional targeting.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_remote_config
+flutter pub add firebase_analytics  # required for conditional targeting of app instances
+```
+
+```dart
+import 'package:firebase_remote_config/firebase_remote_config.dart';
+
+final remoteConfig = FirebaseRemoteConfig.instance;
+```
+
+- Enable **Google Analytics** in your Firebase project for user property and audience targeting.
+- Ensure the **Remote Config REST API** is not disabled — the SDK depends on it.
+- For **macOS**, enable Keychain Sharing in Xcode.
+
+**Configure settings:**
+
+```dart
+await remoteConfig.setConfigSettings(RemoteConfigSettings(
+  fetchTimeout: const Duration(minutes: 1),
+  minimumFetchInterval: const Duration(hours: 1),
+));
+```
+
+---
+
+## 2. Parameter Management
+
+**Set in-app defaults** (ensures your app behaves as intended before connecting to the backend):
+
+```dart
+await remoteConfig.setDefaults(const {
+  "example_param_1": 42,
+  "example_param_2": 3.14159,
+  "example_param_3": true,
+  "example_param_4": "Hello, world!",
+});
+```
+
+- **Never** store confidential data in Remote Config keys or values — they can be accessed by end users.
+- Use type-specific getters: `getBool()`, `getDouble()`, `getInt()`, `getString()`.
+- Define parameters with the **same names** in the Firebase console as those in your app.
+- Group related parameters with common prefixes (e.g., `login_timeout`, `login_attempts_max`).
+
+---
+
+## 3. Fetching and Activating
+
+```dart
+await remoteConfig.fetchAndActivate();
+```
+
+- Use `fetchAndActivate()` to fetch and apply values in a single call.
+- Alternatively, call `fetch()` then `activate()` separately to control when values take effect.
+- Activate fetched values at appropriate times (e.g., app start) for a smooth user experience.
+- Check `remoteConfig.lastFetchStatus` to determine if the fetch was successful, failed, or throttled.
+- Handle fetch failures gracefully by falling back to default values.
+
+---
+
+## 4. Real-time Updates
+
+```dart
+remoteConfig.onConfigUpdated.listen((event) async {
+  await remoteConfig.activate();
+  // Use the new config values here
+});
+```
+
+- Real-time Remote Config is **not available for Web**.
+- Update your UI state when new configuration values are activated.
+- Ensure real-time updates don't disrupt the user experience.
+
+---
+
+## 5. Throttling and Performance
+
+- Fetch calls are **throttled** if an app fetches too frequently.
+- Default minimum fetch interval in production: **12 hours**.
+- For development, use a shorter interval — but only in debug builds:
+
+```dart
+await remoteConfig.setConfigSettings(RemoteConfigSettings(
+  fetchTimeout: const Duration(minutes: 1),
+  minimumFetchInterval: const Duration(minutes: 5),
+));
+```
+
+- Be mindful of **service-side quota limits** with a large user base.
+
+---
+
+## 6. Testing and Debugging
+
+- Use **conditional values** in the Firebase console to test configurations without new app deployments.
+- Implement **A/B testing** with different parameter values for different user segments.
+- Test your app with both default and remote values.
+- Verify graceful handling of configuration changes at runtime.
+- Test **offline behavior** to ensure proper fallback to defaults.
+
+---
+
+## References
+
+- [Firebase Remote Config Flutter documentation](https://firebase.google.com/docs/remote-config/get-started?platform=flutter)

package/skills/firebase-storage/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: firebase-storage
+description: Integrates Firebase Cloud Storage into Flutter apps. Use when setting up Storage, uploading or downloading files, managing metadata, handling errors, or applying security rules.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Cloud Storage Skill
+
+This skill defines how to correctly use Firebase Cloud Storage in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up Cloud Storage in a Flutter project.
+* Uploading or downloading files.
+* Managing file metadata.
+* Handling Storage errors and monitoring upload progress.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_storage
+```
+
+```dart
+import 'package:firebase_storage/firebase_storage.dart';
+
+final storage = FirebaseStorage.instance;
+// Or specify a bucket explicitly:
+// final storage = FirebaseStorage.instanceFor(bucket: "gs://BUCKET_NAME");
+```
+
+- Firebase Storage requires the **Blaze (pay-as-you-go) plan**.
+- Run `flutterfire configure` to update your Firebase config with the default Storage bucket name.
+
+> **Security note:** By default, a Cloud Storage bucket requires Firebase Authentication for any action. Configuring public access may also make App Engine files publicly accessible — restrict access again when you set up Authentication.
+
+---
+
+## 2. File Operations
+
+**Create a reference:**
+
+```dart
+final storageRef = FirebaseStorage.instance.ref();
+final fileRef = storageRef.child("uploads/file.jpg");
+```
+
+**Upload:**
+
+```dart
+final uploadTask = fileRef.putFile(file);
+final snapshot = await uploadTask;
+final downloadUrl = await snapshot.ref.getDownloadURL();
+```
+
+**Download (in-memory):**
+
+```dart
+final data = await fileRef.getData();
+```
+
+**Download URL:**
+
+```dart
+final downloadUrl = await fileRef.getDownloadURL();
+```
+
+**Delete:**
+
+```dart
+await fileRef.delete();
+```
+
+---
+
+## 3. Metadata Management
+
+**Get metadata:**
+
+```dart
+final metadata = await fileRef.getMetadata();
+print('Content type: ${metadata.contentType}');
+print('Size: ${metadata.size}');
+```
+
+**Update metadata:**
+
+```dart
+final newMetadata = SettableMetadata(
+  contentType: "image/jpeg",
+  customMetadata: {'uploaded_by': 'user123'},
+);
+await fileRef.updateMetadata(newMetadata);
+```
+
+Use **custom metadata** to store additional key/value pairs with your files.
+
+---
+
+## 4. Error Handling
+
+Use `try-catch` with `FirebaseException`. Key error codes:
+
+| Code | Meaning |
+|---|---|
+| `storage/object-not-found` | File doesn't exist at the reference |
+| `storage/bucket-not-found` | No bucket configured for Cloud Storage |
+| `storage/project-not-found` | No project configured for Cloud Storage |
+| `storage/quota-exceeded` | Storage quota exceeded |
+| `storage/unauthenticated` | User needs to authenticate |
+| `storage/unauthorized` | User lacks permission |
+| `storage/retry-limit-exceeded` | Operation timeout exceeded |
+
+- For `quota-exceeded` on the Spark plan, upgrade to Blaze.
+- Implement retry logic for network-related errors and timeouts.
+
+---
+
+## 5. Performance and Best Practices
+
+**Monitor upload progress:**
+
+```dart
+final uploadTask = fileRef.putFile(file);
+uploadTask.snapshotEvents.listen((TaskSnapshot snapshot) {
+  print('Progress: ${(snapshot.bytesTransferred / snapshot.totalBytes) * 100}%');
+});
+```
+
+- **Cancel** uploads with `uploadTask.cancel()`.
+- **Pause / resume** with `uploadTask.pause()` and `uploadTask.resume()`.
+- Optimize file sizes before upload to reduce costs and improve performance.
+- Use Cloud Storage with Firestore for comprehensive data management.
+- Use the **Firebase Local Emulator Suite** for local development and testing.
+
+---
+
+## 6. Security
+
+- Use **Firebase Security Rules** to control access to files.
+- Combine Storage rules with **Firebase Authentication** for user-based access control.
+- Test security rules thoroughly before deploying to production.
+
+---
+
+## References
+
+- [Firebase Cloud Storage Flutter documentation](https://firebase.google.com/docs/storage/flutter/start)
+- [Upload files](https://firebase.google.com/docs/storage/flutter/upload-files)
+- [Download files](https://firebase.google.com/docs/storage/flutter/download-files)
+- [Handle errors](https://firebase.google.com/docs/storage/flutter/handle-errors)

package/skills/flutter-add-integration-test/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: flutter-add-integration-test
+description: Configures Flutter Driver for app interaction and converts MCP actions into permanent integration tests. Use when adding integration testing to a project, exploring UI components via MCP, or automating user flows with the integration_test package.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Tue, 21 Apr 2026 18:29:20 GMT
+intents: [test]
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Implementing Flutter Integration Tests
+
+## Contents
+- [Project Setup and Dependencies](#project-setup-and-dependencies)
+- [Interactive Exploration via MCP](#interactive-exploration-via-mcp)
+- [Test Authoring Guidelines](#test-authoring-guidelines)
+- [Execution and Profiling](#execution-and-profiling)
+- [Workflow: End-to-End Integration Testing](#workflow-end-to-end-integration-testing)
+- [Examples](#examples)
+
+## Project Setup and Dependencies
+
+Configure the project to support integration testing and Flutter Driver extensions.
+
+1. Add required development dependencies to `pubspec.yaml`:
+   ```bash
+   flutter pub add 'dev:integration_test:{"sdk":"flutter"}'
+   flutter pub add 'dev:flutter_test:{"sdk":"flutter"}'
+   ```
+2. Enable the Flutter Driver extension in your application entry point (typically `lib/main.dart` or a dedicated `lib/main_test.dart`):
+   - Import `package:flutter_driver/driver_extension.dart`.
+   - Call `enableFlutterDriverExtension();` before `runApp()`.
+3. Add `Key` parameters (e.g., `ValueKey('login_button')`) to critical widgets in the application code to ensure reliable targeting during tests.
+
+## Interactive Exploration via MCP
+
+Use the Dart/Flutter MCP server tools to interactively explore and manipulate the application state before writing static tests.
+
+- **Launch**: Execute `launch_app` with `target: "lib/main_test.dart"` to start the application and acquire the DTD URI.
+- **Inspect**: Execute `get_widget_tree` to discover available `Key`s, `Text` nodes, and widget `Type`s.
+- **Interact**: Execute `tap`, `enter_text`, and `scroll` to simulate user flows.
+- **Wait**: Always execute `waitFor` or verify state with `get_health` when navigating or triggering animations.
+- **Troubleshoot Unmounted Widgets**: If a widget is not found in the tree, it may be lazily loaded in a `SliverList` or `ListView`. Execute `scroll` or `scrollIntoView` to force the widget to mount before interacting with it.
+
+## Test Authoring Guidelines
+
+Structure integration tests using the `flutter_test` API paradigm. 
+
+- Create a dedicated `integration_test/` directory at the project root.
+- Name all test files using the `<name>_test.dart` convention.
+- Initialize the binding by calling `IntegrationTestWidgetsFlutterBinding.ensureInitialized();` at the start of `main()`.
+- Load the application UI using `await tester.pumpWidget(MyApp());`.
+- Trigger frames and wait for animations to complete using `await tester.pumpAndSettle();` after interactions like `tester.tap()`.
+- Assert widget visibility using `expect(find.byKey(ValueKey('foo')), findsOneWidget);` or `findsNothing`.
+- Scroll to specific off-screen widgets using `await tester.scrollUntilVisible(itemFinder, 500.0, scrollable: listFinder);`.
+
+**Conditional Logic for Legacy `flutter_driver`:**
+- If maintaining or migrating legacy `flutter_driver` tests, use `driver.waitFor()`, `driver.waitForAbsent()`, `driver.tap()`, and `driver.scroll()` instead of the `WidgetTester` APIs.
+
+## Execution and Profiling
+
+Execute tests using the `flutter drive` command. Require a host driver script located in `test_driver/integration_test.dart` that calls `integrationDriver()`.
+
+**Conditional Execution Targets:**
+- **If testing on Chrome:** Launch `chromedriver --port=4444` in a separate terminal, then run:
+  `flutter drive --driver=test_driver/integration_test.dart --target=integration_test/app_test.dart -d chrome`
+- **If testing headless web:** Run with `-d web-server`.
+- **If testing on Android (Local):** Run `flutter drive --driver=test_driver/integration_test.dart --target=integration_test/app_test.dart`.
+- **If testing on Firebase Test Lab (Android):** 
+  1. Build debug APK: `flutter build apk --debug`
+  2. Build test APK: `./gradlew app:assembleAndroidTest`
+  3. Upload both APKs to the Firebase Test Lab console.
+
+## Workflow: End-to-End Integration Testing
+
+Copy and follow this checklist to implement and verify integration tests.
+
+- [ ] **Task Progress: Setup**
+  - [ ] Add `integration_test` and `flutter_test` to `pubspec.yaml`.
+  - [ ] Inject `enableFlutterDriverExtension()` into the app entry point.
+  - [ ] Assign `ValueKey`s to target widgets.
+- [ ] **Task Progress: Exploration**
+  - [ ] Run `launch_app` via MCP.
+  - [ ] Map the widget tree using `get_widget_tree`.
+  - [ ] Validate interaction paths using MCP tools (`tap`, `enter_text`).
+- [ ] **Task Progress: Authoring**
+  - [ ] Create `integration_test/app_test.dart`.
+  - [ ] Write test cases using `WidgetTester` APIs.
+  - [ ] Create `test_driver/integration_test.dart` with `integrationDriver()`.
+- [ ] **Task Progress: Execution & Feedback Loop**
+  - [ ] Run `flutter drive --driver=test_driver/integration_test.dart --target=integration_test/app_test.dart`.
+  - [ ] **Feedback Loop**: Review test output -> If `PumpAndSettleTimedOutException` occurs, check for infinite animations -> If widget not found, add `scrollUntilVisible` -> Re-run test until passing.
+
+## Examples
+
+### Standard Integration Test (`integration_test/app_test.dart`)
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:my_app/main.dart';
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+
+  group('End-to-end test', () {
+    testWidgets('tap on the floating action button, verify counter', (tester) async {
+      // Load app widget.
+      await tester.pumpWidget(const MyApp());
+
+      // Verify the counter starts at 0.
+      expect(find.text('0'), findsOneWidget);
+
+      // Find the floating action button to tap on.
+      final fab = find.byKey(const ValueKey('increment'));
+
+      // Emulate a tap on the floating action button.
+      await tester.tap(fab);
+
+      // Trigger a frame and wait for animations.
+      await tester.pumpAndSettle();
+
+      // Verify the counter increments by 1.
+      expect(find.text('1'), findsOneWidget);
+    });
+  });
+}
+```
+
+### Host Driver Script (`test_driver/integration_test.dart`)
+
+```dart
+import 'package:integration_test/integration_test_driver.dart';
+
+Future<void> main() => integrationDriver();
+```
+
+### Performance Profiling Driver Script (`test_driver/perf_driver.dart`)
+
+Use this driver script if you wrap your test actions in `binding.traceAction()` to capture performance metrics.
+
+```dart
+import 'package:flutter_driver/flutter_driver.dart' as driver;
+import 'package:integration_test/integration_test_driver.dart';
+
+Future<void> main() {
+  return integrationDriver(
+    responseDataCallback: (data) async {
+      if (data != null) {
+        final timeline = driver.Timeline.fromJson(
+          data['scrolling_timeline'] as Map<String, dynamic>,
+        );
+
+        final summary = driver.TimelineSummary.summarize(timeline);
+
+        await summary.writeTimelineToFile(
+          'scrolling_timeline',
+          pretty: true,
+          includeSummary: true,
+        );
+      }
+    },
+  );
+}
+```