1. Expo & Core Components
1. Expo & Core Components
Tijdens deze les bouwen we een eenvoudige To-Do applicatie waarin taken toegevoegd kunnen worden en als afgewerkt of niet-afgewerkt gemarkeerd kunnen worden.
De startbestanden voor deze les zijn anders opgebouwd dan bij de frontend-lessen. Omwille van de complexiteit van het project is een deel van de lesinhoud al geïmplementeerd omdat er anders te veel bestanden verplaatst moeten worden binnen het project, wat verwarrend kan zijn.
Startbestanden
Waarschuwing
De code in deze lessen is HEEL gevoelig aan lange, geneste padnamen. Als je op Windows machine werkt, is het ten zeerste aangeraden om je projecten in c:\mobile_dev te plaatsen en geen diepere mappenstructuur te gebruiken.
Het compileren van een applicatie kan tot 20 minuten duren (de eerste keer), als je dan minutenlang moet wachten op uiteindelijk een foutmelding te krijgen ben je heel veel tijd verloren. Begin dus op een pad dat zo dicht mogelijk bij de root van je filesystem ligt en vermijd dit soort problemen.
Expo
Doorheen deze lessenreeks maken we gebruik van Expo, een meta-framework voor React Native waarmee we snel een eenvoudig mobiele applicaties kunnen bouwen.
Het is perfect mogelijk om een React Native applicatie te bouwen zonder Expo, maar dit is aanzienlijk complexer en vereist dat je zelf aanpassingen doet aan het Android en iOS project. Daarnaast is het lastiger om routing werkende te krijgen en om native modules (camera, bluetooth, ...) te gebruiken.
Project aanmaken
Bovenstaande startbestanden bevatten reeds een React Native project waarin ESLint en Prettier geïntegreerd zijn. Ondanks dat de startbestanden reeds een project bevatten, is het wel cruciaal dat je zelf een project kan aanmaken, daarom bespreken we procedure hieronder.
Een project aanmaken kan via onderstaand commando. Voor de configuratie van ESLint en Prettier verwijzen we door naar de appendix.
Vie de --template parameter kunnen we kiezen uit enkele templates. Deze les kiezen we voor de Blank (TypeScript) template, voor de volgende lessen vertrekken we van de Navigation (TypeScript) template.
? Choose a template: » - Use arrow-keys. Return to submit.
Blank
> Blank (TypeScript) - blank app with TypeScript enabled
Navigation (TypeScript)
Blank (Bare)Vervolgens moeten we de naam van de app ingeven, waarna onderstaande uitvoer verschijnt.
✅ Your project is ready!
To run your project, navigate to the directory and run one of the following pnpm commands.
- cd mobile_dev_lecture1_example
- pnpm run android
- pnpm run ios # you need to use macOS to build the iOS project - use the Expo app if you need to do iOS development without a Mac
- pnpm run webAls we onderstaand commando uitvoeren wordt de app gecompileerd.
Vervolgens typen we de letter 'a' in om het project te openen in een Android emulator of 'i' om het project te openen in een iOS emulator. Daarna opent de emulator en wordt Expo Go geïnstalleerd[1] op de emulator. Eens deze installatie gedaan is, wordt Expo Go gebruikt om de applicatie te openen.

Core components
Voordat we de To-Do app uitwerken, kijken we eerste naar de enkele basiscomponenten en hoe we deze een opmaak kunnen geven in React Native. React Native code lijkt natuurlijk heel sterk op de code die we in frontend frameworks geschreven hebben, maar komt niet volledig overeen.
Om dit te illustreren benaderen we applicatie eerst als een normale React applicatie.
const TaskPage: FunctionComponent = () => {
return <div>Een eerste React Native App</div>
}Als we bovenstaande code uitvoeren (via pnpm android), krijgen we onderstaande foutmelding te zien in de console.
De reden voor deze fout is dat je in React Native enkel gebruik kan maken van core components. Door een recente update van Expo kan je hier een uitzondering op maken[2], maar daar gaan we verder niet op in.
Begrip: Core Components
Omdat React Native de UI die in JavaScript geschreven is converteert naar native UI-elementen, is het aantal componenten die door React Native aangeboden worden eerder beperkt. Klassieke HTML tags kunnen niet gebruikt worden.
Elk van de core components is gelinkt aan een vast UI-element in de Android of iOS SDK. Alhoewel de standaard componenten eenvoudig zijn, kunnen deze wel gebruikt worden om complexere en grotere componenten te bouwen.
Het is belangrijk om op te merken dat verschillende cruciale componenten, zoals een checkbox, radio button, ... niet beschikbaar zijn in React Native. Als je deze wilt gebruiken, moet je de component zelf bouwen, of gebruikmaken van een community library.
View & Text Components
De View component is de basis bouwsteen die je voor alle andere componenten moet gebruiken. Het ingangspunt van elke applicatie moet een View zijn.
Deze component is vergelijkbaar met een <div> en kan dan ook, net zoals een <div>, nul, één of meerdere kinderen bevatten. Daarnaast komt ook de styling overeen met een <div>, een View is dus een container zonder opmaak die standaard de volledige breedte van een scherm in beslag neemt.
De Text component dient, zoals de naam doet vermoeden, om tekst weer te geven.
Deze component is vergelijkbaar met een paragraph (<p>) in HTML, er zijn wel enkele belangrijke verschillen. Text componenten kunnen genest worden, terwijl dat voor een <p> tag verboden is. Verder kan een Text component een newline bevatten, de '\n' literal produceert een linebreak in de resulterende app.
Via deze twee componenten kunnen we bovenstaande code omvormen naar iets dat wel door React Native gecompileerd kan worden.
import {Text, View} from 'react-native'
const TaskPage: FunctionComponent = () => {
return (
<View>
<Text>Een eerste React Native App</Text>
</View>
)
}Alhoewel de app nu compileert, zijn er duidelijk nog visuele problemen. De tekst staat onder de statusbalk en is dus niet leesbaar.

SafeAreaView
Een smartphone bevat verschillende elementen die de content van een applicatie kunnen overlappen. Denk hierbij aan een notch, een afgerond scherm, een home button, ... Het is vanzelfsprekend dat de applicatie niet onder deze elementen mag staan, om dit probleem op te lossen kunnen we gebruik maken van de safe-area-context library.
Merk op dat we pnpx expo gebruiken om de library te installeren, dit garandeert dat de versie van react-native-safe-area-context die geïnstalleerd wordt compatibel is met de versie van Expo die we gebruiken.
De library bevat twee componenten, SafeAreaProvider zorgt ervoor dat de SafeAreaView[3] component werkt. Deze laatste component voeg automatisch marge toe aan de randen van de view zodat er geen overlap is met hardware-elementen.
Info
Als onderstaande code geen zichtbaar resultaat geeft, kan je de cache leegmaken met onderstaand commando:
import {Text} from 'react-native'
import {SafeAreaProvider, SafeAreaView} from 'react-native-safe-area-context'
const TaskPage: FunctionComponent = () => {
return (
<SafeAreaProvider>
<SafeAreaView>
<Text>Een eerste React Native App</Text>
</SafeAreaView>
</SafeAreaProvider>
)
}
Theming
De app ziet er nog heel basic uit, het is altijd interessanter als een app een eigen thema heeft. React Native ondersteunt een subset van CSS met enkele kleine verschillen.
Begrip: Styling in React Native
Om de opmaak van een React Native applicatie te implementeren wordt iets gebruikt dat op CSS lijkt, maar niet helemaal overeen komt. Er zijn enkele belangrijke verschillen tussen CSS en React Native styling.
- Id's, klassen en andere CSS-selectors kunnen niet gebruikt worden
- Lay-out gebeurt uitsluitend met flexbox. Er zijn wel enkele verschillen met CSS-flexbox.
- flexDirection heeft column als default
- alignContent heeft flex-start als default
- flexShrink heeft 0 als default
- flex kan slechts een waarde krijgen, een getal.
- Er zijn twee mogelijke eenheden rem, em, px, ... worden niet gebruikt.
- Als de hoogte en/of breedte zonder eenheid (en als integer) genoteerd wordt, verwijst dit naar density-independent pixels.
- Als de hoogte en/of breedte als '%' genoteerd wordt, verwijst dit naar procentuele afmetingen.
- Een View component moet een vaste hoogte of breedte hebben of moet de regel flex: krijgen waarbij een integer groter dan of gelijk aan is. Als dit niet het geval is, zijn de kinderen niet zichtbaar.
- Er is GEEN overerving van View naar Tekst, dit betekent dat dingen als tekst kleur voor elke Text component individueel aangepast moet worden. Behalve als de Text component in een andere Text component genest is.
Opmaak wordt gedefinieerd via de StyleSheet namespace en wordt volledig in JavaScript genoteerd.
import {View, Text, StyleSheet} from 'react-native'
import {FunctionComponent} from 'react'
import {StatusBar} from 'expo-status-bar'
const Foo: FunctionComponent = () => {
return (
<View style={styles.container}>
<Text style={[styles.textStyle, styles.strikeThrough]}>
Je kan één of meer stijlen toekennen aan een component.
De laatste stijl heeft voorrang.
De kleur van deze tekst is dus rood.
</Text>
<StatusBar style="auto" />
</View>
)
}
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: '#282c34',
alignItems: 'center',
justifyContent: 'center',
},
textStyle: {
color: '#fff',
fontSize: 18,
},
strikeThrough: {
color: 'red',
textDecorationLine: 'line-through',
},
})Zelf styling schrijven is relatief veel werk, zeker als je dit goed wilt doen. Daarom maken we in het vervolg van de cursus gebruik van Expo UI.
Expo UI
Expo UI is een bibliotheek van UI-componenten die onderliggend gemapped worden naar SwiftUI en Jetpack Compose voor respectievelijk iOS en Android.
Apps die gebouwd zijn met Expo UI zien er dus uit als een native app en hebben dezelfde look-and-feel als andere apps op het toestel. Dit is ideaal om snel apps te bouwen, maar minder geschikt als je een app wilt bouwen die er op alle toestellen hetzelfde uitziet.
Expo UI bevat drie verschillende sets van componenten, de universal, iOS en Android componenten. Zoals de naam door vermoeden werken de universal componenten op alle toestellen, de iOS en Android componenten zijn enkel beschikbaar op respectievelijk iOS en Android toestellen. Gebruik dus zo veel mogelijk de universal componenten die geïmporteerd worden uit @expo/ui.
Elke component uit @expo/ui moet genest worden in een Host. Als je ergens terug wisselt naar een core component, zoals een View of Text, moet je de kinderen daarvan terug in een Host component plaatsen (als je deze kinderen Expo UI componenten zijn).
Merk op dat we de SafeAreaView en Host component op flex: 1 moeten zetten zodat deze de volledige hoogte van het scherm innemen. Verder gebruiken we een Column component gebruiken om een verticale layout te bouwen.
import {Host, Text, Column} from '@expo/ui'
const TaskPage: FunctionComponent = () => {
return (
<SafeAreaProvider>
<SafeAreaView>
<Host style={ {flex: 1}}>
<Column>
<Text>Een eerste React Native App</Text>
</Column>
</Host>
</SafeAreaView>
</SafeAreaProvider>
)
}Dark & Light mode
Expo UI past zicht automatisch aan aan het gekozen OS-thema. Hiervoor moeten we echter de userInterfaceStyle property in app.json op automatic zetten, anders is het theme hardgecodeerd op light.
{
"expo": {
"name": "mobile_dev_lecture1_example",
"slug": "mobile_dev_lecture1_example",
"version": "1.0.0",
"orientation": "portrait",
"icon": "./assets/icon.png",
"userInterfaceStyle": "automatic",
"newArchEnabled": true,
"splash": {
"image": "./assets/splash.png",
"resizeMode": "contain",
"backgroundColor": "#ffffff"
},
"ios": {
"supportsTablet": true
},
"android": {
"adaptiveIcon": {
"foregroundImage": "./assets/adaptive-icon.png",
"backgroundColor": "#ffffff"
}
},
"web": {
"favicon": "./assets/favicon.png"
}
}
}Na deze aanpassing kunnen we de applicatie is dark mode bekijken door het OS-thema op dark te zetten.

Zoals te zien, is de dark mode nog niet volledig correct. Dit komt doordat de SafeAreaView en SafeAreaProvider componenten geen Expo UI componenten zijn, maar gewone React Native View componenten.
Om dit probleem op te lossen schrijven we een hook die de achtergrondkleur van het besturingsysteem ophaalt en deze gebruikt om de SafeAreaView en SafeAreaProvider componenten te stylen.
Begrip: Platform-specifieke code
De React Native compiler heeft ondersteuning voor platform-specifieke code. Door de android of ios extensie toe te voegen aan een bestand, zal de compiler enkel dat bestand gebruiken bij het bouwen van de applicatie voor dat platform.
foo.android.tsx
foo.ios.tsx
foo.web.tsx
foo.tsxEen bestand zonder extensie wordt gebruikt als fallback voor alle platformen waarvoor geen specifieke code voorzien is.
Notitie
Gebruik in imports steeds het bestand zonder platform-specifieke extensie, de compiler zal automatisch het juiste bestand kiezen.
Via de useMaterialColors hook kunnen we de Android themakleuren uitlezen uit het besturingssysteem. Aangezien we in deze cursus focussen op Android apps, laten we de code voor iOS en web buiten beschouwing.
Merk op dat we ook flex: 1 moeten toevoegen zodat de SafeAreaView component de volledige hoogte van het scherm inneemt.
import {useMaterialColors} from '@expo/ui/jetpack-compose'
import type {ColorValue} from 'react-native'
function useBackgroundColor(): ColorValue {
return useMaterialColors().surface
}
export default useBackgroundColorimport useBackgroundColor from '../../hooks/useBackgroundColor'
const TaskPage: FunctionComponent = () => {
const backgroundColor = useBackgroundColor()
return (
<SafeAreaProvider>
<SafeAreaView style={ {backgroundColor: backgroundColor, flex: 1}}>
<Host style={ {flex: 1}}>
<Column>
<Text>Een eerste React Native App</Text>
</Column>
</Host>
</SafeAreaView>
</SafeAreaProvider>
)
}
Voordat we verder gaan, is het interessant om eerste de code in de TaskPage te herschrijven. Ook al hebben we maar één CSS-regels gekoppeld aan de View component, is het nog steeds properder om deze code af te zonderen. We kunnen geen klassieke CSS gebruiken, maar moeten de StyleSheet klasse gebruiken. Op deze manier wordt de code afgezonderd en wordt het object met styling niet in elke re-render opnieuw aangemaakt.
De klassen die we definiëren in het stylesheet kunnen meegegeven worden aan de style eigenschap van een core-component. We kunnen, via deze property, één stylesheet toekennen, of een array met meerdere stylesheet of objecten. Net zoals in CSS, is het mogelijk om dingen te overschrijven, het laatste element in de array heeft steeds voorrang.
De dynamische delen van de CSS, e.g. de achtergrondkleur, kunnen niet in de styles variable, daarom gebruiken we voor deze properties inline styles.
import {StyleSheet} from 'react-native'
const TaskPage: FunctionComponent = () => {
const backgroundColor = useBackgroundColor()
return (
<SafeAreaProvider>
<SafeAreaView style={[styles.container, {backgroundColor}]}>
<Host style={styles.container}>
<Column>
<Text>Een eerste React Native App</Text>
</Column>
</Host>
</SafeAreaView>
</SafeAreaProvider>
)
}
const styles = StyleSheet.create({
container: {
flex: 1,
},
})Row & Column
Via de Row en Column componenten uit Expo UI kunnen we de respectievelijk horizontale en verticale layouts schrijven.
We gebruiken deze componenten om de Header component verder uit te werken, zodat we een titel en een knop kunnen tonen.
De globalStyles variable die hieronder gebruiker wordt is een stylesheet met algemene styling uit de startbestanden. De Spacer component wordt gebruikt om de kinderen van een Row of Column component uit elkaar te duwen.
import {Host, Row, Spacer, Text} from '@expo/ui'
const Header: FunctionComponent<HeaderProps> = ({title, children}) => {
return (
<Row alignment="center" style={styles.header}>
<Text textStyle={globalStyles.titleH1}>{title}</Text>
<Spacer flexible />
{children}
</Row>
)
}const TaskPage: FunctionComponent = () => {
const backgroundColor = useBackgroundColor()
return (
<SafeAreaProvider>
<SafeAreaView style={[styles.container, {backgroundColor}]}>
<Host style={styles.container}>
<Column>
<Header title="Tasks"></Header>
</Column>
</Host>
</SafeAreaView>
</SafeAreaProvider>
)
}
Iconen
Om de header component af te werken, moeten we nog een klikbaar icoon toevoegen waarmee we een nieuwe taak kunnen aanmaken. Aangezien Expo UI gebruik maakt van SwiftUI en Jetpack Compose, gebruiken we ook de iconen die beschikbaar zijn in deze frameworks. Dit zijn respectievelijk SF Symbols en Material Symbols.[4]
Om deze iconen te gebruiken in React Native moet nog een extra library geïnstalleerd worden:
Aangezien we afhankelijk van het platform een ander icoon willen gebruiken, laten we Expo automatisch het juiste icoon selecteren op basis van het platform.
De startbestanden bevatten reeds de nodige iconen. We kunnen deze iconen combineren met de Button component om de CreateTaskSheet component uit de startbestanden te openen die gebouwd is bovenop de BottomSheet component uit Expo UI.
import {Icon} from '@expo/ui'
export const AddIcon = Icon.select({
ios: 'plus',
android: import('@expo/material-symbols/add.xml'),
})
export const CompletedIcon = Icon.select({
ios: 'checkmark.circle.fill',
android: import('@expo/material-symbols/check_circle.xml'),
})
export const OpenIcon = Icon.select({
ios: 'circle',
android: import('@expo/material-symbols/radio_button_unchecked.xml'),
})import {Button, Host, Icon, Column} from '@expo/ui'
import {AddIcon} from '../../utils/icons'
import CreateTaskSheet from './createTaskModal'
const TaskPage: FunctionComponent = () => {
const backgroundColor = useBackgroundColor()
const [showTaskSheet, setShowTaskSheet] = useState<boolean>(false)
return (
<SafeAreaProvider>
<SafeAreaView style={[styles.container, {backgroundColor}]}>
<Host style={styles.container}>
<Column>
<Header title="Tasks">
<Button variant="text" onPress={() => setShowTaskSheet(true)}>
<Icon name={AddIcon} size={28} />
</Button>
</Header>
</Column>
</Host>
</SafeAreaView>
<CreateTaskSheet isVisible={showTaskSheet} onClose={() => setShowTaskSheet(false)} />
</SafeAreaProvider>
)
}MMKV
De useTasks hook die al beschikbaar is in de startbestanden, wordt gebruikt om taken te bewaren, updaten en verwijderen. We hebben echter nog geen persistentie voorzien, hiervoor gebruiken we MMKV.
Begrip: MMKV
MMKV is een zeer snelle (en kleine) key-value storage library ontwikkeld door het Chinese WeChat. Deze library presteert in benchmarks aanzienlijk beter de SharedPreferences en UserDefaults, die respectievelijk voorzien worden door Android en iOS.
MMKV kan gebruikt worden om kleine, niet relationele, data te bewaren of om het resultaat van een HTTP request lokaal te cachen. Via de react-native-mmkv library kan MMKV gebruikt worden in een React Native applicatie.
Via de useMMKV... hooks kunnen we (een stuk van) een object of een primitieve waarde bewaren.
const Foo: FuctionComponent = () => {
const [someString, setSomeString] = useMKKVString('sleutel1')
const [someBoolean, setSomeBoolean] = useMKKVBoolean('sleutel2')
const [someNumber, setSomeNumber] = useMKKVNumber('sleutel3')
const [someObject, setSomeObject] = useMKKVObject<T>('sleutel4')
return <> {/* JSX-Code */} </>
}Naast MMKV installeren we ook de expo-crypto library om een UUID te generen voor elke nieuwe taak.
MMKV is niet bedoeld voor grote en complexe read-operaties, daarom is deze library synchroon. Je zoek dus beter naar een andere oplossing als je complexere queries wilt uitvoeren of met grotere data wilt werken. Maar langs de andere kant betekent dit dat het niet nodig is om TanStack Query te gebruiken. We kunnen dus een eenvoudige hook schrijven die de taken uitleest, CRUD methodes voorziet en eventueel demo taken aanmaakt.
De code voor deze hook is grotendeels gegeven, we moeten de useState hook enkel vervangen met de useMMKVObject hook.
import {randomUUID} from 'expo-crypto'
import {useEffect, useEffectEvent} from 'react'
import {useMMKVObject} from 'react-native-mmkv'
import type ITask from '../models/ITask'
type useTaskReturnValue = {
tasks: ITask[]
createTask: (name: string) => void
toggleTaskStatus: (id: string) => void
}
const useTasks = (key: string = 'tasks'): useTaskReturnValue => {
const [tasks, setTasks] = useMMKVObject<ITask[]>(key)
const generateTasks = useEffectEvent(() => {
const demoTasks: ITask[] = []
for (let i = 1; i <= 20; i++) {
demoTasks.push({
name: `Task ${i}`,
id: randomUUID(),
completed: i % 2 === 0,
})
}
setTasks(demoTasks)
})
useEffect(() => {
if (tasks === undefined || tasks.length === 0) {
generateTasks()
}
}, [tasks])
const createTask = (name: string) => {
setTasks([
...(tasks ?? []),
{
name,
completed: false,
id: randomUUID(),
},
])
}
const toggleTaskStatus = (id: string) => {
// We maken een nieuwe array met een nieuw object voor de aangepaste taak.
// De native lijst (List.ForEach) detecteert wijzigingen enkel als er een nieuwe array doorgegeven wordt.
setTasks((tasks ?? []).map(t => (t.id === id ? {...t, completed: !t.completed} : t)))
}
return {
tasks: tasks ?? [],
createTask,
toggleTaskStatus,
}
}
export default useTasksTenslotte kunnen we deze hook dan gebruiken in de ToDoList component die gerenderd wordt als kind van de TaskPage. In ToDoList tonen we elke taak via een ToDoItem component. Zowel de ToDoList als ToDoItem component zijn beschikbaar in de startbestanden.
const TaskPage: FunctionComponent = () => {
const [showTaskSheet, setShowTaskSheet] = useState<boolean>(false)
const backgroundColor = useBackgroundColor()
return (
<SafeAreaProvider>
<SafeAreaView style={[styles.container, {backgroundColor}]}>
<Host style={styles.container}>
<Column>
<Header title="Tasks">
<Button variant="text" onPress={() => setShowTaskSheet(true)}>
<Icon name={AddIcon} size={28} />
</Button>
</Header>
<ToDoList />
</Column>
</Host>
</SafeAreaView>
<CreateTaskSheet isVisible={showTaskSheet} onClose={() => setShowTaskSheet(false)} />
</SafeAreaProvider>
)
}const ToDoList: FunctionComponent = () => {
const {tasks} = useTasks()
return (
<>
{tasks.map(task => (
<ToDoItem {...task} key={task.id} />
))}
</>
)
}
export default ToDoListZodra we deze code uitvoeren, zien we dat Metro (de bundler) een foutmelding uitprint.
Om dit probleem op te lossen, moeten we een native Android code generen en deze lokaal compileren. Via onderstaand commando wordt de Android code gegenereerd (en iOS code als je op macOS werkt).
Nadat we dit commando uitvoeren, krijgen we de vraag om het package name in te geven (of wordt dit automatisch gegenereerd en in app.json toegevoegd).
Begrip: Package name
Het package id van je app is een wereldwijd unieke naam die gebruikt wordt om te bepalen of een app al geïnstalleerd is op een toestel en voor een hele reeks andere doeleinden.
Het package id moet in reverse domain name notation formaat genoteerd worden. Als je een app bouwt met als doel deze te publiceren, in plaats van om te leren, is het natuurlijk belangrijk dat je hiervoor een domeinnaam gebruikt die je effectief bezit. Domeinnamen zijn uniek en twee apps zullen dus nooit als "dezelfde app" beschouwd worden.
Expo bewaart de package name in app.json, je kan de naam altijd aanpassen in deze file.
Notitie
Gebruik tijdens deze cursus een appId van de vorm com.achternaam.voornaam.appnaam. De apps die als voorbeeld aangeboden worden krijgen steeds een id van de vorm be.pitgraduaten.appnaam.
Na deze aanpassingen kunnen we het project opnieuw compileren, maar dit keer met een ander commando dat de native code compileert in de plaats van Expo Go te gebruiken.
Het compilatieproces kan relatief lang duren, zeker de eerste keer.
Waarschuwing
Gebruik vanaf nu steeds pnpm android om de applicatie te compileren, anders zal de applicatie niet werken.
ScrollView & List
De applicatie start nu wel op, maar het is nog niet mogelijk om door de taken te scrollen.
ScrollView
Het probleem is dat een React Native UI niet automatisch doorgroeit met de inhoud zoals op een website. Ook de Column component uit Expo UI groeit niet automatisch mee met de inhoud, maar neemt enkel de hoogte in van de kinderen die op het scherm getoond worden. Om dit probleem op te lossen moeten we de ToDoList componenten wrappen in een ScrollView.
import {ScrollView} from '@expo/ui'
const ToDoList: FunctionComponent = () => {
const {tasks} = useTasks()
return (
<ScrollView>
{tasks.map(task => <ToDoItem {...task} key={task.id}/>)}
</ScrollView>
)
}Na deze aanpassing worden de taken correct getoond.
Performante lijsten
Alhoewel de taken nu wel zichtbaar zijn, is de code niet optimaal. De ScrollView component gebruik je best enkel voor content die niet in een lijst weergegeven kan worden, dingen zoals een lange post op een social media platform. Voor content die volledig in een lijst weergegeven kan worden gebruik je best een list component.
We gebruiken de List component uit Expo UI om de taken te renderen. Deze component creëert een virtualized list, dit is een lijst die enkel de items rendert die op het scherm getoond worden in plaats van alle items in de lijst te renderen. Omdat er slechts een beperkt aantal items op het scherm getoond worden, is dit veel performanter dan een ScrollView.
De List.ForEach component moet als kind van de List component gebruikt worden om de taken te renderen. Via de data property wordt de lijst van taken doorgegeven, via de keyExtractor property wordt een unieke key per taak opgegeven (deze key heeft hetzelfde doel als de key property in React).
Het kind van de List.ForEach component is een functie die een object met de property item afbeeld op een component. De waarde van de item property is telkens één taak uit de lijst van taken.
We herschrijven de inhoud van de ToDoItem component zodat deze gebruik maakt van de ListItem component uit Expo UI.
import {List} from '@expo/ui'
const ToDoList: FunctionComponent = () => {
const {tasks} = useTasks()
return (
<List>
<List.ForEach data={tasks} keyExtractor={task => task.id}>
{({item: task}) => <ToDoItem {...task} key={task.id} />}
</List.ForEach>
</List>
)
}import {Icon, ListItem} from '@expo/ui'
const ToDoItem: FunctionComponent<ITask> = ({name, id, completed}) => {
const {toggleTaskStatus} = useTasks()
return (
<ListItem
trailing={
<Icon
onPress={() => toggleTaskStatus(id)}
name={completed ? CompletedIcon : OpenIcon}
size={28}
color={completed ? 'green' : 'gray'}
accessibilityLabel={completed ? 'Completed' : 'Open'}
/>
}
>
<ListItem.Supporting>{completed ? 'Completed' : 'Open'}</ListItem.Supporting>
{name}
</ListItem>
)
}nativeState
Nu dat de taken zichtbaar zijn en we er op performante wijze doorheen kunnen scrollen, is het tijd om een nieuwe taak toe te voegen. Bijna alle code hiervoor is reeds geschreven in de CreateTaskSheet component.
Alhoewel de CreateTaskSheet component grotendeels af is, is er nog een probleem met de TextInput component. Tot nu hebben we steeds gebruik gemaakt van de useState hook om formuliervelden te bouwen, hier is echter één groot probleem mee. Een update aan de state zorgt voor een re-render van de component, wat een performantieprobleem kan zijn.
Om dit probleem op te lossen, gebruiken we de useNativeState hook. Deze hook maakt state aan die gedeeld wordt met de native view, waardoor een update van de waarde geen re-render van de component triggert, maar enkel een aanpassing in de native view. Doordat de React render cyclus niet getriggerd wordt, is dit een performantere oplossing.
Notitie
Gebruik deze hook enkel voor componenten die hier expliciet voor gemaakt zijn, zoals de TextInput component uit Expo UI.
Merk op dat we geen onChange property moeten meegeven, dit wordt automatisch afgehandeld.
Merk ook op dat we een nieuwe Host component moeten toevoegen rond de BottomSheet component. Zoals eerder besproken, moet elke component uit Expo UI genest worden in een Host component, omdat de BottomSheet component in een portal boven de rest van de applicatie getoond wordt, moet deze een eigen Host component hebben.
import {BottomSheet, Button, Column, Host, Row, Spacer, Text, TextInput, useNativeState} from '@expo/ui'
const CreateTaskSheet: FunctionComponent<CreateTaskSheetProps> = ({isVisible, onClose}) => {
const taskName = useNativeState('')
const {createTask} = useTasks()
const close = () => {
taskName.set('')
onClose()
}
const _createTask = () => {
const name = taskName.value.trim()
if (name.length > 0) {
createTask(name)
}
close()
}
return (
<Host style={StyleSheet.absoluteFill} pointerEvents="none">
<BottomSheet isPresented={isVisible} onDismiss={close} contentPadding={styles.bottomSheetPadding}>
<Column spacing={16} style={ {width: '100%'}}>
<Text textStyle={globalStyles.titleH2}>New Task</Text>
<TextInput
value={taskName}
placeholder="New task name"
autoFocus
returnKeyType="done"
onSubmitEditing={_createTask}
style={styles.input}
/>
<Row spacing={8} style={ {width: '100%'}}>
<Spacer flexible />
<Button label="Cancel" variant="outlined" onPress={close} />
<Button label="OK" onPress={_createTask} />
</Row>
</Column>
</BottomSheet>
</Host>
)
}Voorbeeldcode
Volledig uitgewerkt lesvoorbeeld met commentaar
Als dit niet het geval is, heb je iets fout gedaan tijdens de installatie van de development environment. ↩︎
Met de release van Expo DOM Components is het mogelijk componenten te maken met HTML code. LET OP: omdat dit in de achtergrond een WebView proxy component maakt, neemt dit net de kracht van native ontwikkeling weg (zie inleiding). Het is echter een handige tool om incrementeel een bestaande website om te zetten naar een app, of om enkele functionaliteiten uit te proberen voor je er veel tijd in stopt door ze native te maken. Je kan de volledige uitleg vinden op Expo DOM Components. ↩︎
Let op, React Native bevat ook een SafeAreaView component, maar deze werkt enkel op iOS. ↩︎