Cheatsheet Flutter & Dart: Referensi Cepat Widget, State, dan API

// Tipe eksplisit
String nama = 'Budi';
int umur = 25;
double tinggi = 175.5;
bool aktif = true;

// Tipe dinamis
var kota = 'Jakarta';        // Inferred sebagai String
dynamic data = 'bisa apa saja'; // Bisa berubah tipe

// final & const
final waktu = DateTime.now();  // Runtime const, tidak bisa diubah
const pi = 3.14159;            // Compile-time const

// Nullable (Dart null safety)
String? alamat;                // Bisa null
int? nilai;                    // Bisa null
String nama2 = 'Wajib isi';    // Tidak boleh null

// Null safety operators
print(alamat?.length);         // Null-aware access
String namaFinal = nama2 ?? 'Default'; // Null coalescing
String namaUpper = nama2.toUpperCase(); // Cascade
alamat ??= 'Belum diisi';     // Null-aware assignment

// Fungsi dasar
int tambah(int a, int b) {
  return a + b;
}

// Arrow function (satu expression)
int kali(int a, int b) => a * b;

// Named parameters
void greet({required String nama, String salam = 'Halo'}) {
  print('$salam, $nama!');
}
greet(nama: 'Budi');               // Halo, Budi!
greet(nama: 'Budi', salam: 'Hi');  // Hi, Budi!

// Optional positional parameters
void log(String message, [String? prefix]) {
  print('${prefix ?? 'LOG'}: $message');
}
log('Server started');          // LOG: Server started
log('Server started', 'INFO');  // INFO: Server started

// Anonymous function / lambda
var list = [1, 2, 3, 4, 5];
var genap = list.where((n) => n % 2 == 0).toList();
// [2, 4]

// Higher-order function
List<int> apply(List<int> list, int Function(int) fn) {
  return list.map(fn).toList();
}
var hasil = apply([1, 2, 3], (x) => x * 2);
// [2, 4, 6]

// Cascade notation
var buffer = StringBuffer()
  ..write('Hello ')
  ..write('World')
  ..write('!');
print(buffer.toString()); // Hello World!

// Future - asynchronous computation
Future<String> fetchData() async {
  // Simulasi network request
  await Future.delayed(Duration(seconds: 2));
  return 'Data loaded!';
}

// Async/Await
void loadData() async {
  try {
    String data = await fetchData();
    print(data); // Data loaded!
  } catch (e) {
    print('Error: $e');
  }
}

// Future chaining dengan .then()
fetchData()
  .then((data) => print(data))
  .catchError((e) => print('Error: $e'));

// Stream - multiple async values
Stream<int> countStream(int max) async* {
  for (int i = 1; i <= max; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

// Mendengarkan Stream
void listenStream() async {
  await for (int value in countStream(5)) {
    print('Count: $value');
  }
}

// StreamBuilder di Flutter
// StreamBuilder<int>(
//   stream: countStream(10),
//   builder: (context, snapshot) {
//     if (snapshot.hasData) {
//       return Text('Count: ${snapshot.data}');
//     }
//     return CircularProgressIndicator();
//   },
// )

// Completer - manual future completion
import 'dart:async';
Future<String> getAuth() {
  final completer = Completer<String>();
  // Misalnya callback-based API
  onAuthSuccess((token) {
    completer.complete(token);
  });
  return completer.future;
}

// List
var buah = ['apel', 'jeruk', 'mangga'];
buah.add('pisang');
buah.addAll(['anggur', 'melon']);
buah.remove('jeruk');
buah.removeAt(0);
buah.insert(0, 'durian');

// List properties & methods
buah.length;          // Jumlah elemen
buah.isEmpty;         // true jika kosong
buah.isNotEmpty;      // true jika ada isi
buah.first;           // Elemen pertama
buah.last;            // Elemen terakhir
buah.contains('apel'); // true/false
buah.sublist(0, 2);   // [durian, mangga]
buah.shuffle();       // Acak urutan

// Spread operator & collection if/for
var a = [1, 2, 3];
var b = [0, ...a];           // [0, 1, 2, 3]
var c = [0, ...?a];          // null-safe spread

var showItem = true;
var items = [
  'item1',
  if (showItem) 'item2',    // Conditional
];
var doubled = [for (var i in [1,2,3]) i * 2]; // [2, 4, 6]

// Map
var mahasiswa = {
  'nama': 'Budi',
  'nim': '2024001',
  'ipk': 3.75,
};

// Operasi Map
mahasiswa['semester'] = 5;
mahasiswa.remove('ipk');
mahasiswa.containsKey('nama');   // true
mahasiswa.containsValue('Budi'); // true
mahasiswa.keys;                  // (nama, nim, semester)
mahasiswa.values;                // (Budi, 2024001, 5)

// Iterasi
mahasiswa.forEach((key, value) {
  print('$key: $value');
});

// Map dari List
var angka = [1, 2, 3];
var mapAngka = angka.asMap(); // {0: 1, 1: 2, 2: 3}

class GreetingCard extends StatelessWidget {
  final String nama;

  const GreetingCard({super.key, required this.nama});

  @override
  Widget build(BuildContext context) {
    return Card(
      child: Padding(
        padding: EdgeInsets.all(16),
        child: Text(
          'Halo, $nama!',
          style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
        ),
      ),
    );
  }
}

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

  @override
  State<CounterPage> createState() => _CounterPageState();
}

class _CounterPageState extends State<CounterPage> {
  int _count = 0;

  void _increment() {
    setState(() {
      _count++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Counter')),
      body: Center(
        child: Text('Count: $_count', style: TextStyle(fontSize: 32)),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

// Push halaman baru
Navigator.push(
  context,
  MaterialPageRoute(builder: (context) => DetailPage(id: 42)),
);

// Push dan ganti halaman (tidak bisa kembali)
Navigator.pushReplacement(
  context,
  MaterialPageRoute(builder: (context) => HomePage()),
);

// Push dan hapus semua stack
Navigator.pushAndRemoveUntil(
  context,
  MaterialPageRoute(builder: (context) => LoginPage()),
  (route) => false,
);

// Kembali ke halaman sebelumnya
Navigator.pop(context);

// Pop dengan result
Navigator.pop(context, 'result_data');

// Push dan dapatkan result
final result = await Navigator.push<String>(
  context,
  MaterialPageRoute(builder: (context) => SearchPage()),
);
print('Result: $result');

// Definisi routes di MaterialApp
MaterialApp(
  initialRoute: '/',
  routes: {
    '/': (context) => HomePage(),
    '/detail': (context) => DetailPage(),
    '/settings': (context) => SettingsPage(),
  },
);

// Navigasi dengan named route
Navigator.pushNamed(context, '/detail');
Navigator.pushNamed(context, '/detail', arguments: {'id': 42});

// Ambil arguments di halaman tujuan
final args = ModalRoute.of(context)!.settings.arguments as Map;

class TimerPage extends StatefulWidget {
  @override
  State<TimerPage> createState() => _TimerPageState();
}

class _TimerPageState extends State<TimerPage> {
  int _seconds = 0;
  late Timer _timer;

  @override
  void initState() {
    super.initState();
    _timer = Timer.periodic(Duration(seconds: 1), (timer) {
      setState(() {
        _seconds++;
      });
    });
  }

  @override
  void dispose() {
    _timer.cancel(); // WAJIB cancel timer
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Center(child: Text('$_seconds detik'));
  }
}

// pubspec.yaml
dependencies:
  provider: ^6.1.0

import 'package:flutter/foundation.dart';

class CartModel extends ChangeNotifier {
  final List<Map<String, dynamic>> _items = [];

  List<Map<String, dynamic>> get items => _items;
  int get itemCount => _items.length;
  double get totalPrice =>
      _items.fold(0, (sum, item) => sum + (item['price'] * item['qty']));

  void addItem(String name, double price) {
    _items.add({'name': name, 'price': price, 'qty': 1});
    notifyListeners(); // WAJIB untuk trigger rebuild
  }

  void removeItem(int index) {
    _items.removeAt(index);
    notifyListeners();
  }

  void clear() {
    _items.clear();
    notifyListeners();
  }
}

void main() {
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => CartModel()),
        ChangeNotifierProvider(create: (_) => AuthModel()),
      ],
      child: MyApp(),
    ),
  );
}

// Consumer - rebuild hanya widget di dalam builder
Consumer<CartModel>(
  builder: (context, cart, child) {
    return Text('${cart.itemCount} item');
  },
)

// Provider.of - baca tanpa rebuild
final cart = Provider.of<CartModel>(context, listen: false);
cart.addItem('Kaos', 150000);

// context.read - sama dengan listen: false (sekali baca)
context.read<CartModel>().addItem('Kaos', 150000);

// context.watch - rebuild saat berubah
final count = context.watch<CartModel>().itemCount;

// Selector - rebuild hanya saat value tertentu berubah
Selector<CartModel, int>(
  selector: (_, cart) => cart.itemCount,
  builder: (_, count, __) => Text('$count items'),
)

// pubspec.yaml
dependencies:
  http: ^1.2.0

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

// GET - Ambil data
Future<List<dynamic>> getUsers() async {
  final response = await http.get(
    Uri.parse('https://api.example.com/users'),
    headers: {'Authorization': 'Bearer $token'},
  );

  if (response.statusCode == 200) {
    return jsonDecode(response.body);
  } else {
    throw Exception('Gagal memuat data: ${response.statusCode}');
  }
}

// POST - Kirim data
Future<Map<String, dynamic>> createUser(String nama, String email) async {
  final response = await http.post(
    Uri.parse('https://api.example.com/users'),
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $token',
    },
    body: jsonEncode({
      'nama': nama,
      'email': email,
    }),
  );

  if (response.statusCode == 201) {
    return jsonDecode(response.body);
  } else {
    throw Exception('Gagal membuat user');
  }
}

// PUT - Update data
Future<void> updateUser(int id, Map<String, dynamic> data) async {
  final response = await http.put(
    Uri.parse('https://api.example.com/users/$id'),
    headers: {'Content-Type': 'application/json'},
    body: jsonEncode(data),
  );

  if (response.statusCode != 200) {
    throw Exception('Gagal mengupdate user');
  }
}

// DELETE - Hapus data
Future<void> deleteUser(int id) async {
  final response = await http.delete(
    Uri.parse('https://api.example.com/users/$id'),
  );

  if (response.statusCode != 200) {
    throw Exception('Gagal menghapus user');
  }
}

class User {
  final int id;
  final String nama;
  final String email;
  final String? avatar;

  User({
    required this.id,
    required this.nama,
    required this.email,
    this.avatar,
  });

  // Factory constructor dari JSON
  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'] as int,
      nama: json['nama'] as String,
      email: json['email'] as String,
      avatar: json['avatar'] as String?,
    );
  }

  // Convert ke JSON
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'nama': nama,
      'email': email,
      'avatar': avatar,
    };
  }
}

// Menggunakan
void parseData() async {
  // Parse single object
  final response = await http.get(Uri.parse('https://api.example.com/users/1'));
  final jsonData = jsonDecode(response.body);
  final user = User.fromJson(jsonData);

  // Parse list
  final listResponse = await http.get(Uri.parse('https://api.example.com/users'));
  final List<dynamic> jsonList = jsonDecode(listResponse.body);
  final users = jsonList.map((json) => User.fromJson(json)).toList();

  // Convert ke JSON string
  final jsonString = jsonEncode(user.toJson());
  print(jsonString);
}

// pubspec.yaml
dependencies:
  json_annotation: ^4.8.0
dev_dependencies:
  json_serializable: ^6.7.0
  build_runner: ^2.4.0

// user.dart
import 'package:json_annotation/json_annotation.dart';
part 'user.g.dart';

@JsonSerializable()
class User {
  final int id;
  final String nama;
  @JsonKey(name: 'email_address') // Custom key mapping
  final String email;

  User({required this.id, required this.nama, required this.email});

  factory User.fromJson(Map<String, dynamic> json) => _$UserFromJson(json);
  Map<String, dynamic> toJson() => _$UserToJson(this);
}

// Generate: dart run build_runner build

// MediaQuery - dapatkan ukuran layar
double width = MediaQuery.of(context).size.width;
double height = MediaQuery.of(context).size.height;
bool isMobile = width < 600;
bool isTablet = width >= 600 && width < 1200;
bool isDesktop = width >= 1200;

// LayoutBuilder - responsive berdasarkan parent constraints
LayoutBuilder(
  builder: (context, constraints) {
    if (constraints.maxWidth > 600) {
      return _buildWideLayout();
    } else {
      return _buildNarrowLayout();
    }
  },
)

// OrientationBuilder
OrientationBuilder(
  builder: (context, orientation) {
    return orientation == Orientation.portrait
        ? _buildPortrait()
        : _buildLandscape();
  },
)