Most Advanced and Useful Flutter Techniques (from r/FlutterDev)

### Advanced Flutter Techniques

- **State Management**  
  - Use tools like Riverpod for clean and easy async state management.  
  - Build async-friendly UI components that react to AsyncValue states.

- **Performance Optimization**  
  - Profile your app regularly.  
  - Follow good architectural patterns to reduce the need for later optimization.

- **Custom Animations and Transitions**  
  - Use the `flutter_animate` package.  
  - Use the Hero widget for smooth page transitions.

- **Native Platform Integration**  
  - Use PlatformView and MethodChannel to work with native SDKs.  
  - Call C/C++ libraries via Dart FFI (e.g., OpenCV for image processing).  
  - Try Flutter Rust Bridge and other emerging FFI tools.

- **Effective Debugging**  
  - Use breakpoints and verify app state during debugging.

- **CI/CD Pipelines**  
  - Use Melos for monorepo management, running tests, and scripting both locally and in CI.

- **Complex UI and Layouts**  
  - Use basic Flutter widgets like MediaQuery, LayoutBuilder, and SafeArea for responsive design.

- **Best Testing Practices**  
  - Write composable helper functions inspired by React Hooks to manage lifecycle and resources in tests, reducing boilerplate.

- **Working with Packages & Plugins**  
  - Use Melos to manage multiple packages and streamline your workflow.

- **Other Useful Practices**  
  - Follow SOLID design principles for maintainable code.  
  - Use git hooks to automate formatting and other common tasks.  
  - Launch emulators from the terminal or VSCode launch.json for faster startup.  
  - Set up centralized logging with strategy patterns for analytics and console logs.  
  - Create strongly-typed network libraries with mock implementations for easier testing.

### Use Cases for Native Code Integration  
- Alarm screen that appears even when the app is closed or the phone is locked.  
- Native APIs or libraries not yet available in Flutter (e.g., Azure Speech Recognition).  
- Heavy processing tasks using C++ libraries via Dart FFI (e.g., OpenCV).

// ================== SOLID Principles ==================

// 1. Single Responsibility Principle (SRP)
// A class should have only one reason to change.

class SaveUserManager {
  void saveUser() {
    print("User saved.");
  }
}

class ValidateUserManager {
  void validateUser() {
    print("User validated.");
  }
}

// ======================================================

// 2. Open-Closed Principle (OCP)
// Software entities should be open for extension but closed for modification.

abstract class SalaryManager {
  int salary();

  int? bonus() {
    return 200; // default bonus
  }
}

class Junior extends SalaryManager {
  @override
  int salary() => 400;
}

class Middle extends SalaryManager {
  @override
  int salary() => 900;
}

class Senior extends SalaryManager {
  @override
  int salary() => 1400;

  @override
  int? bonus() => 400;
}

// ======================================================

// 3. Liskov Substitution Principle (LSP)
// Subtypes must be substitutable for their base types.

abstract class Shape {
  int area();
}

class Rectangle extends Shape {
  int height;
  int width;

  Rectangle(this.height, this.width);

  @override
  int area() => height * width;
}

class Square extends Shape {
  int side;

  Square(this.side);

  @override
  int area() => side * side;
}

// ======================================================

// 4. Interface Segregation Principle (ISP)
// No client should be forced to depend on methods it does not use.

abstract class DrivingTransport {
  void drive();
}

abstract class FlyingTransport {
  void fly();
}

abstract class SwimmingTransport {
  void swim();
}

class BMW implements DrivingTransport {
  @override
  void drive() {
    print("BMW driving on road...");
  }
}

class Boat implements SwimmingTransport {
  @override
  void swim() {
    print("Boat swimming on water...");
  }
}

class Airplane implements FlyingTransport {
  @override
  void fly() {
    print("Airplane flying in the sky...");
  }
}

// ======================================================

// 5. Dependency Inversion Principle (DIP)
// High-level modules should not depend on low-level modules.
// Both should depend on abstractions.

abstract class AuthService {
  void signIn();
}

class SmsAuth extends AuthService {
  @override
  void signIn() {
    print("Signed in with SMS");
  }
}

class GoogleAuth extends AuthService {
  @override
  void signIn() {
    print("Signed in with Google");
  }
}

class UserAuth {
  final AuthService authService;

  UserAuth(this.authService);

  void signIn() {
    authService.signIn();
  }
}

// ======================================================

void main() {
  // SRP
  SaveUserManager().saveUser();
  ValidateUserManager().validateUser();

  // OCP
  SalaryManager junior = Junior();
  print("Junior salary: ${junior.salary()}, bonus: ${junior.bonus()}");

  SalaryManager senior = Senior();
  print("Senior salary: ${senior.salary()}, bonus: ${senior.bonus()}");

  // LSP
  Shape rect = Rectangle(10, 20);
  Shape square = Square(15);
  print("Rectangle area: ${rect.area()}");
  print("Square area: ${square.area()}");

  // ISP
  BMW().drive();
  Boat().swim();
  Airplane().fly();

  // DIP
  UserAuth userAuth1 = UserAuth(GoogleAuth());
  userAuth1.signIn();

  UserAuth userAuth2 = UserAuth(SmsAuth());
  userAuth2.signIn();
}