appiq-solution 1.2.0 → 1.3.0

package/#Tools/APPIQ-METHOD/expansion-packs/bmad-mobile-app-dev/data/bmad-kb.md

@@ -0,0 +1,292 @@
+# Mobile App Development Knowledge Base
+
+## Platform Overview
+
+### Flutter
+Flutter is Google's UI toolkit for building natively compiled applications for mobile, web, and desktop from a single codebase. It uses the Dart programming language and provides excellent performance with native compilation.
+
+**Key Advantages:**
+- Single codebase for multiple platforms
+- Hot reload for fast development
+- Rich widget ecosystem
+- Strong community support
+- Excellent documentation
+
+### React Native
+React Native is Facebook's framework for building mobile applications using React and JavaScript. It allows developers to create truly native apps with the familiarity of React development patterns.
+
+**Key Advantages:**
+- Familiar React development experience
+- Large JavaScript ecosystem
+- Good community support
+- Code sharing between iOS and Android
+- Over-the-air updates capability
+
+## State Management Best Practices 2024
+
+### Flutter State Management
+
+#### BLoC/Cubit - Production Ready (Recommended for Enterprise)
+**When to Use:**
+- Large, complex applications
+- Enterprise-level projects
+- When you need predictable state management
+- Projects requiring extensive testing
+- Teams that benefit from strict patterns
+
+**Best Practices:**
+- Use Cubit for simpler state scenarios
+- Use BLoC for complex event-driven logic
+- Implement clean architecture layers
+- Use dependency injection with GetIt
+- Follow the repository pattern
+
+**Key Dependencies:**
+```yaml
+dependencies:
+  flutter_bloc: ^8.1.3
+  equatable: ^2.0.5
+  get_it: ^7.6.4
+  injectable: ^2.3.0
+```
+
+#### Riverpod - Modern Alternative (Recommended for New Projects)
+**When to Use:**
+- Medium to large applications
+- When you want compile-time safety
+- Projects requiring flexible dependency injection
+- Modern Flutter applications
+
+**Best Practices:**
+- Use StateProvider for simple state
+- Use StateNotifierProvider for complex state
+- Leverage AsyncValue for handling loading/error states
+- Use family modifiers for parameterized providers
+
+#### GetX - Rapid Development (Recommended for MVPs)
+**When to Use:**
+- Small to medium applications
+- Rapid prototyping
+- When simplicity is preferred
+- Projects with tight deadlines
+
+**Best Practices:**
+- Use GetBuilder for performance-critical widgets
+- Implement clean architecture with GetX
+- Use GetX dependency injection
+- Follow reactive programming patterns
+
+#### Provider - Beginner Friendly
+**When to Use:**
+- Learning Flutter
+- Simple applications
+- When you want to understand state management fundamentals
+
+### React Native State Management
+
+#### Redux Toolkit - Enterprise Standard
+**When to Use:**
+- Large, complex applications
+- When you need time-travel debugging
+- Projects with complex state interactions
+- Teams familiar with Redux patterns
+
+**Best Practices:**
+- Use RTK Query for data fetching
+- Implement normalized state structure
+- Use createSlice for reducers
+- Follow the ducks pattern for organization
+
+#### Zustand - Lightweight Alternative
+**When to Use:**
+- Small to medium applications
+- When Redux feels too heavy
+- Projects requiring dynamic state updates
+- Performance-critical applications
+
+**Best Practices:**
+- Use immer for immutable updates
+- Implement middleware for persistence
+- Create separate stores for different domains
+- Use subscribeWithSelector for optimizations
+
+#### Context API - Built-in Solution
+**When to Use:**
+- Simple global state needs
+- Theme or language preferences
+- Authentication state
+- Small applications
+
+**Best Practices:**
+- Avoid frequent updates to prevent re-renders
+- Split contexts by concern
+- Use React.memo to optimize components
+- Combine with useReducer for complex state
+
+## Clean Architecture Patterns
+
+### Flutter Clean Architecture
+
+#### Layer Structure
+```
+lib/
+├── core/              # Infrastructure & shared utilities
+├── data/              # Data layer (repositories impl, datasources, models)
+├── domain/            # Business logic (entities, repository interfaces)
+└── presentation/      # UI layer (screens, widgets, BLoC/Cubit)
+```
+
+#### Dependency Rules
+- Dependencies point inward (presentation → domain ← data)
+- Domain layer is independent of external frameworks
+- Use dependency injection for loose coupling
+- Repository pattern for data access abstraction
+
+### React Native Clean Architecture
+
+#### Recommended Structure
+```
+src/
+├── components/        # Reusable UI components
+├── screens/          # Screen components
+├── navigation/       # Navigation configuration
+├── services/         # API and external services
+├── hooks/           # Custom React hooks
+├── types/           # TypeScript type definitions
+├── store/           # State management (Redux/Zustand)
+└── utils/           # Utility functions
+```
+
+## Development Guidelines
+
+### Flutter Development Rules
+
+#### Code Organization
+- Follow feature-based organization
+- Use barrel exports for clean imports
+- Implement proper error handling
+- Use const constructors where possible
+
+#### State Management Integration
+- Always use BaseCubitMixin for Cubits (when available)
+- Implement proper loading and error states
+- Use Either pattern for error handling
+- Register services with dependency injection
+
+#### UI Development
+- Create reusable widget components
+- Use theme-based styling
+- Implement proper localization
+- Follow material design guidelines
+
+### React Native Development Rules
+
+#### TypeScript Best Practices
+- Use strict TypeScript configuration
+- Define proper prop interfaces
+- Implement proper error boundaries
+- Use generic types for reusable components
+
+#### Performance Optimization
+- Use React.memo for expensive components
+- Implement lazy loading for screens
+- Optimize list rendering with FlatList
+- Use hermes engine for better performance
+
+## Testing Strategies
+
+### Flutter Testing
+- Unit tests for business logic
+- Widget tests for UI components
+- Integration tests for complete flows
+- Golden tests for UI consistency
+
+### React Native Testing
+- Jest for unit testing
+- React Native Testing Library for component tests
+- Detox for end-to-end testing
+- Snapshot testing for UI components
+
+## Platform-Specific Considerations
+
+### Flutter Specific
+- Use platform channels for native functionality
+- Implement proper app lifecycle handling
+- Optimize build sizes with tree shaking
+- Handle different screen sizes and orientations
+
+### React Native Specific
+- Use react-native-vector-icons for icons
+- Implement proper navigation with React Navigation
+- Handle platform-specific styling
+- Use flipper for debugging
+
+## Security Best Practices
+
+### Data Security
+- Encrypt sensitive local data
+- Use secure storage for credentials
+- Implement proper API authentication
+- Validate all user inputs
+
+### Network Security
+- Use HTTPS for all API calls
+- Implement certificate pinning
+- Add request/response interceptors
+- Handle network errors gracefully
+
+## Performance Optimization
+
+### Flutter Performance
+- Use const constructors
+- Minimize widget rebuilds
+- Optimize image loading
+- Use RepaintBoundary for expensive widgets
+
+### React Native Performance
+- Use FlatList for large lists
+- Implement proper image caching
+- Minimize bridge communications
+- Use native modules for heavy computations
+
+## Deployment and CI/CD
+
+### Flutter Deployment
+- Use Codemagic or GitHub Actions
+- Implement proper versioning
+- Configure different environments
+- Automate store uploads
+
+### React Native Deployment
+- Use Fastlane for automation
+- Implement CodePush for updates
+- Configure proper signing
+- Use App Center for distribution
+
+## Common Anti-Patterns to Avoid
+
+### Flutter Anti-Patterns
+- Avoid setState in StatelessWidget
+- Don't create widgets in build methods
+- Avoid deeply nested widget trees
+- Don't ignore memory leaks
+
+### React Native Anti-Patterns
+- Avoid inline styles in render methods
+- Don't mutate state directly
+- Avoid unnecessary re-renders
+- Don't ignore platform differences
+
+## Quality Assurance
+
+### Code Quality Metrics
+- Maintain high test coverage (>80%)
+- Follow linting rules consistently
+- Implement proper error handling
+- Document public APIs
+
+### Performance Metrics
+- Monitor app startup time
+- Track memory usage
+- Measure frame rendering performance
+- Monitor network request efficiency