@rosetears/aili-pi 0.1.0

package/skills/flutter-dev/references/performance.md

@@ -0,0 +1,305 @@
+# Performance Optimization
+
+Flutter performance guide covering profiling, const optimization, and DevTools analysis.
+
+## Profiling Commands
+
+```bash
+# Run in profile mode (required for accurate measurements)
+flutter run --profile
+
+# Analyze code issues
+flutter analyze
+
+# Launch DevTools
+flutter pub global activate devtools
+flutter pub global run devtools
+
+# Build release for testing
+flutter build apk --release
+flutter build ios --release
+```
+
+## Const Widget Optimization
+
+The most important optimization for preventing unnecessary rebuilds:
+
+```dart
+// BAD - Creates new objects every build
+Widget build(BuildContext context) {
+  return Container(
+    padding: EdgeInsets.all(16),  // New object each time
+    child: Text('Hello'),          // New widget each time
+  );
+}
+
+// GOOD - Const prevents rebuilds
+Widget build(BuildContext context) {
+  return Container(
+    padding: const EdgeInsets.all(16),
+    child: const Text('Hello'),
+  );
+}
+```
+
+### Extracting Const Widgets
+
+```dart
+// BAD - Inline static content
+class MyScreen extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      children: [
+        Icon(Icons.star, size: 48),
+        Text('Welcome'),
+        Text('Description text here'),
+      ],
+    );
+  }
+}
+
+// GOOD - Extract to const classes
+class MyScreen extends StatelessWidget {
+  const MyScreen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return const Column(
+      children: [
+        _Header(),
+        _Description(),
+      ],
+    );
+  }
+}
+
+class _Header extends StatelessWidget {
+  const _Header();
+
+  @override
+  Widget build(BuildContext context) {
+    return const Column(
+      children: [
+        Icon(Icons.star, size: 48),
+        Text('Welcome'),
+      ],
+    );
+  }
+}
+```
+
+## Selective Provider Watching
+
+```dart
+// BAD - Rebuilds on any user change
+class UserAvatar extends ConsumerWidget {
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final user = ref.watch(userProvider);
+    return CircleAvatar(
+      backgroundImage: NetworkImage(user.avatarUrl),
+    );
+  }
+}
+
+// GOOD - Only rebuilds when avatarUrl changes
+class UserAvatar extends ConsumerWidget {
+  const UserAvatar({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final avatarUrl = ref.watch(userProvider.select((u) => u.avatarUrl));
+    return CircleAvatar(
+      backgroundImage: NetworkImage(avatarUrl),
+    );
+  }
+}
+```
+
+## RepaintBoundary
+
+Isolate expensive widgets to prevent unnecessary repaints:
+
+```dart
+// Isolate complex animated widgets
+RepaintBoundary(
+  child: ComplexAnimatedWidget(),
+)
+
+// Isolate frequently updating widgets
+RepaintBoundary(
+  child: StreamBuilder<int>(
+    stream: counterStream,
+    builder: (context, snapshot) => Text('${snapshot.data}'),
+  ),
+)
+```
+
+## List Optimization
+
+```dart
+// BAD - Builds all items upfront
+ListView(
+  children: items.map((item) => ItemWidget(item: item)).toList(),
+)
+
+// GOOD - Lazy loading with builder
+ListView.builder(
+  itemCount: items.length,
+  itemBuilder: (context, index) {
+    return ItemWidget(
+      key: ValueKey(items[index].id),
+      item: items[index],
+    );
+  },
+)
+
+// For heterogeneous content
+ListView.separated(
+  itemCount: items.length,
+  separatorBuilder: (_, __) => const Divider(),
+  itemBuilder: (context, index) => ItemWidget(item: items[index]),
+)
+```
+
+## Image Optimization
+
+```dart
+// Use cached_network_image for network images
+CachedNetworkImage(
+  imageUrl: url,
+  placeholder: (_, __) => const ShimmerPlaceholder(),
+  errorWidget: (_, __, ___) => const Icon(Icons.error),
+  memCacheWidth: 200,
+  memCacheHeight: 200,
+)
+
+// Resize images in memory
+Image.network(
+  url,
+  cacheWidth: 200,   // Decode at smaller size
+  cacheHeight: 200,  // Saves memory
+)
+
+// Precache images
+precacheImage(NetworkImage(url), context);
+```
+
+## Heavy Computation
+
+```dart
+// BAD - Blocks UI thread
+void processData() {
+  final result = heavyComputation(data);  // UI freezes
+  updateUI(result);
+}
+
+// GOOD - Run in isolate
+Future<void> processData() async {
+  final result = await compute(heavyComputation, data);
+  updateUI(result);
+}
+
+// For multiple operations
+Future<void> processMultiple() async {
+  final results = await Future.wait([
+    compute(process1, data1),
+    compute(process2, data2),
+    compute(process3, data3),
+  ]);
+}
+```
+
+## Animation Performance
+
+```dart
+// Use AnimatedBuilder for custom animations
+AnimatedBuilder(
+  animation: controller,
+  builder: (context, child) {
+    return Transform.rotate(
+      angle: controller.value * 2 * pi,
+      child: child,  // Child not rebuilt
+    );
+  },
+  child: const ExpensiveWidget(),
+)
+
+// Prefer implicit animations for simple cases
+AnimatedContainer(
+  duration: const Duration(milliseconds: 300),
+  width: expanded ? 200 : 100,
+  child: const Content(),
+)
+```
+
+## DevTools Analysis
+
+### Key Metrics
+
+| Metric | Target | Action if Exceeded |
+|--------|--------|-------------------|
+| Frame time | < 16ms (60fps) | Profile build/paint |
+| Build time | < 8ms | Add const, extract widgets |
+| Paint time | < 8ms | Add RepaintBoundary |
+| Memory | Stable | Check for leaks |
+
+### Common Issues
+
+| Issue | Symptom | Solution |
+|-------|---------|----------|
+| Expensive builds | High build time | Extract const widgets |
+| Excessive repaints | High paint time | Add RepaintBoundary |
+| Memory leaks | Growing memory | Dispose controllers |
+| Jank | Dropped frames | Use compute() |
+
+## Performance Checklist
+
+| Check | Solution |
+|-------|----------|
+| Unnecessary rebuilds | Add `const`, use `select()` |
+| Large lists | Use `ListView.builder` |
+| Image loading | Use `cached_network_image` |
+| Heavy computation | Use `compute()` |
+| Jank in animations | Use `RepaintBoundary` |
+| Memory leaks | Dispose controllers, cancel subscriptions |
+| Network calls | Cache responses, debounce requests |
+| Startup time | Defer initialization, lazy loading |
+
+## Dispose Pattern
+
+```dart
+class MyWidget extends StatefulWidget {
+  const MyWidget({super.key});
+
+  @override
+  State<MyWidget> createState() => _MyWidgetState();
+}
+
+class _MyWidgetState extends State<MyWidget> {
+  late final TextEditingController _controller;
+  late final StreamSubscription _subscription;
+
+  @override
+  void initState() {
+    super.initState();
+    _controller = TextEditingController();
+    _subscription = stream.listen(handleData);
+  }
+
+  @override
+  void dispose() {
+    _controller.dispose();
+    _subscription.cancel();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) => Container();
+}
+```
+
+---
+
+*Flutter and DevTools are trademarks of Google LLC.*

package/skills/flutter-dev/references/platform-specific.md

@@ -0,0 +1,417 @@
+# Platform Integration
+
+Flutter platform-specific implementations for iOS, Android, Web, and Desktop.
+
+## Platform Detection
+
+```dart
+import 'dart:io' show Platform;
+import 'package:flutter/foundation.dart' show kIsWeb;
+
+bool get isIOS => !kIsWeb && Platform.isIOS;
+bool get isAndroid => !kIsWeb && Platform.isAndroid;
+bool get isWeb => kIsWeb;
+bool get isDesktop => !kIsWeb && (Platform.isMacOS || Platform.isWindows || Platform.isLinux);
+bool get isMobile => !kIsWeb && (Platform.isIOS || Platform.isAndroid);
+```
+
+## Adaptive Widgets
+
+### Platform-Aware Components
+
+```dart
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+
+class AdaptiveButton extends StatelessWidget {
+  final String label;
+  final VoidCallback onPressed;
+
+  const AdaptiveButton({
+    super.key,
+    required this.label,
+    required this.onPressed,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    if (Platform.isIOS) {
+      return CupertinoButton.filled(
+        onPressed: onPressed,
+        child: Text(label),
+      );
+    }
+    return ElevatedButton(
+      onPressed: onPressed,
+      child: Text(label),
+    );
+  }
+}
+```
+
+### Adaptive Dialog
+
+```dart
+Future<bool?> showAdaptiveConfirmDialog(
+  BuildContext context, {
+  required String title,
+  required String content,
+}) async {
+  if (Platform.isIOS) {
+    return showCupertinoDialog<bool>(
+      context: context,
+      builder: (context) => CupertinoAlertDialog(
+        title: Text(title),
+        content: Text(content),
+        actions: [
+          CupertinoDialogAction(
+            isDestructiveAction: true,
+            onPressed: () => Navigator.pop(context, true),
+            child: const Text('Delete'),
+          ),
+          CupertinoDialogAction(
+            isDefaultAction: true,
+            onPressed: () => Navigator.pop(context, false),
+            child: const Text('Cancel'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  return showDialog<bool>(
+    context: context,
+    builder: (context) => AlertDialog(
+      title: Text(title),
+      content: Text(content),
+      actions: [
+        TextButton(
+          onPressed: () => Navigator.pop(context, false),
+          child: const Text('Cancel'),
+        ),
+        TextButton(
+          onPressed: () => Navigator.pop(context, true),
+          child: const Text('Delete'),
+        ),
+      ],
+    ),
+  );
+}
+```
+
+### Adaptive Scaffold
+
+```dart
+class AdaptiveScaffold extends StatelessWidget {
+  final String title;
+  final Widget body;
+  final List<Widget>? actions;
+
+  const AdaptiveScaffold({
+    super.key,
+    required this.title,
+    required this.body,
+    this.actions,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    if (Platform.isIOS) {
+      return CupertinoPageScaffold(
+        navigationBar: CupertinoNavigationBar(
+          middle: Text(title),
+          trailing: actions != null
+              ? Row(mainAxisSize: MainAxisSize.min, children: actions!)
+              : null,
+        ),
+        child: SafeArea(child: body),
+      );
+    }
+
+    return Scaffold(
+      appBar: AppBar(title: Text(title), actions: actions),
+      body: body,
+    );
+  }
+}
+```
+
+## Platform Channels
+
+### Method Channel (Dart Side)
+
+```dart
+import 'package:flutter/services.dart';
+
+class NativeBridge {
+  static const _channel = MethodChannel('com.example.app/native');
+
+  static Future<String> getPlatformVersion() async {
+    final version = await _channel.invokeMethod<String>('getPlatformVersion');
+    return version ?? 'Unknown';
+  }
+
+  static Future<void> triggerHaptic() async {
+    await _channel.invokeMethod('triggerHaptic');
+  }
+
+  static Future<Map<String, dynamic>> getDeviceInfo() async {
+    final result = await _channel.invokeMethod<Map>('getDeviceInfo');
+    return Map<String, dynamic>.from(result ?? {});
+  }
+}
+```
+
+### iOS Implementation (Swift)
+
+```swift
+// ios/Runner/AppDelegate.swift
+import Flutter
+import UIKit
+
+@main
+@objc class AppDelegate: FlutterAppDelegate {
+    override func application(
+        _ application: UIApplication,
+        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+    ) -> Bool {
+        let controller = window?.rootViewController as! FlutterViewController
+        let channel = FlutterMethodChannel(
+            name: "com.example.app/native",
+            binaryMessenger: controller.binaryMessenger
+        )
+
+        channel.setMethodCallHandler { (call, result) in
+            switch call.method {
+            case "getPlatformVersion":
+                result("iOS " + UIDevice.current.systemVersion)
+            case "triggerHaptic":
+                let generator = UIImpactFeedbackGenerator(style: .medium)
+                generator.impactOccurred()
+                result(nil)
+            case "getDeviceInfo":
+                result([
+                    "model": UIDevice.current.model,
+                    "name": UIDevice.current.name,
+                    "systemVersion": UIDevice.current.systemVersion
+                ])
+            default:
+                result(FlutterMethodNotImplemented)
+            }
+        }
+
+        GeneratedPluginRegistrant.register(with: self)
+        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+    }
+}
+```
+
+### Android Implementation (Kotlin)
+
+```kotlin
+// android/app/src/main/kotlin/.../MainActivity.kt
+package com.example.app
+
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.content.Context
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodChannel
+
+class MainActivity: FlutterActivity() {
+    private val CHANNEL = "com.example.app/native"
+
+    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+        super.configureFlutterEngine(flutterEngine)
+
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)
+            .setMethodCallHandler { call, result ->
+                when (call.method) {
+                    "getPlatformVersion" -> {
+                        result.success("Android ${Build.VERSION.RELEASE}")
+                    }
+                    "triggerHaptic" -> {
+                        val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                            vibrator.vibrate(
+                                VibrationEffect.createOneShot(50, VibrationEffect.DEFAULT_AMPLITUDE)
+                            )
+                        } else {
+                            @Suppress("DEPRECATION")
+                            vibrator.vibrate(50)
+                        }
+                        result.success(null)
+                    }
+                    "getDeviceInfo" -> {
+                        result.success(mapOf(
+                            "model" to Build.MODEL,
+                            "manufacturer" to Build.MANUFACTURER,
+                            "version" to Build.VERSION.RELEASE
+                        ))
+                    }
+                    else -> result.notImplemented()
+                }
+            }
+    }
+}
+```
+
+## iOS-Specific Configuration
+
+### Info.plist Permissions
+
+```xml
+<!-- ios/Runner/Info.plist -->
+<key>NSCameraUsageDescription</key>
+<string>This app needs camera access to take photos</string>
+
+<key>NSPhotoLibraryUsageDescription</key>
+<string>This app needs photo library access to save images</string>
+
+<key>NSLocationWhenInUseUsageDescription</key>
+<string>This app needs location access to show nearby places</string>
+
+<key>NSMicrophoneUsageDescription</key>
+<string>This app needs microphone access for voice recording</string>
+```
+
+### iOS App Icons and Launch Screen
+
+```
+ios/Runner/Assets.xcassets/
+├── AppIcon.appiconset/
+│   ├── Contents.json
+│   └── Icon-App-*.png
+└── LaunchImage.imageset/
+    ├── Contents.json
+    └── LaunchImage*.png
+```
+
+## Android-Specific Configuration
+
+### AndroidManifest.xml Permissions
+
+```xml
+<!-- android/app/src/main/AndroidManifest.xml -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+
+    <application
+        android:label="My App"
+        android:icon="@mipmap/ic_launcher">
+        <!-- ... -->
+    </application>
+</manifest>
+```
+
+### Build Gradle Configuration
+
+```groovy
+// android/app/build.gradle
+android {
+    compileSdkVersion 34
+
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 34
+        multiDexEnabled true
+    }
+
+    buildTypes {
+        release {
+            signingConfig signingConfigs.release
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+```
+
+## Web-Specific
+
+### Conditional Imports
+
+```dart
+// lib/services/storage_service.dart
+export 'storage_service_stub.dart'
+    if (dart.library.io) 'storage_service_native.dart'
+    if (dart.library.html) 'storage_service_web.dart';
+```
+
+```dart
+// lib/services/storage_service_web.dart
+import 'dart:html' as html;
+
+class StorageService {
+  void save(String key, String value) {
+    html.window.localStorage[key] = value;
+  }
+
+  String? load(String key) {
+    return html.window.localStorage[key];
+  }
+}
+```
+
+### Web Index Configuration
+
+```html
+<!-- web/index.html -->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>My App</title>
+  <link rel="manifest" href="manifest.json">
+  <link rel="icon" type="image/png" href="favicon.png"/>
+</head>
+<body>
+  <script src="flutter_bootstrap.js" async></script>
+</body>
+</html>
+```
+
+## Platform-Specific Styling
+
+```dart
+ThemeData get theme {
+  final baseTheme = ThemeData(
+    colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
+    useMaterial3: true,
+  );
+
+  if (Platform.isIOS) {
+    return baseTheme.copyWith(
+      // iOS-style page transitions
+      pageTransitionsTheme: const PageTransitionsTheme(
+        builders: {
+          TargetPlatform.iOS: CupertinoPageTransitionsBuilder(),
+        },
+      ),
+    );
+  }
+
+  return baseTheme;
+}
+```
+
+## Platform Reference
+
+| Feature | iOS | Android | Web |
+|---------|-----|---------|-----|
+| Navigation | Cupertino style | Material style | URL-based |
+| Haptics | UIFeedbackGenerator | Vibrator | Not available |
+| Storage | NSUserDefaults | SharedPreferences | localStorage |
+| Deep links | Universal Links | App Links | URL routing |
+| Notifications | APNs | FCM | Web Push |
+
+---
+
+*Flutter, iOS, Android, and their respective logos are trademarks of Google LLC and Apple Inc.*