Terakhir diperbarui: 26 Oktober 2026

Bahasa Indonesia | English

Tujuan pembelajaran

Setelah menyelesaikan codelab ini, mahasiswa diharapkan mampu:

Persiapan

1. Mengapa Optimasi Performa Penting?

Aplikasi mobile modern harus responsif, hemat baterai, dan berjalan lancar di berbagai spesifikasi perangkat. Performa yang buruk dapat menyebabkan:

2. Pipeline Rendering Flutter

UI Thread (Dart)          Raster Thread (GPU)
+------------------+      +------------------+
|  Build Widget    |      |                  |
|  Layout          | ---> |  Composite       |
|  Paint           |      |  Rasterize       |
+------------------+      +------------------+
      |                          |
      v                          v
  Frame Budget: 16,67 ms (60 FPS) / 8,33 ms (120 FPS)

3. Kategori Optimasi Utama

KategoriFokusTools
CPU/BuildWidget rebuild, layout berlebih, komputasi beratDevTools Performance, Timeline
MemoriLeak, gambar besar, list tidak dibuangDevTools Memory, Heap Snapshot
JaringanRequest berulang, payload besar, tidak ada cacheDevTools Network, Dio Interceptor
GambarResolusi tidak sesuai, format tidak efisienDevTools Memory, cached_network_image

1. Membuka DevTools

# Dari terminal project
flutter run --profile
# Atau
flutter run -d  --profile

# Buka DevTools di browser (otomatis terbuka atau)
# http://127.0.0.1:9100

Catatan: Gunakan mode --profile (bukan --debug atau --release) untuk profiling yang akurat. Mode debug memiliki overhead yang signifikan.

2. Tab Performance (CPU Profiling)

3. Tab Memory (Memory Profiling)

4. Praktik Profiling

  1. Jalankan aplikasi dengan flutter run --profile
  2. Buka DevTools → tab Performance
  3. Klik Record → gunakan aplikasi secara normal (scroll, navigasi, load data)
  4. Klik Stop → analisis frame merah/kuning
  5. Klik frame bermasalah → lihat Flame Chart → identifikasi fungsi paling atas yang lama
  6. Perbaiki kode → ulangi profiling untuk verifikasi

1. Penyebab Rebuild Berlebih

2. Teknik Optimasi

A. Gunakan const Constructor

// Sebelum: rebuild tiap parent rebuild
Widget build(BuildContext context) {
  return Column(
    children: [
      Text('Judul'),           // tidak const
      Icon(Icons.star),        // tidak const
      MyCustomWidget(),        // tidak const
    ],
  );
}

// Sesudah: hanya rebuild jika parameter berubah
Widget build(BuildContext context) {
  return const Column(
    children: [
      Text('Judul'),
      Icon(Icons.star),
      MyCustomWidget(),
    ],
  );
}

B. Ekstrak Widget ke Class Terpisah

// Sebelum: semua di satu build method
class MyPage extends StatelessWidget {
  Widget build(BuildContext context) {
    return Column(
      children: List.generate(100, (i) => Text('Item $i')), // rebuild semua
    );
  }
}

// Sesudah: item terpisah, bisa const
class MyPage extends StatelessWidget {
  Widget build(BuildContext context) {
    return Column(
      children: List.generate(100, (i) => const MyItem()), // hanya MyItem rebuild
    );
  }
}

class MyItem extends StatelessWidget {
  const MyItem();
  Widget build(BuildContext context) => const Text('Item');
}

C. Gunakan RepaintBoundary untuk Isolasi Paint

// Hanya area ini yang di-repaint saat berubah
RepaintBoundary(
  child: ExpensiveWidget(),
)

D. Riverpod: select dan ProviderScope Override

// Hanya rebuild saat value.count berubah, bukan seluruh state
final count = ref.watch(counterProvider.select((s) => s.count));

// Atau gunakan Consumer dengan builder spesifik
Consumer(
  builder: (context, ref, child) {
    final value = ref.watch(provider);
    return Text('$value');
  },
)

E. Hindari Anonymous Function di Build

// Buruk: closure baru tiap build
onPressed: () => doSomething()

// Baik: method reference atau tear-off
onPressed: doSomething

// Atau gunakan callback yang sudah didefinisikan
onPressed: _handlePress

1. Lazy Loading dengan ListView.builder

ListView.builder hanya membangun item yang terlihat (viewport). Pastikan:

2. Pagination (Infinite Scroll)

class PaginatedList extends ConsumerStatefulWidget {
  const PaginatedList();

  @override
  ConsumerState createState() => _PaginatedListState();
}

class _PaginatedListState extends ConsumerState {
  final _scrollController = ScrollController();
  final _items = [];
  var _page = 1;
  var _isLoading = false;
  var _hasMore = true;

  @override
  void initState() {
    super.initState();
    _scrollController.addListener(_onScroll);
    _loadPage();
  }

  void _onScroll() {
    if (_scrollController.position.pixels >=
        _scrollController.position.maxScrollExtent - 200) {
      _loadPage();
    }
  }

  Future _loadPage() async {
    if (_isLoading || !_hasMore) return;
    _isLoading = true;
    try {
      final newItems = await ref.read(itemRepositoryProvider).fetchPage(_page);
      if (newItems.isEmpty) {
        _hasMore = false;
      } else {
        _items.addAll(newItems);
        _page++;
      }
    } finally {
      _isLoading = false;
      if (mounted) setState(() {});
    }
  }

  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      controller: _scrollController,
      itemCount: _items.length + (_hasMore ? 1 : 0),
      itemBuilder: (context, index) {
        if (index == _items.length) {
          return const Center(child: CircularProgressIndicator());
        }
        return ItemTile(item: _items[index]);
      },
    );
  }
}

3. Optimasi Gambar

TeknikDeskripsiPackage
Resize di serverMinta ukuran yang sesuai (thumbnail), bukan full-resBackend/CDN
Format modernWebP, AVIF lebih kecil dari JPEG/PNGServer/CDN
Cache lokalSimpan gambar ke disk, hindari download ulangcached_network_image
PlaceholderTampilkan blur/low-res dulu, lalu swapfade_in_image, cached_network_image
PrecacheMuat gambar sebelum dibutuhkan (mis. halaman berikutnya)precacheImage
MemcacheBatasi ukuran cache memoriPaintingBinding.instance.imageCache
// Contoh cached_network_image
CachedNetworkImage(
  imageUrl: item.imageUrl,
  placeholder: (context, url) => Shimmer.fromColors(
    baseColor: Colors.grey[300]!,
    highlightColor: Colors.grey[100]!,
    child: Container(color: Colors.white),
  ),
  errorWidget: (context, url, error) => const Icon(Icons.error),
  memCacheWidth: 300,  // decode di ukuran tampil, bukan full-res
  memCacheHeight: 200,
  fadeInDuration: const Duration(milliseconds: 200),
)

1. Strategi Caching

StrategiCocok UntukImplementasi
Cache-FirstData jarang berubah (konfigurasi, master data)Baca cache → jika kosong, fetch API → simpan cache
Network-FirstData kritis real-time (chat, harga, stok)Fetch API → simpan cache → fallback ke cache jika gagal
Stale-While-RevalidateData semi-real-time (feed, daftar)Tampilkan cache → fetch background → update UI
Cache-Only (Offline)Mode offline penuhHanya baca dari local DB (Hive/SQLite/Drift)

2. Implementasi Repository dengan Cache (Stale-While-Revalidate)

class ItemRepository {
  final Dio _dio;
  final Box _localBox; // Hive

  ItemRepository(this._dio, this._localBox);

  Future> getItems() async {
    // 1. Tampilkan cache segera (jika ada)
    final cached = _localBox.values.toList();
    if (cached.isNotEmpty) {
      _emitCached(cached);
    }

    // 2. Fetch fresh data di background
    try {
      final response = await _dio.get('/items');
      final fresh = (response.data as List)
          .map((e) => Item.fromJson(e))
          .toList();

      // 3. Update local cache
      await _localBox.clear();
      await _localBox.addAll(fresh);

      // 4. Emit fresh data
      _emitFresh(fresh);
      return fresh;
    } catch (e) {
      // Jika error dan tidak ada cache, lempar error
      if (cached.isEmpty) rethrow;
      return cached; // Return cache sebagai fallback
    }
  }
}

3. Dio Interceptor untuk Logging dan Retry

final dio = Dio(BaseOptions(
  baseUrl: 'https://api.example.com',
  connectTimeout: const Duration(seconds: 10),
  receiveTimeout: const Duration(seconds: 15),
));

// Retry interceptor
dio.interceptors.add(RetryInterceptor(
  dio: dio,
  logPrint: print,
  retries: 3,
  retryDelays: [
    const Duration(seconds: 1),
    const Duration(seconds: 2),
    const Duration(seconds: 5),
  ],
));

// Cache interceptor (custom)
dio.interceptors.add(CacheInterceptor(
  storage: CacheStorage(),
  policy: CachePolicy.staleWhileRevalidate,
));

4. Kompresi dan Payload Kecil

Langkah 1: Baseline Profiling

  1. Buka project Minggu 7–10 Anda (misalnya campus_notify)
  2. Jalankan flutter run --profile
  3. Buka DevTools → tab Performance → klik Record
  4. Lakukan skenario: buka daftar, scroll cepat, buka detail, kembali, pull-to-refresh
  5. Klik Stop → catat: jumlah frame merah/kuning, rata-rata frame time, top fungsi di Flame Chart
  6. Simpan screenshot Flame Chart sebagai screenshots/before-profile.png

Langkah 2: Identifikasi Masalah

Berdasarkan profiling, identifikasi minimal 3 masalah:

Tulis temuan di docs/performance-findings.md

Langkah 3: Terapkan Optimasi

Pilih dan terapkan minimal 3 optimasi:

  1. Const constructor: Tambah const ke widget statis
  2. Ekstrak widget: Pecah widget besar jadi widget kecil const
  3. RepaintBoundary: Bungkus area yang sering repaint (mis. chart, animasi)
  4. Riverpod select: Ganti ref.watch(provider) jadi ref.watch(provider.select(...))
  5. ListView.builder: Pastikan semua list pakai builder
  6. CachedNetworkImage: Ganti Image.network dengan CachedNetworkImage + memCacheWidth/Height
  7. Pagination: Tambah infinite scroll ke list panjang
  8. Repository cache: Tambah stale-while-revalidate di repository

Langkah 4: Verifikasi Profiling

  1. Jalankan lagi flutter run --profile
  2. Record skenario yang sama
  3. Bandingkan: frame merah/kuning berkurang, frame time rata-rata turun
  4. Simpan screenshot sebagai screenshots/after-profile.png

Langkah 5: Memory Profiling

  1. Buka tab Memory di DevTools
  2. Ambil Heap Snapshot di halaman daftar
  3. Navigasi ke detail → kembali → ulang 5x
  4. Ambil snapshot lagi → bandingkan: apakah ada objek yang menumpuk?
  5. Jika ada leak: cari referensi yang tidak dibuang (controller, listener, stream subscription)
  6. Perbaiki dengan dispose() yang benar

Mini project / Industry Challenge

  1. Optimasi performa project Minggu 7–10 Anda dengan minimal 3 teknik dari codelab ini.
  2. Dokumentasikan di docs/performance-report.md:
    • Baseline metrics (frame time, jank count, memory usage)
    • Temuan dari profiling (screenshot Flame Chart before/after)
    • Optimasi yang diterapkan + alasan pemilihan
    • Hasil verifikasi (metrics after)
  3. Sertakan flutter analyze + flutter test bersih di README.
  4. Push ke 11-week-11-performance-optimization/ berisi lib/, docs/, README.md, screenshots/.

Refleksi

Referensi pendukung