Atelier 5

Database in Android
Studio.

Développement Android Page 1

 SQLite

SQLite est un système de base de données ou une bibliothèque proposant un moteur de base
de données relationnelles. Il repose sur une écriture en C, un langage de programmation
impératif, et sur une accessibilité via le langage SQL (Structured Query Language)

SQLite est intégrée dans chaque appareil Android. L'utilisation d'une base de données SQLite
sous Android ne nécessite pas de configuration ou d'administration de la base de données.

Vous devez uniquement définir les instructions SQL pour créer et mettre à jour la base de
données. Ensuite, celle-ci est gérée automatiquement pour vous, par la plate-forme Android.

Les class java de android SQLite

1. Cursor :
Un curseur représente le résultat d'une requête et pointe généralement vers une
ligne de ce résultat. De cette façon, Android peut gérer les résultats de la requête de
manière efficace, car il n'a pas à charger toutes les données en mémoire.
Une requête retourne un objet Cursor.
Ses principales methodes sont :
 close(): libere toutes les resources.
 getCount(): retourne le nombre de ligne dans le result set.
 moveToFirst(): pointe vers la premiere ligne du result set.
 moveToLast():pointe vers la derniere ligne du result set.
 moveToNext():pointe vers la prochaine ligne du result set.
 move(): se deplace dans le result set.
 get<type>() :Cursor fournit des méthodes get*() par type de données :
getLong(columnIndex), getString(columnIndex), pour accéder aux données
d'une colonne de la position courante du résultat. Le "columnIndex" est
l'index de la colonne à laquelle vous accédez.
 getColumnIndexOrThrow(String) qui permet d'obtenir l'index d'une colonne à
partir de son nom passé en paramètre
2. SQLiteDatabase :
C’ est la classe de base pour travailler avec une base de données SQLite sous Android
et fournit des méthodes pour ouvrir, effectuer des requêtes, mettre à jour et fermer
la base de données.

Développement Android Page 2

 Plus précisément, SQLiteDatabase fournit les méthodes insert(), update() et delete().

En outre, elle fournit la méthode execSQL(), qui permet d'exécuter une instruction
SQL directement.
Des requêtes peuvent être créées via les méthodes rawQuery() et query()

 rawQuery() accepte directement une requête SQL SELECT en entrée.

Cursor cursor = getReadableDatabase().

rawQuery("select * from todo where _id = ?", new String[] { id });

 query() fournit une interface structurée pour spécifier la requête SQL.

return database.query(DATABASE_TABLE,
new String[] { KEY_ROWID, KEY_CATEGORY, KEY_SUMMARY,
KEY_DESCRIPTION }, null, null, null, null, null);

3. SQLiteOpenHelper :
Pour créer et mettre à jour une base de données dans votre application Android,
vous créez une classe qui hérite de SQLiteOpenHelper. Dans le constructeur de votre
sous-classe, vous appelez la méthode super() de SQLiteOpenHelper, en précisant le
nom de la base de données et sa version actuelle.

Dans cette classe, vous devez redéfinir les méthodes suivantes pour créer et mettre à
jour votre base de données.

• onCreate() - est appelée par le framework pour accéder à une base de données qui
n'est pas encore créée.

• onUpgrade() - est appelée si la version de la base de données est augmentée dans

le code de votre application. Cette méthode vous permet de mettre à jour un schéma
de base de données existant ou de supprimer la base de données existante et la
recréer par la méthode onCreate().

Les deux méthodes reçoivent en paramètre un objet SQLiteDatabase qui est la

représentation Java de la base de données.

La classe SQLiteOpenHelper fournit les méthodes getReadableDatabase() et

getWriteableDatabase() pour accéder à un objet SQLiteDatabase en lecture,
respectif en écriture.

Développement Android Page 3

 Les tables de base de données doivent utiliser l'identifiant _id comme clé primaire de
la table. Plusieurs fonctions Android s'appuient sur cette norme.

Bonne pratique :C'est une bonne pratique de créer une classe par table. Cette classe
définit des méthodes statiques onCreate() et onUpgrade(), qui sont appelées dans les
méthodes correspondantes de la superclasse SQLiteOpenHelper. De cette façon,
votre implémentation de SQLiteOpenHelper reste lisible, même si vous avez plusieurs
tables

Développement Android Page 4

 Creation de notre projet

Nom de la base des données : StudentDB.db

Schema de la bd :

Model de l’application

Etape1 :Data Model Class

Développement Android Page 5

Développement Android Page 6
Etape2 :Data Handler Class : MyDBHandler est une sous classe de
SQLiteOpenHelper

Développement Android Page 7

Creation de la table

Chargement des données

//Chargement des données
public String loadHandler()
{
String result = "";
//on va definir la requete
String query = "Select * from " + TABLE_NAME;
//acces pour lire de la base
SQLiteDatabase db = this.getWritableDatabase();

Cursor cursor = db.rawQuery(query, null);

while (cursor.moveToNext()) {
int result_0 = cursor.getInt(0);
String result_1 = cursor.getString(1);
result += String.valueOf(result_0) + " " + result_1 +
System.getProperty("line.separator");
}
cursor.close();
db.close();
return result;
}

Insertion des données

Rappel : ContentValues permet de stocker des paramatres de type key/value

//insertion
public void addHandler(Student student) {
ContentValues values = new ContentValues();
values.put(COLUMN_ID, student.getID());
values.put(COLUMN_NAME, student.getStudentName());
SQLiteDatabase db = this.getWritableDatabase();
db.insert(TABLE_NAME, null, values);
db.close();
}

Développement Android Page 8

Selection des données avec une condition
//selection
public Student findHandler(String studentname) {
String query = "select * from " + TABLE_NAME + " where" + COLUMN_NAME + " = " + "'" +
studentname + "'";
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(query, null);
//on appelle le constructeur vide car on va par la suite remplir cet objet
Student student = new Student();
//
if (cursor.moveToFirst()) {
cursor.moveToFirst();
student.setID(Integer.parseInt(cursor.getString(0)));
student.setStudentName(cursor.getString(1));
cursor.close();
} else {
student = null;
}
db.close();
return student;
}
Supprimer des données avec une condition
//effacer une donnée
public boolean deleteHandler(int ID) {
boolean result = false;
String query = "select * from " + TABLE_NAME + " where " + COLUMN_ID + "= '" +
String.valueOf(ID) + "'";
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(query, null);
Student student = new Student();
if (cursor.moveToFirst()) {

student.setID(Integer.parseInt(cursor.getString(0)));

db.delete(TABLE_NAME, COLUMN_ID + "=?",

new String[] {
String.valueOf(student.getID())
});
cursor.close();
result = true;
}
db.close();
return result;
}
Maj des données
public boolean updateHandler(int ID, String name) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues args = new ContentValues();
args.put(COLUMN_ID, ID);
args.put(COLUMN_NAME, name);
return db.update(TABLE_NAME, args, COLUMN_ID + "=" + ID, null) > 0;
}

Développement Android Page 9

Etape3 :Interface de l’application

Les composants utilisés dans notre layout :

Développement Android Page 10

Voici activity_main.XML
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity"
android:orientation="vertical">

<EditText
android:id="@+id/studentid"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:gravity="center"
android:layout_marginLeft="90dp"

android:hint="StudentID"
android:textSize="20dp" />
<EditText
android:id="@+id/studentname"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="90dp"
android:gravity="center"
android:hint="Student Name"
android:textSize="20dp"
android:layout_below="@id/studentid"
/>

<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:layout_marginTop="5dp">

<ImageButton
android:id="@+id/btnload"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:src="@drawable/add" />

<ImageButton
android:id="@+id/btnfind"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:src="@drawable/find" />

<ImageButton
android:id="@+id/btndelete"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/supprimer" />

<ImageButton
android:id="@+id/btnupdate"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/modifier" />
</LinearLayout>
<TextView
android:id="@+id/lst"
android:hint="list des students"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
</LinearLayout>

Développement Android Page 11

Voici le code de la class MainActivity
package com.example.bh_info_81.appsqlite;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.TextView;

import com.example.bh_info_81.appsqlite.Model.Student;
import com.example.bh_info_81.appsqlite.tools.MyDBHandler;

public class MainActivity extends AppCompatActivity {

private EditText studentid;
private TextView lst;
private EditText studentname;
private ImageButton btnload, btnfind,btndelete,btnupdate;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
studentid=findViewById(R.id.studentid);
studentname=findViewById(R.id.studentname);
btndelete=findViewById(R.id.btndelete);
btnfind=findViewById(R.id.btnfind);
btnload=findViewById(R.id.btnload);
lst=findViewById(R.id.lst);

//ajouter les stagiaires

btnfind.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyDBHandler dbHandler =new MyDBHandler(getApplicationContext(),null,null,1);

int id = Integer.parseInt(studentid.getText().toString());
String name = studentname.getText().toString();
Student student = new Student(name,id);
dbHandler.addHandler(student);
studentid.setText("");
studentname.setText("");
}
});
//trouver un student
btnfind.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyDBHandler dbHandler = new MyDBHandler(getApplicationContext(), null, null,
1);
Student student =
dbHandler.findHandler(studentname.getText().toString());
if (student != null) {
lst.setText(String.valueOf(student.getID()) + " " +
student.getStudentName() + System.getProperty("line.separator"));
studentid.setText("");
studentname.setText("");
} else {
lst.setText("No Match Found");
studentid.setText("");
studentname.setText("");
}
}
});
//charger tous les etudiants
btnload.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyDBHandler dbHandler =new MyDBHandler(getApplicationContext(),null,null,1);
lst.setText(dbHandler.loadHandler());
studentid.setText("");
studentname.setText("");
}
});
//Supprimer un etudiant

Développement Android Page 12

 btndelete.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyDBHandler dbHandler = new MyDBHandler(getApplicationContext(), null,
null, 1);
boolean result = dbHandler.deleteHandler(Integer.parseInt(
studentid.getText().toString()));
if (result) {
studentid.setText("");
studentname.setText("");
lst.setText("Record Deleted");
} else
studentid.setText("No Match Found");
}
});

Développement Android Page 13