Fondasi

BAB 4: Aplikasi Pertama

Membangun aplikasi catatan dari nol: daftar, formulir tambah, penyimpanan lokal, dan 2 layar dengan Expo Router, ditutup dengan uji di perangkat.

Bab ini membangun aplikasi yang dipakai sehari-hari: daftar catatan dengan formulir tambah, penyimpanan yang bertahan setelah aplikasi ditutup, dan kemampuan menghapus catatan.

Ruang lingkupnya sengaja kecil. Tujuannya bukan menyelesaikan sebuah produk, tapi melewati satu siklus penuh: menampilkan daftar, menerima input, menyimpan, membaca ulang, dan menghapus. Pola inilah yang akan diulang di hampir semua layar aplikasi lain.

Rencana aplikasi

BagianIsi
Layar daftarmenampilkan semua catatan, tombol tambah, keadaan kosong
Layar tambahjudul dan isi catatan, validasi, tombol simpan
Penyimpanansatu kunci AsyncStorage berisi array catatan
Interaksitambah, hapus dengan konfirmasi, urut dari yang terbaru

Struktur berkas yang dipakai:

CodeCODE
catatan-harian/
  app/
    _layout.tsx        kerangka navigasi
    index.tsx          layar daftar
    tambah.tsx         layar formulir
  components/
    ItemCatatan.tsx    satu baris catatan
    KeadaanKosong.tsx  tampilan saat belum ada catatan
  hooks/
    useCatatan.ts      baca, tambah, hapus, dan simpan
  lib/
    penyimpanan.ts     pembungkus AsyncStorage
  types.ts             tipe Catatan

Tipe data lebih dulu

Menulis tipe di awal membuat kesalahan terlihat sebelum aplikasi dijalankan.

TypeScriptTS
// types.ts
export type Catatan = {
  id: string;
  judul: string;
  isi: string;
  dibuatPada: string;
};

id memakai string, bukan angka berurutan. Angka berurutan bermasalah ketika data dihapus dan ditambah lagi, karena 2 catatan bisa mendapat nomor yang sama.

Lapisan penyimpanan

AsyncStorage menyimpan teks dengan kunci. Karena hanya bisa menyimpan string, objek harus diubah ke JSON dan sebaliknya.

TypeScriptTS
// lib/penyimpanan.ts
import AsyncStorage from "@react-native-async-storage/async-storage";
import type { Catatan } from "../types";

const KUNCI = "catatan:v1";

export async function bacaSemua(): Promise<Catatan[]> {
  const mentah = await AsyncStorage.getItem(KUNCI);
  if (!mentah) return [];

  try {
    const data = JSON.parse(mentah);
    return Array.isArray(data) ? data : [];
  } catch {
    return [];
  }
}

export async function tulisSemua(daftar: Catatan[]): Promise<void> {
  await AsyncStorage.setItem(KUNCI, JSON.stringify(daftar));
}

Perhatikan 2 hal. Pertama, kunci diberi akhiran versi v1, supaya bentuk data bisa berubah di versi berikutnya tanpa merusak data lama. Kedua, JSON.parse dibungkus try, karena data yang rusak harus menghasilkan daftar kosong, bukan aplikasi yang berhenti.

Satu hook untuk seluruh logika data

Layar tidak perlu tahu bagaimana data disimpan. Semua logika ditempatkan di satu hook.

TypeScriptTS
// hooks/useCatatan.ts
import { useCallback, useEffect, useState } from "react";
import { bacaSemua, tulisSemua } from "../lib/penyimpanan";
import type { Catatan } from "../types";

export function useCatatan() {
  const [daftar, setDaftar] = useState<Catatan[]>([]);
  const [memuat, setMemuat] = useState(true);

  useEffect(() => {
    let aktif = true;
    bacaSemua()
      .then((data) => {
        if (aktif) setDaftar(data);
      })
      .finally(() => {
        if (aktif) setMemuat(false);
      });
    return () => {
      aktif = false;
    };
  }, []);

  const tambah = useCallback(async (judul: string, isi: string) => {
    const baru: Catatan = {
      id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
      judul: judul.trim(),
      isi: isi.trim(),
      dibuatPada: new Date().toISOString(),
    };
    const berikutnya = [baru, ...daftar];
    setDaftar(berikutnya);
    await tulisSemua(berikutnya);
    return baru;
  }, [daftar]);

  const hapus = useCallback(async (id: string) => {
    const berikutnya = daftar.filter((item) => item.id !== id);
    setDaftar(berikutnya);
    await tulisSemua(berikutnya);
  }, [daftar]);

  return { daftar, memuat, tambah, hapus };
}

Variabel aktif mencegah pembaruan state setelah komponen dilepas. Tanpa itu, React akan memberi peringatan ketika pengguna berpindah layar sebelum pembacaan selesai.

Kerangka navigasi

Expo Router memakai berkas sebagai rute. app/_layout.tsx menentukan kerangka yang membungkus semua layar.

React TSXTSX
// app/_layout.tsx
import { Stack } from "expo-router";
import { SafeAreaProvider } from "react-native-safe-area-context";

export default function Kerangka() {
  return (
    <SafeAreaProvider>
      <Stack screenOptions={{ headerTitleAlign: "center" }}>
        <Stack.Screen name="index" options={{ title: "Catatan" }} />
        <Stack.Screen name="tambah" options={{ title: "Catatan Baru", presentation: "modal" }} />
      </Stack>
    </SafeAreaProvider>
  );
}

Nama berkas menjadi nama rute. index.tsx adalah layar pertama, dan tambah.tsx dibuka dengan router.push("/tambah"). Pilihan presentation: "modal" membuat layar formulir muncul dari bawah, sesuai kebiasaan aplikasi mobile.

Layar daftar

React TSXTSX
// app/index.tsx
import { router } from "expo-router";
import { ActivityIndicator, Alert, FlatList, Pressable, StyleSheet, Text, View } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";
import { ItemCatatan } from "../components/ItemCatatan";
import { KeadaanKosong } from "../components/KeadaanKosong";
import { useCatatan } from "../hooks/useCatatan";

export default function DaftarCatatan() {
  const { daftar, memuat, hapus } = useCatatan();
  const inset = useSafeAreaInsets();

  const konfirmasiHapus = (id: string, judul: string) => {
    Alert.alert("Hapus catatan", `"${judul}" akan dihapus permanen.`, [
      { text: "Batal", style: "cancel" },
      { text: "Hapus", style: "destructive", onPress: () => hapus(id) },
    ]);
  };

  if (memuat) {
    return (
      <View style={gaya.tengah}>
        <ActivityIndicator size="large" />
      </View>
    );
  }

  return (
    <View style={gaya.wadah}>
      <FlatList
        data={daftar}
        keyExtractor={(item) => item.id}
        contentContainerStyle={{ padding: 16, paddingBottom: 96 + inset.bottom }}
        ListEmptyComponent={<KeadaanKosong />}
        renderItem={({ item }) => (
          <ItemCatatan catatan={item} onHapus={() => konfirmasiHapus(item.id, item.judul)} />
        )}
      />

      <Pressable
        style={[gaya.tombolTambah, { bottom: 24 + inset.bottom }]}
        onPress={() => router.push("/tambah")}
        accessibilityRole="button"
        accessibilityLabel="Tambah catatan"
      >
        <Text style={gaya.teksTambah}>Catatan baru</Text>
      </Pressable>
    </View>
  );
}

const gaya = StyleSheet.create({
  wadah: { flex: 1 },
  tengah: { flex: 1, alignItems: "center", justifyContent: "center" },
  tombolTambah: {
    position: "absolute",
    left: 16,
    right: 16,
    backgroundColor: "#6366f1",
    paddingVertical: 16,
    borderRadius: 14,
    alignItems: "center",
  },
  teksTambah: { color: "#ffffff", fontSize: 16, fontWeight: "600" },
});

3 keputusan di kode itu layak diperhatikan.

FlatList dipakai, bukan map, karena hanya item yang terlihat yang dirender. Untuk daftar pendek hasilnya sama, tapi kebiasaan ini mencegah masalah ketika daftar tumbuh.

keyExtractor memakai item.id yang unik dan stabil. Memakai indeks array sebagai kunci menyebabkan baris yang salah ikut terhapus saat daftar berubah.

Batas bawah daftar dan posisi tombol memakai inset.bottom, sehingga tidak tertutup indikator gestur di perangkat mana pun.

Komponen baris dan keadaan kosong

React TSXTSX
// components/ItemCatatan.tsx
import { Pressable, StyleSheet, Text, View } from "react-native";
import type { Catatan } from "../types";

type Props = { catatan: Catatan; onHapus: () => void };

export function ItemCatatan({ catatan, onHapus }: Props) {
  const tanggal = new Date(catatan.dibuatPada).toLocaleDateString("id-ID", {
    day: "numeric",
    month: "short",
    year: "numeric",
  });

  return (
    <View style={gaya.kartu}>
      <View style={{ flex: 1 }}>
        <Text style={gaya.judul} numberOfLines={1}>{catatan.judul}</Text>
        <Text style={gaya.isi} numberOfLines={2}>{catatan.isi}</Text>
        <Text style={gaya.tanggal}>{tanggal}</Text>
      </View>
      <Pressable onPress={onHapus} hitSlop={12} accessibilityRole="button" accessibilityLabel={`Hapus ${catatan.judul}`}>
        <Text style={gaya.hapus}>Hapus</Text>
      </Pressable>
    </View>
  );
}

const gaya = StyleSheet.create({
  kartu: { flexDirection: "row", gap: 12, backgroundColor: "#ffffff", padding: 14, borderRadius: 12, marginBottom: 10 },
  judul: { fontSize: 16, fontWeight: "600" },
  isi: { fontSize: 14, color: "#475569", marginTop: 2 },
  tanggal: { fontSize: 12, color: "#94a3b8", marginTop: 6 },
  hapus: { fontSize: 13, color: "#dc2626", fontWeight: "600" },
});
React TSXTSX
// components/KeadaanKosong.tsx
import { StyleSheet, Text, View } from "react-native";

export function KeadaanKosong() {
  return (
    <View style={gaya.wadah}>
      <Text style={gaya.judul}>Belum ada catatan</Text>
      <Text style={gaya.teks}>Tekan tombol di bawah untuk menulis catatan pertama.</Text>
    </View>
  );
}

const gaya = StyleSheet.create({
  wadah: { alignItems: "center", paddingVertical: 64, paddingHorizontal: 24 },
  judul: { fontSize: 17, fontWeight: "600", marginBottom: 6 },
  teks: { fontSize: 14, color: "#64748b", textAlign: "center" },
});

Keadaan kosong bukan hiasan. Layar yang kosong tanpa penjelasan membuat pengguna mengira aplikasi gagal memuat data.

Layar formulir

React TSXTSX
// app/tambah.tsx
import { router } from "expo-router";
import { useState } from "react";
import { KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, Text, TextInput, View } from "react-native";
import { useCatatan } from "../hooks/useCatatan";

export default function TambahCatatan() {
  const { tambah } = useCatatan();
  const [judul, setJudul] = useState("");
  const [isi, setIsi] = useState("");
  const [galat, setGalat] = useState<string | null>(null);
  const [menyimpan, setMenyimpan] = useState(false);

  const simpan = async () => {
    if (judul.trim().length < 3) {
      setGalat("Judul minimal 3 karakter.");
      return;
    }
    setGalat(null);
    setMenyimpan(true);
    await tambah(judul, isi);
    setMenyimpan(false);
    router.back();
  };

  return (
    <KeyboardAvoidingView style={{ flex: 1 }} behavior={Platform.OS === "ios" ? "padding" : undefined}>
      <ScrollView contentContainerStyle={gaya.wadah} keyboardShouldPersistTaps="handled">
        <Text style={gaya.label}>Judul</Text>
        <TextInput
          style={gaya.input}
          value={judul}
          onChangeText={setJudul}
          placeholder="Misalnya: rencana minggu ini"
          maxLength={80}
          returnKeyType="next"
        />

        <Text style={gaya.label}>Isi</Text>
        <TextInput
          style={[gaya.input, gaya.inputBesar]}
          value={isi}
          onChangeText={setIsi}
          placeholder="Tulis di sini"
          multiline
          textAlignVertical="top"
        />

        {galat ? <Text style={gaya.galat}>{galat}</Text> : null}

        <Pressable style={[gaya.tombol, menyimpan && { opacity: 0.6 }]} onPress={simpan} disabled={menyimpan}>
          <Text style={gaya.teksTombol}>{menyimpan ? "Menyimpan..." : "Simpan catatan"}</Text>
        </Pressable>
      </ScrollView>
    </KeyboardAvoidingView>
  );
}

const gaya = StyleSheet.create({
  wadah: { padding: 16, gap: 8 },
  label: { fontSize: 14, fontWeight: "600", marginTop: 8 },
  input: { borderWidth: 1, borderColor: "#cbd5e1", borderRadius: 10, padding: 12, fontSize: 15, backgroundColor: "#ffffff" },
  inputBesar: { minHeight: 140 },
  galat: { color: "#dc2626", fontSize: 13, marginTop: 4 },
  tombol: { marginTop: 16, backgroundColor: "#6366f1", paddingVertical: 15, borderRadius: 12, alignItems: "center" },
  teksTombol: { color: "#ffffff", fontWeight: "600", fontSize: 16 },
});

KeyboardAvoidingView mencegah kolom input tertutup papan ketik di iOS. Di Android, penyesuaian biasanya ditangani sistem, jadi behavior dikosongkan.

keyboardShouldPersistTaps="handled" membuat tombol simpan tetap bisa ditekan saat papan ketik terbuka, tanpa perlu menutupnya lebih dulu.

Menguji

Jalankan npx expo start, lalu uji 4 alur ini secara berurutan:

  1. Buka aplikasi pertama kali. Keadaan kosong harus muncul, bukan layar putih.
  2. Tambah catatan dengan judul 2 karakter. Pesan galat harus muncul dan data tidak tersimpan.
  3. Tambah catatan yang valid. Catatan muncul di urutan paling atas.
  4. Tutup aplikasi sepenuhnya, buka lagi. Catatan harus tetap ada.
  5. Hapus satu catatan, batalkan konfirmasi, lalu hapus lagi dan setujui.

Kalau nomor 4 gagal, penyebabnya hampir selalu penulisan yang tidak ditunggu (await) atau kunci yang berbeda antara baca dan tulis. Kalau nomor 5 gagal setelah hapus, biasanya karena keyExtractor memakai indeks, bukan id.

Latihan singkat

  1. Tambahkan penghitung jumlah catatan di judul layar daftar.
  2. Ubah penyimpanan supaya memakai satu kunci per catatan, lalu bandingkan mana yang lebih mudah untuk fitur sunting.
  3. Tambahkan pencarian sederhana dengan TextInput di atas daftar, yang menyaring berdasarkan judul.

Ringkasan

Aplikasi pertama ini memuat pola yang akan dipakai berulang: tipe data yang jelas, lapisan penyimpanan terpisah, hook yang memegang logika, FlatList dengan kunci stabil, formulir terkendali dengan validasi, dan konfirmasi sebelum menghapus.

Bab 5 memperluas bagian antarmuka: layout dengan flexbox, penanganan teks panjang, gambar, dan daftar bertingkat.