Bye Bye Prof

Projet Température2

Explication du projet

Le projet consiste à créer une application multiplateforme de type convertiseur de température (farenheit à celsius) avec la particularité suivante:

Si la température est plus basse que le point de congélation de l'eau (0 degré celcius), une image de glacon (cold.png) sera affichée.

Si la température est plus haute que le point de congélation (supérieur à 0 degré celcius), une image de soleil (hot.png) sera affichée.

Exemple avec l'image hot.png

Étape 1: Création du projet

Dans le command line de windows (CMD), nous allons nous positioner dans notre répertoire de travail et taper la commande suivante:

npx create-expo-app react-native-temperature-converter

Ceci aura pour effet de créer un nouveau projet :

À l'aide de la commande cd, nous allons nous déplacer dans notre projet et démarrer celui-ci

cd react-native-temperature-converter
npm run web

Le résultat sur le mobile:

Nous allons faire un reset de l'application:

npm run reset-project

Vous devriez avoir le résultat suivant:

Nous pouvons exécuter l'étape 1 de l'image ci-dessus:

npx expo start

Le résultat devrait ressembler à ceci:

Et sur le mobile:

Finalement, nous pouvons ouvrir le code dans VSCode (File - Add Folder to Workspace…):

Étape 2: Le layout

Container du fond

Analysons tout d'abord le layout de l'application:

Nous allons créer un fichier de style (App.style.js) avec le code suivant:

import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: 'red',
  },
});

export { s };

Et nous allons modifier le fichier principale (app/index.tsx): 

//Index.tsx
//Ne pas oublier d'importer les composants
import { Text, View } from 'react-native';
import { s } from '../App.style';

export default function App() {
  return <View style={s.container}></View>;
}

Le résultat sur le mobile est le suivant:

Création de la vue Workspace (Espace de travail)

Rajoutons notre espace de travail (en background bleu) dans le fichier App.style.js:

//Etape 2 avec workspace
import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: 'red',
  },

  workspace: {
    height: 450,
    backgroundColor: 'blue',
  },
});

export { s };

Et le fichier principale devient:

//Etape 2 avec workspace
import { Text, View } from 'react-native';
import { s } from '../App.style';

export default function App() {
  return (
    <View style={s.container}>
      <View style={s.workspace}></View>
    </View>
  );
}

Le résultat sur mobile:

Positionnons le ‘workspace’ (en zone bleu) dans le milieu de la fenêtre (sommes nous en mode colonne ou rangé?):

//Etape 3 avec workspace au milieu
import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    backgroundColor: 'red',
  },

  workspace: {
    height: 450,
    backgroundColor: 'blue',
  },
});

export { s };

Le résultat sur mobile:

3 composants à l'intérieur de l'espace de travail

Rajoutons maintenant nos 3 composant dans l'espace de travail (workspace)

//Il faut rajouter cette ligne 3 fois dans le fichier index.tsx
<View><Text></Text></View>
//Etape 4 Rajout des 3 composants
import { Text, View } from 'react-native';
import { s } from '../App.style';

export default function App() {
  return (
    <View style={s.container}>
      <View style={s.workspace}>
        <View>
          <Text>Temperature</Text>
        </View>
        <View>
          <Text>Input</Text>
        </View>
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </View>
  );
}

Le résultat sur mobile:

Centralisation de nos 3 composants

Centrons nos 3 composants horizontalement et verticalement. Il faut modifier le fichier App.style.js:

import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    backgroundColor: 'red',
  },

  workspace: {
    height: 450,
    alignItems: 'center',
    justifyContent: 'space-evenly',
    backgroundColor: 'blue',
  },
});

export { s };

Le résultat sur mobile est:

Rajout des images pour le background

Nous allons maintenant rajouter les images cold.png et hot.png dans notre projet (vous pouvez sauvegarder les images suivantes sur votre desktop): 



cold.png


hot.png

Pour rajouter les images dans VSCode, il suffit de faire un ‘drag and drop’ de celles-ci VSCode:

Afin de remplacer notre containeur (en rouge) par une image, nous allons utiliser la composante imageBackground de React Native.

Il suffit de faire l'opération suivante (et ne pas oublier d'importer la composante):

Le code de index.tsx devient:

//Fichier index.tsx
//Ne pas oublier d'importer la composante ImageBackground
import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';

export default function App() {
  return (
    <ImageBackground style={s.container}>
      <View style={s.workspace}>
        <View>
          <Text>Temperature</Text>
        </View>
        <View>
          <Text>Input</Text>
        </View>
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Rajoutons le code pour importer notre image (import hot from '../assets/images/hot.png';):

//Fichier index.tsx
import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';

export default function App() {
  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <View>
          <Text>Temperature</Text>
        </View>
        <View>
          <Text>Input</Text>
        </View>
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Attention, vous pourriez avoir une erreur d'importation dans VSCode. Celle-ci n'affecte pas le code

Nous pouvons maintenant retire les couleurs bleu et rouge de nos vues:

//Fichier App.style.js
//Je retire la couleur rouge et bleu
import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
  },

  workspace: {
    height: 450,
    alignItems: 'center',
    justifyContent: 'space-evenly',
  },
});

export { s };

Le résultat sur mobile est:

Étape 3: Les inputs

3.1 Input température

Nous allons maintenant commencer à coder nos différents inputs. Commencons par créer un composant InputTemperature avec son style.

Le code pour la composante (fonction vide) est:

//InputTemperature.jsx
import { TextInput } from 'react-native';
import { s } from './InputTemperature.style.js';

export function InputTemperature({}) {
  return <TextInput placeholder="Tape une température"></TextInput>;
}

Le code pour le style (style vide) est :

//InputTemperature.style.js
import { StyleSheet } from 'react-native';

const s = StyleSheet.create({});

export { s };

Finalement, nous allons rajouter notre composant dans Index.jsx (ne pas oublier d'importer votre composant):


//index.tsx
import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';

export default function App() {
  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <View>
          <Text>Temperature</Text>
        </View>
        <View>
          <InputTemperature />
        </View>
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Le résultat sur mobile devrait être similaire à l'image suivante :

Exercice 3.1

De prime abord, un input semble être quelque chose de simple. En réalité, il y a plusieurs paramètres à configurer:

Voici le code pour chacune des composants ainsi que pour l'index principal:

InputTemperature.jsx

import { Text, TextInput, View } from 'react-native';
import { s } from './InputTemperature.style.js';

export function InputTemperature({ defaultValue }) {
  return (
    <View style={s.container}>
      <TextInput
        style={s.input}
        placeholder="Tape une température"
        keyboardType="numeric"
        maxLength={4}
        defaultValue={defaultValue}
      />
      <Text style={s.unit}>°C</Text>
    </View>
  );
}

InputTemperature.style.js

import { StyleSheet } from 'react-native';

const s = StyleSheet.create({
  container: {
    alignSelf: 'stretch',
    justifyContent: 'center',
  },

  input: {
    backgroundColor: 'white',
    borderRadius: 20,
    height: 50,
    paddingLeft: 25,
  },

  unit: {
    position: 'absolute',
    fontSize: 35,
    alignSelf: 'flex-end',
    paddingRight: 25,
  },
});

export { s };

index.tsx (Attention, nous avons retiré la balise View avant et après <InputTemperature>)

import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';

export default function App() {
  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <View>
          <Text>Temperature</Text>
        </View>

        <InputTemperature defaultValue={'666'} />

        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

3.2 Input Display

Pour les besoins de ce input, nous allons nous créer un composant ainsi qu'un style vide:

Le code pour TemperatureDisplay.jsx sera:

//TemperatureDisplay.jsx
import { s } from './TemperatureDisplay.style';
export function TemperatureDisplay() {
  return <></>;
}

Le code pour son style sera:

//TemperatureDisplay.style.js
import { StyleSheet } from 'react-native';
const s = StyleSheet.create({});
export { s };

Finalement, nous allons rajouter le composant dans notre code principal:

Voici le code de index.tsx (ne pas oublier d'importer son composant):

//Etape Input Display
import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';

export default function App() {
  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay />
        <InputTemperature defaultValue={'666'} />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Exercice 3.2

Pour le moment, et puisque la fonction et le style du composant TemperatureDisplay sont vide, nous allons essayer de trouver le code afin d'avoir le résultat suivant sachant que index.tsx est :

//index.tsx
import { ImageBackground, Text, View } from 'react-native';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';

export default function App() {
  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay value="1234" unit="°C" />
        <InputTemperature defaultValue={'666'} />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Voici le code correspodant pour TemperatureDisplay:

//TemperatureDisplay
import { Text } from 'react-native';
import { s } from './TemperatureDisplay.style';

export function TemperatureDisplay({ value, unit }) {
  return (
    <Text style={s.text}>
      {value}
      {unit}
    </Text>
  );
}

Et pour son style corespondant:

//TemperatureDisplay.style.js
import { StyleSheet } from 'react-native';
const s = StyleSheet.create({
  text: {
    fontSize: 50,
    color: 'white',
  },
});
export { s };

3.3 Température affichée en display

Pour cette partie de l'exercice, nous allons faire en sorte que l'information renseignée dans InputTemperature soit affiché dans TemperatureDisplay. Afin d'afficher l'infromation, nous allons utiliser les STATES

Code pour index.jsx (ne pas oublier d'importer useState):

//index.jsx
//Utilisation des states
import { ImageBackground, Text, View } from 'react-native';
import { useState } from 'react';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';

export default function App() {
  const [inputValue, setInputValue] = useState('0');
  const [currentUnit, setCurrentUnit] = useState('°C');

  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay value={inputValue} unit="°C" />
        <InputTemperature onChangeText={setInputValue} defaultValue={'666'} />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Code pour InputTemperature.jsx (nous envoyons par props la valeur onChangeText)

//InputTemperature.jsx
//Utilisation des states
import { Text, TextInput, View } from 'react-native';
import { s } from './InputTemperature.style.js';

export function InputTemperature({ defaultValue, onChangeText }) {
  return (
    <View style={s.container}>
      <TextInput
        style={s.input}
        placeholder="Tape une température"
        keyboardType="numeric"
        maxLength={4}
        defaultValue={defaultValue}
        onChangeText={onChangeText}
      />
      <Text style={s.unit}>°C</Text>
    </View>
  );
}

3.4 Fichier de constante

Il est commun d'utiliser un fichier de constate qui énumère l'ensemble des variables/constates de notre projet. Pour ce faire, nous allons nous créer un fichier constant.js à la racine de notre projet et nous allons déclarer les constantes suivantes:

Voici le code pour le fichier constant.js:

//constant.js
export const DEFAULT_TEMPERATURE = '0';
export const UNITS = {
  celcius: '°C',
  faranheit: '°F',
};
export const DEFAULT_UNIT = UNITS.celcius;

Nous allons modifier le fichier index.tsx afin de tenir en compte des constates et ainsi n'avoir aucunes valeurs écrites en dure (ne pas oublier d'importer les constates désirées):

//Utilisation du fichier de constante
import { ImageBackground, Text, View } from 'react-native';
import { useState } from 'react';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';
import { DEFAULT_TEMPERATURE, DEFAULT_UNIT, UNITS } from '../constant';

export default function App() {
  const [inputValue, setInputValue] = useState(DEFAULT_TEMPERATURE);
  const [currentUnit, setCurrentUnit] = useState(DEFAULT_UNIT);

  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay value={inputValue} unit={currentUnit} />
        <InputTemperature
          onChangeText={setInputValue}
          defaultValue={DEFAULT_TEMPERATURE}
        />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

3.5 Conversion

Nous allons nous attaquer à la conversion de valeur qui est renseigné dans InputTemperature et qui doit être affiché dans DisplayTemperature. Pour ce faire, nous allons nous créer un fichier avec nos différentes fonctions que nous allons placer dnas le répertoire services et intituler temperature-service.js:

Voici le code pour temperature-service.js:

//temperature-service.js
import { UNITS } from "../constant";

function getOppositUnit(unit) {
  return unit === UNITS.celcius ? UNITS.faranheit : UNITS.celcius;
}

function convertTemperatureTo(unit, value) {
  if (unit === UNITS.celcius) {
    return (value - 32) / 1.8;
  } else {
    return value * 1.8 + 32;
  }
}
export { getOppositUnit, convertTemperatureTo };

Et voici le code pour index.tsx:

//index.tsx
import { ImageBackground, Text, View } from 'react-native';
import { useState } from 'react';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';
import { DEFAULT_TEMPERATURE, DEFAULT_UNIT, UNITS } from '../constant';
import {
  getOppositUnit,
  convertTemperatureTo,
} from '../services/temperature-service';

export default function App() {
  const [inputValue, setInputValue] = useState(DEFAULT_TEMPERATURE);
  const [currentUnit, setCurrentUnit] = useState(DEFAULT_UNIT);
  const oppositeUnit = getOppositUnit(currentUnit);

  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay
          value={convertTemperatureTo(oppositeUnit, inputValue)}
          unit={getOppositUnit(currentUnit)}
        />
        <InputTemperature
          onChangeText={setInputValue}
          defaultValue={DEFAULT_TEMPERATURE}
        />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

Le résultat final sur mobile:

3.6 Correction des erreurs de Input

Après quelques tests, vous réalisez qu'il y a des coquilles à corriger. En effet:

Pour corriger ces erreurs, nous allons nous créer une fonction getConvertedTemperature() qui va corriger coquilles. La fonction va recevoir 2 paramètres, soit:

//temperature-service.js
import { DEFAULT_TEMPERATURE, DEFAULT_UNIT, UNITS } from '../constant';

function getOppositUnit(unit) {
  return unit === UNITS.celcius ? UNITS.faranheit : UNITS.celcius;
}

function convertTemperatureTo(unit, value) {
  if (unit === UNITS.celcius) {
    return (value - 32) / 1.8;
  } else {
    return value * 1.8 + 32;
  }
}

function getConvertedTemperature(unit, value) {
  const valueAsFloat = Number.parseFloat(value);
  return isNaN(valueAsFloat)
    ? ''
    : convertTemperatureTo(unit, valueAsFloat).toFixed(1);
}

export { getOppositUnit, convertTemperatureTo, getConvertedTemperature };

Dans index.tsx, nous allons appeler cette fonction (ne pas oublier de l'importer):

//index.tsx
import { ImageBackground, Text, View } from 'react-native';
import { useState } from 'react';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';
import { DEFAULT_TEMPERATURE, DEFAULT_UNIT, UNITS } from '../constant';
import {
  getOppositUnit,
  convertTemperatureTo,
  getConvertedTemperature,
} from '../services/temperature-service';

export default function App() {
  const [inputValue, setInputValue] = useState(DEFAULT_TEMPERATURE);
  const [currentUnit, setCurrentUnit] = useState(DEFAULT_UNIT);
  const oppositeUnit = getOppositUnit(currentUnit);

  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay
          value={getConvertedTemperature(oppositeUnit, inputValue)}
          unit={getOppositUnit(currentUnit)}
        />
        <InputTemperature
          onChangeText={setInputValue}
          defaultValue={DEFAULT_TEMPERATURE}
        />
        <View>
          <Text>Bouton</Text>
        </View>
      </View>
    </ImageBackground>
  );
}

3.7 Bouton de conversion

Il est temps de travailler sur le bouton. Nous allons créer un composant vide et son style correspodant vide. Pour rappel, un bouton dans react-native est un composant de type TouchableOpacity

Le code pour ButtonConvert.jsx

//ButtonConvert.jsx
import { TouchableOpacity, Text } from 'react-native';
import { s } from './ButtonConvert.style';
export function ButtonConvert() {
  return (
    <TouchableOpacity style={s.button}>
      <Text style={s.text}>Convertir</Text>
    </TouchableOpacity>
  );
}

Le code pour le style:

//ButtonConvert.style.js
import { StyleSheet } from 'react-native';
const s = StyleSheet.create({});
export { s };

Nous allons remplacer le code index.jsx pour appeler le bouton (ne pas oublier d'importer celui-ci). 

Le code dans index.tsx:

import { ImageBackground, Text, View } from 'react-native';
import { useState } from 'react';
import { s } from '../App.style';
import hot from '../assets/images/hot.png';
import { InputTemperature } from '../components/InputTemperature/InputTemperature';
import { TemperatureDisplay } from '../components/TemperatureDisplay/TemperatureDisplay';
import { ButtonConvert } from '../components/ButtonConvert/ButtonConvert';
import { DEFAULT_TEMPERATURE, DEFAULT_UNIT, UNITS } from '../constant';
import {
  getOppositUnit,
  convertTemperatureTo,
  getConvertedTemperature,
} from '../services/temperature-service';

export default function App() {
  const [inputValue, setInputValue] = useState(DEFAULT_TEMPERATURE);
  const [currentUnit, setCurrentUnit] = useState(DEFAULT_UNIT);
  const oppositeUnit = getOppositUnit(currentUnit);

  return (
    <ImageBackground source={hot} style={s.container}>
      <View style={s.workspace}>
        <TemperatureDisplay
          value={getConvertedTemperature(oppositeUnit, inputValue)}
          unit={getOppositUnit(currentUnit)}
        />
        <InputTemperature
          onChangeText={setInputValue}
          defaultValue={DEFAULT_TEMPERATURE}
        />
        <View>
          <ButtonConvert />
        </View>
      </View>
    </ImageBackground>
  );
}

Le résultat sur mobile:

Exercice 3.7

Quelle est le code du bouton pour avoir les caractéristiques suivante: