refactorplan.md

📦 Architecture Refactoring (High Priority)

1. Break Down Massive Classes

NativeTermFormFragment (3,346 lines)

Target Structure:

• NativeTermFormFragment (UI only, ~500 lines)
• NativeTermFormViewModel (business logic)
• NativeTermFormValidator (validation logic)
• ParentTermManager (parent term handling)

SentenceReadFragment (3,074 lines)

Target Structure:

• SentenceReadFragment (UI only)
• SentenceReadViewModel
• SentenceNavigationManager
• SentenceAudioManager

MainActivity (2,396 lines)

Extract Classes:

• WordCountManager (lines 365-525)
• BookLanguageDetector (lines 1463-1792)
• NetworkStatusManager

AppSettingsFragment (2,289 lines)

Target Structure:

• Split into category-specific fragments:
  • DisplaySettingsFragment
  • AudioSettingsFragment
  • LanguageSettingsFragment
  • AdvancedSettingsFragment

2. Implement Proper MVVM

• Create ViewModels for all large fragments
• Move business logic out of UI components
• Use LiveData/StateFlow for reactive UI updates
• Implement proper data binding patterns

🔧 Code Quality Improvements (Medium Priority)

1. Eliminate Code Duplication

Network Operations

• Create NetworkUtils class for common operations
• Centralize HTTP client configuration
• Standardize error handling for network calls

HTML Parsing

• Implement HtmlParser utility for JSoup operations
• Extract common parsing patterns
• Add proper sanitization methods

Logging & Utilities

• Create LoggingUtils for consistent logging patterns
• Implement SharedPreferencesManager for settings access
• Add StringUtils for common text operations

2. Improve Error Handling

• Create centralized ErrorHandler class
• Implement specific exception types:
  • NetworkException
  • ParseException
  • ValidationException
• Add proper user feedback for all error states
• Replace generic catch (e: Exception) with specific handling

3. Standardize Code Style

• Configure ktlint with custom rules
• Remove wildcard imports
• Standardize naming conventions
• Add consistent KDoc documentation
• Implement pre-commit hooks for code quality

⚡ Performance Optimizations (Medium Priority)

1. Memory Management

• Fix potential memory leaks in large fragments
• Implement proper lifecycle cleanup
• Use weak references for listeners where appropriate
• Add memory profiling and monitoring

2. Resource Optimization

Font Files (7.6MB total)

• Current Size: 7.6MB across 4 font families
• Optimization:
  • Remove unused font variants
  • Convert to WOFF2 format for Android
  • Load fonts dynamically instead of bundling all
  • Implement font subsetting for reduced size

Image Assets

• Convert PNG to WebP format (30-50% size reduction)
• Remove duplicate icons
• Implement vector drawables where possible
• Optimize launcher icons for different densities

3. Network Performance

• Implement request caching with proper TTL
• Add connection pooling
• Use proper async/await patterns
• Add network monitoring and metrics

🧪 Testing & Documentation (Low Priority)

1. Add Missing Tests

• Unit Tests: ViewModels and business logic
• Integration Tests: Network operations and database interactions
• UI Tests: Critical user flows and navigation
• Performance Tests: Memory usage and startup time

2. Improve Documentation

• Add KDoc comments to all public APIs
• Document complex algorithms and business logic
• Create architectural decision records (ADRs)
• Add inline comments for critical code sections

📋 Implementation Order

📊 Expected Impact

Code Metrics

• Lines of Code Reduction: ~40% (from ~15,000 to ~9,000)
• Cyclomatic Complexity: Significantly reduced through smaller methods
• Code Duplication: Eliminated 100+ instances of duplicate patterns

Security

• Security Score: Improve from critical to safe
• Vulnerability Count: Reduce from 5+ critical to 0
• Compliance: Meet Android security best practices

Performance

• Memory Usage: ~25% reduction in runtime memory
• Startup Time: ~20% improvement in app launch
• APK Size: ~30% reduction through resource optimization

Maintainability

• Class Size: Largest classes reduced from 3000+ to <500 lines
• Method Complexity: Long methods broken into focused functions
• Documentation: 100% coverage of public APIs

🛠️ Tools & Technologies

Code Quality Tools

• ktlint: Kotlin code formatting
• detekt: Static analysis for Kotlin
• sonarqube: Code quality and security analysis
• dependency-check: Vulnerability scanning

Performance Tools

• Android Profiler: Memory and CPU analysis
• LeakCanary: Memory leak detection
• Firebase Performance: Network and app performance monitoring