Flutter

// Null safety: non-nullable by default
String name = 'Flutter';
int version = 3;
double rating = 4.9;
bool isAwesome = true;

// Nullable with ?
String? nickname;  // can be null

// Type inference with var / final / const
var message = 'Hello';        // inferred String
final pi = 3.14159;          // immutable at runtime
const maxItems = 100;        // compile-time constant

// Collections
List<String> fruits = ['apple', 'banana', 'mango'];
Map<String, int> scores = {'Alice': 95, 'Bob': 87};
Set<int> unique = {1, 2, 3};

// String interpolation
print('Hello, $name! Version ${version + 1}');

// Named & optional parameters
String greet(String name, {String greeting = 'Hello'}) {
  return '$greeting, $name!';
}

// Arrow functions
int square(int n) => n * n;

// Class with constructor
class Person {
  final String name;
  final int age;

  // Constructor shorthand
  Person({required this.name, required this.age});

  // Named constructor
  Person.anonymous() : name = 'Unknown', age = 0;

  // Getter
  bool get isAdult => age >= 18;

  // toString override
  @override
  String toString() => 'Person(name: $name, age: $age)';
}

// Mixins
mixin Flyable {
  void fly() => print('Flying!');
}

class SuperHero extends Person with Flyable {
  SuperHero(String name) : super(name: name, age: 30);
}

// Future — single async value
Future<String> fetchUser(int id) async {
  await Future.delayed(Duration(seconds: 2));
  return 'User $id';
}

void main() async {
  final user = await fetchUser(42);
  print(user);

  // Error handling
  try {
    final data = await riskyOperation();
  } catch (e) {
    print('Error: $e');
  }
}

// Stream — async sequence of values
Stream<int> countdown(int n) async* {
  for (int i = n; i >= 0; i--) {
    yield i;
    await Future.delayed(Duration(seconds: 1));
  }
}

// Listen to stream
countdown(5).listen((n) => print('$n...'));

# Check Flutter installation
flutter doctor

# Create new project
flutter create my_awesome_app
cd my_awesome_app

# Get dependencies
flutter pub get

# Run on connected device/simulator
flutter run

# Build release APK for Android
flutter build apk --release

# Build for iOS
flutter build ios --release

# Build for web
flutter build web

# Add a package
flutter pub add http

my_app/
├── lib/                   # Your Dart code lives here
│   ├── main.dart         # App entry point
│   ├── screens/          # Screen widgets
│   ├── widgets/          # Reusable widgets
│   ├── models/           # Data models
│   ├── services/         # API / DB services
│   └── providers/        # State management
├── test/                  # Unit & widget tests
├── android/               # Android-specific files
├── ios/                   # iOS-specific files
├── web/                   # Web-specific files
├── assets/                # Images, fonts, JSON
└── pubspec.yaml           # Dependencies & metadata

// 1. Define a ChangeNotifier model
class CartModel extends ChangeNotifier {
  final List<String> _items = [];

  List<String> get items => List.unmodifiable(_items);

  void add(String item) {
    _items.add(item);
    notifyListeners();  // rebuilds listening widgets
  }

  void remove(String item) {
    _items.remove(item);
    notifyListeners();
  }
}

// 2. Provide it at the top of the tree
void main() => runApp(
  ChangeNotifierProvider(
    create: (_) => CartModel(),
    child: const MyApp(),
  ),
);

// 3. Consume with Consumer or context.watch
class CartButton extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final cart = context.watch<CartModel>();
    return Badge(
      label: Text('${cart.items.length}'),
      child: IconButton(
        icon: const Icon(Icons.shopping_cart),
        onPressed: () {},
      ),
    );
  }
}

import 'package:flutter_riverpod/flutter_riverpod.dart';

// Define a provider
final counterProvider = StateNotifierProvider<CounterNotifier, int>(
  (ref) => CounterNotifier(),
);

class CounterNotifier extends StateNotifier<int> {
  CounterNotifier() : super(0);
  void increment() => state++;
  void decrement() => state--;
}

// Wrap app with ProviderScope
void main() => runApp(ProviderScope(child: MyApp()));

// Use ConsumerWidget
class CounterScreen extends ConsumerWidget {
  @override
  Widget build(BuildContext ctx, WidgetRef ref) {
    final count = ref.watch(counterProvider);
    return Scaffold(
      body: Center(child: Text('$count', style: TextStyle(fontSize:48))),
      floatingActionButton: FloatingActionButton(
        onPressed: () => ref.read(counterProvider.notifier).increment(),
        child: const Icon(Icons.add),
      ),
    );
  }
}

Column(
  mainAxisAlignment: MainAxisAlignment.center,
  crossAxisAlignment: CrossAxisAlignment.start,
  children: [
    Text('Title', style: TextStyle(fontSize: 24)),
    const SizedBox(height: 8),
    Row(
      children: [
        Expanded(child: Text('Left')),   // takes available width
        Flexible(child: Text('Right')),  // flexible but won't force size
      ],
    ),
    Spacer(),  // fills remaining space
    ElevatedButton(onPressed: (){}, child: Text('OK')),
  ],
)

// Overlapping widgets with Stack
Stack(
  children: [
    Image.network('https://...', fit: BoxFit.cover),
    Positioned(
      bottom: 16, left: 16,
      child: Text('Caption', style: TextStyle(color: Colors.white)),
    ),
    Positioned(top: 8, right: 8, child: Icon(Icons.favorite)),
  ],
)

// Responsive with LayoutBuilder
LayoutBuilder(
  builder: (context, constraints) {
    if (constraints.maxWidth > 600) {
      return WideLayout();   // tablet/desktop
    }
    return NarrowLayout();   // phone
  },
)

// Adaptive sizing with MediaQuery
final screenWidth = MediaQuery.of(context).size.width;
final isTablet = screenWidth > 768;

// Push a new screen
Navigator.push(
  context,
  MaterialPageRoute(
    builder: (context) => DetailScreen(id: 42),
  ),
);

// Pop back with result
Navigator.pop(context, 'result');

// Named routes setup
MaterialApp(
  initialRoute: '/',
  routes: {
    '/':       (ctx) => HomeScreen(),
    '/detail': (ctx) => DetailScreen(),
    '/settings': (ctx) => SettingsScreen(),
  },
);

// Navigate with arguments
Navigator.pushNamed(context, '/detail', arguments: {'id': 42});

import 'package:go_router/go_router.dart';

final _router = GoRouter(
  routes: [
    GoRoute(
      path: '/',
      builder: (context, state) => const HomeScreen(),
    ),
    GoRoute(
      path: '/product/:id',
      builder: (context, state) {
        final id = state.pathParameters['id']!;
        return ProductScreen(id: id);
      },
    ),
    ShellRoute(   // nested navigation (bottom nav)
      builder: (context, state, child) => AppShell(child: child),
      routes: [
        GoRoute(path: '/home', builder: (c,s) => HomeTab()),
        GoRoute(path: '/search', builder: (c,s) => SearchTab()),
        GoRoute(path: '/profile', builder: (c,s) => ProfileTab()),
      ],
    ),
  ],
);

// Navigate from anywhere
context.go('/product/123');
context.push('/settings');

import 'dart:convert';
import 'package:http/http.dart' as http;

// Data model
class Post {
  final int id;
  final String title;
  final String body;

  const Post({required this.id, required this.title, required this.body});

  factory Post.fromJson(Map<String, dynamic> json) => Post(
    id: json['id'] as int,
    title: json['title'] as String,
    body: json['body'] as String,
  );
}

// Fetch from API
Future<List<Post>> fetchPosts() async {
  final response = await http.get(
    Uri.parse('https://jsonplaceholder.typicode.com/posts'),
  );
  if (response.statusCode == 200) {
    final data = jsonDecode(response.body) as List;
    return data.map((json) => Post.fromJson(json)).toList();
  }
  throw Exception('Failed to load posts');
}

class PostsList extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return FutureBuilder<List<Post>>(
      future: fetchPosts(),
      builder: (context, snapshot) {
        // Loading state
        if (snapshot.connectionState == ConnectionState.waiting) {
          return const Center(child: CircularProgressIndicator());
        }
        // Error state
        if (snapshot.hasError) {
          return Center(child: Text('Error: ${snapshot.error}'));
        }
        // Data state
        final posts = snapshot.data!;
        return ListView.builder(
          itemCount: posts.length,
          itemBuilder: (ctx, i) => ListTile(
            title: Text(posts[i].title),
            subtitle: Text(posts[i].body),
          ),
        );
      },
    );
  }
}

import 'package:flutter/material.dart';

void main() => runApp(const MyApp());

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
        useMaterial3: true,
      ),
      home: const MainScreen(),
    );
  }
}

class MainScreen extends StatefulWidget {
  const MainScreen({super.key});

  @override
  State<MainScreen> createState() => _MainScreenState();
}

class _MainScreenState extends State<MainScreen> {
  int _selectedIndex = 0;

  static const _screens = [
    HomeTab(), SearchTab(), ProfileTab(),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: IndexedStack(     // preserves tab state
        index: _selectedIndex,
        children: _screens,
      ),
      bottomNavigationBar: NavigationBar(
        selectedIndex: _selectedIndex,
        onDestinationSelected: (i) => setState(() => _selectedIndex = i),
        destinations: const [
          NavigationDestination(icon: Icon(Icons.home), label: 'Home'),
          NavigationDestination(icon: Icon(Icons.search), label: 'Search'),
          NavigationDestination(icon: Icon(Icons.person), label: 'Profile'),
        ],
      ),
    );
  }
}

class AnimatedHeartButton extends StatefulWidget {
  const AnimatedHeartButton({super.key});

  @override
  State<AnimatedHeartButton> createState() => _AnimatedHeartButtonState();
}

class _AnimatedHeartButtonState extends State<AnimatedHeartButton>
    with SingleTickerProviderStateMixin {
  late AnimationController _controller;
  late Animation<double> _scaleAnim;
  bool _liked = false;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 200),
    );
    _scaleAnim = Tween(begin: 1.0, end: 1.4).chain(
      CurveTween(curve: Curves.elasticOut),
    ).animate(_controller);
  }

  void _onTap() {
    setState(() => _liked = !_liked);
    _controller.forward().then((_) => _controller.reverse());
  }

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: _onTap,
      child: ScaleTransition(
        scale: _scaleAnim,
        child: Icon(
          _liked ? Icons.favorite : Icons.favorite_border,
          color: _liked ? Colors.red : Colors.grey,
          size: 32,
        ),
      ),
    );
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

class WaveWidget extends StatefulWidget { ... }

class WavePainter extends CustomPainter {
  final double animValue;
  WavePainter(this.animValue);

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue.withOpacity(0.5)
      ..style = PaintingStyle.fill;

    final path = Path();
    path.moveTo(0, size.height * 0.5);

    for (double x = 0; x <= size.width; x++) {
      final y = size.height * 0.5 +
          math.sin((x / size.width * 2 * math.pi) + animValue) * 30;
      path.lineTo(x, y);
    }
    path.lineTo(size.width, size.height);
    path.lineTo(0, size.height);
    path.close();

    canvas.drawPath(path, paint);
  }

  @override
  bool shouldRepaint(WavePainter old) => old.animValue != animValue;
}