Android cours

Pr. Zakaria Bentahar
À l’académie internationale d’aviation civile (AIAC), Casablanca, Maroc

Plan
Android : qu'est ce que c'est ? et l'Open Handset Alliance ?
Pourquoi Android ?
Positionnement par rapport à son environnement
Historique de 2005 à nos jours
Les différentes versions d’Android
Architecture du système Android

Plan
La structure d’un projet Android
Création des interfaces utilisateurs
Ressources
Activités
Intent
Persistence des données (Fichiers, SQLite)

Android
&
l'Open Handset
Alliance

Android est un système d'exploitation pour téléphone portable de
nouvelle génération développé par Google. Celui ci met à disposition
un kit de développement (SDK) basé sur le langage Java.

L'Open Handset Alliance (abrégé OHA) est un consortium de plusieurs
entreprises dont le but est de développer des normes ouvertes pour
les appareils de téléphonie mobile.
Le consortium a été créé le 5 novembre 2007 à l'initiative
de Google qui a su fédérer autour de lui 34 compagnies

Rovio une entreprise fondé par trois étudiants d'une université de
technology en Finland a eu des revenues d'environ €75.4 million en
2011 grâce à un jeu gratuit Angry Birds, ils ont gagné plus d'un
million de dollars par mois, ceci à travers les publicités qui se lancent
automatiquement suite à chaque lancement du jeu.

Instagram est une application et un service de partage des photos
conçu par un ingénieur avec deux ans d'expériences en Gmail et un
ingénieur étudiant brézilien résidant en Californie , Facebook l'a
acheté d'eux en 1 billion $ Cach, il était uploaded au niveau de App
Store comme c'est le cas pour le reste des applications Android et il a
eu sa réputation grâce aux nombres de téléchargement.

WhatsApp est une application de messagerie instantannée réalisé par
deux anciens combattants de Yahoo, cette application qui coute juste
0.99$ après une année gratuite a réussit a faire une fortune même si
la societé n'a pas dévoilé ses revenues mais juste en la comparant
avec le nombre d'utilisation de Instagram qu'a acquiert facebook , elle
a eu plus d'utilisateurs par la suite plus de revenues.

Talking Tom Cat c'est un jeu qui étaient téléchargé plus de 400 million
fois réalisé par une societé spécialisée dans la réalisation des
applications payantes de divertissement, alors que le meilleur
nombre de téléchargement d'un logiciel comme Avast a eu juste
340987 nombre de téléchargement dans le site le plus populaire de
téléchargement télecharger.com

Positionnement par rappot à son environnement

Versions
Pour plus de details :
http://fr.wikipedia.org/wiki/Historique_des_versions_d'
Android

Architecture
La plate-forme Android est composée de différentes couches :
un noyau Linux qui lui confère notamment des caractéristiques
multitâches ;
des bibliothèques graphiques, multimédias ;
une machine virtuelle Java adaptée : la Dalvik Virtual Machine ;
un framework applicatif proposant des fonctionnalités de gestion
de fenêtres, de téléphonie, de gestion de contenu... ;
des applications dont un navigateur web, une gestion des contacts,
un calendrier…

SDK
Le SDK est un ensemble d’outils qui permet aux
développeurs et aux entreprises de créer des
applications.
http://developer.android.com/sdk/index.html

Configuration de Eclipse: Installation de ADT (Android Development Tools)
 crée et débogue des applications Android facile et plus
rapide
 donne accès à d'autres outils de
développement Android à l'intérieur de Eclipse.
 fournit un éditeur de code Android qui aide à écrire du
code XML valide pour le fichier de configuration et les
fichiers de ressources
 exporte le projet dans un APK signé.

ADT Plugin
http://dl-ssl.google.com/android/eclipse/

1) Installer SDK
2) Installer ADT
3) Configurer SDK dans Eclipse
Etapes de configuration de l’environnement de développement

CONFIGURER UN APPAREIL VIRTUEL ANDROID
AVD (Android Virtual
Devices) est un émulateur
qui joue le rôle de
smartphone

CONFIGURER UN APPAREIL VIRTUEL ANDROID
Window > Android AVD Manager

Structure du projet : gen
 Contain Java files auto-generated by ADT.
 Contain the class R :
 Special static class.
 Reference the data contained in resource files.
 Contain one static inner class by resource type.
public final class R{
public static final class drawable {
public static final int
icon=0x7f020000;
}
public static final class layout {
public static final int
main=0x7f030000;
}
... //code omitted
}

Structure du projet : assets
 Contain asset files
 Quite similar to resources.
 Accessed in a classic file manipulation style
 With stream of bytes manipulation.
 Need to use AssertManager class to open them.
 Not for an usage as extensive as resources.

Structure du projet : androidManifest.xml
 Mandatory file in every Android projects.
 Contain information needed by Android to run the
application
 Package name of the application.
 List of Activities, Services, Broadcast Receivers, …
 Permissions needed by the application.
 etc…

Resources : Presentation
 Android externalize resources like :
 Images.
 Strings.
 User Interface description.
 …
 Easier to manage and maintain them.
 Contained inside the res folder.

Resources : Use the resources
 Resources are accessible inside the code thanks to the static
class : R.
 This class is automatically generated by ADT.
 When you add a resource inside the res folder, ADT add a
reference to it inside the R class.
 The syntax to retrieve a resource reference is :
R.resource_type.resource_name

Resources : Example
// Define the layout of an activity
setContentView(R.layout.my_screen);
// Retrieve the application name
Resources resources = getResources();
String appName = resources.getString(R.string.app_name);
public final class R{
public static final class string {
public static final int app_name=0x7f020000;
}
public static final class layout {
public static final int my_screen=0x7f030000;
}
... //code omitted
}

Resources : System Resources
 Android already includes a number of resources
 Predefined Colors.
 Predefined Strings.
 Predefined Images.
 Examples :
...
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content”
android:textColor="@android:color/darker_gray"
android:text="@string/hello”
/>
...
String cancel =
resources.getString(android.R.string.cancel);

Resources : Simple Values
 Simple values are stored in XML files inside /res/values folder.
 You can declare
 Strings
 You can use the HTML tags <b>, <i> and <u>.
 Colors
 Accept #RGB, #ARGB, #RRGGBB and #AARRGGBB format.
 Dimensions
 In pixels (px), inches (in), millimeters (mm), points (pt),
density-independent pixel (dp) or scale-independent pixel
(sp),
 Arrays
 Of Integers or Strings.

Resources : simple values’ examples
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Cyan">#00FFFF</color>
<string name="first_name">zakaria</string>
<string-array name="my_array">
<item>A string</item>
<item>Another String</item>
</string-array>
<integer-array name="my_other_array">
<item>123</item>
<item>456</item>
</integer-array>
<dimen name="my_dimension">4dp</dimen>
<dimen name="text_size">4px</dimen>
</resources>

Resources : Images
 Android accept different bitmap format for resources :
 PNG (advised by the documentation)
 JPEG
 GIF (deprecated)
 From Android 1.6, three folders :
 drawable-hdpi : resource for high-resolution screens.
 drawable-mdpi : resources for medium-resolution screens.
 drawable-ldpi : resources for low-resolution screens.

User Interfaces
 A user interface is a set of graphical components like :
 Button.
 Text.
 Form field.
 Component composed of other components…
 This components are called Views.
 The last one is a special view
called ViewGroup.

User Interfaces
Views
ViewGroups

User Interfaces
 User interfaces can be defined :
 In XML, inside a layout resource file.
 Directly in the Activity code.
 We’re going to see both.

User Interfaces : XML Definition VS Java Definition
 Use XML layout to define user interfaces :
 Separate interface structure and interface logic.
 Easier to maintain.
 But java definition can also be useful :
 Adding components dynamically.

User Interfaces : XML Definition >> Example
<LinearLayout
xmlns:android=“http://schemas.android.com/apk/res/androi
d”
android:orientation="vertical”
android:layout_width=“match_parent”
android:layout_height=“match_parent”
>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/first_name”
/>
<EditText
android:layout_width=“match_parent"
android:id="@+id/first_name”
/>
</LinearLayout>
GroupView
Views

User Interfaces : Java Definition >> Example
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
LinearLayout layout = new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.setLayoutParams(
new LayoutParams(
LayoutParams.MATCH_PARENT,
LayoutParams.MATCH_PARENT));
TextView textView = new TextView(this);
textView.setText(R.string.first_name);
EditText editText = new EditText(this);
layout.addView(textView);
layout.addView(editText);
setContentView(layout);
}

User Interfaces : ID Attribute
 Ids are typically assigned in the layout XML files, and are used
to retrieve specific views inside the Activity code.
 You can ask ADT to generate one with the special syntax :
Instead of :
“@+id/resource_identifier”
“@id/resource_identifier”

User Interfaces : ID Attribute
 Example :
<EditText
/>
EditText txtFirstName =
(EditText)
findViewById(R.id.first_name);

User Interfaces : Layouts
 A layout is a ViewGroup which help us to position our views.
 A layout is also a view.
 A layout can contain other layouts.
 Common layouts provide by the SDK are :
 LinearLayout.
 RelativeLayout.
 FrameLayout.
 TableLayout.
 We’re going to see only the first one.

User Interfaces : Layouts >> LinearLayout
 A Layout that arranges its
children in a single column or a
single row.
 This layout is the more use in
Android development
 It can almost do everything
others can do.
 With nesting layout.

User Interfaces : Layouts >> LinearLayout : Component size
 The size of its components can be define with :
 In XML with layout_width and layout_height attributes.
 In Java with a LayoutParams object.
 Their values may be a dimension or one of the special
constants :
FILL_PARENT, MATCH_PARENT, WRAP_CONTENT
<TextView
android:layout_height=”10px"
/>

User Interfaces : Layouts >> LinearLayout : Weight
 Defined how views on the same
row share the layout size.
 Useful when you want that
several views share all the
screen.
 Example :
<Button
android:layout_width="wrap_content
"
android:layout_height=”wrap_conten
t”
android:layout_weight=”2”
android:layout_text=”weight=2"
/>

User Interfaces : Layouts >> LinearLayout : Gravity
 Specify how to align the text by the view's x- and/or y-axis
when the content is smaller than the view.
 Must be one or more (separated by '|') of the Gravity class
constant values :
 LEFT / RIGHT
 TOP / BOTTOM
 CENTER
 … <TextView
android:layout_width=”match_parent"
android:gravity=”top|right"
/>

User Interfaces : Layouts >> LinearLayout : Padding
 By default, components are tightened each other.
 You can define space between them thanks to padding !
 Padding is defined as space between the edges of the view and
the view's content.
 Value in pixels.
 Five padding attributes exist :
 padding
 paddingLeft
 paddingRight
 paddingTop
 paddingBottom

User Interfaces : Layouts >> LinearLayout : Padding
 XML example :
 Java example :
<TextView
android:padding=”20dp"
/>
EditText txtFirstName = ... ;
// left, top, right, bottom
txtFirstName.setPadding(20, 30, 10, 20);

User Interfaces : TextView
 Displays text to the user.
 Can be editable
 But disable by default.
<TextView
android:gravity=”top|right"
/>

User Interfaces : EditText
 EditText is a subclass of TextView
 Editable by default !
<EditText
/>

User Interfaces : CheckBox
<CheckBox
android:id="@+id/checkbox”
android:layout_width="wrap_content”
android:text="check it out"
/>
 A check box is a two-states button that can be either checked
or unchecked.

User Interfaces : RadioButton
 A radio button is a two-states button that can be either
checked or unchecked.
 Contrary to checkbox, only one button by radio group can
be checked.
<RadioGroup
android:layout_height="fill_parent"
android:id="@+id/radio_group"
>
<RadioButton
android:text="Easy"
/>
...
</RadioGroup>

User Interfaces : Spinner
<Spinner
android:id="@+id/spinner”
android:layout_width=“match_parent”
android:prompt="@string/spinner_prompt”
/>
 A spinner is the Android version of the combo box.

User Interfaces : Spinner >> Adapter
String[] values = { "Easy", "Medium", "Hard" };
ListAdapter adapter =
new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item,
values);
adapter.setDropDownViewResource
(android.R.layout.simple_spinner_dropdown_item)
;
Spinner spinner = (Spinner)
findViewById(R.id.spinner);
spinner.setAdapter(adapter);
 To set spinner options, you need to use a ListAdapter object.

User Interfaces : AutoCompleteTextView
 An editable text view that shows completion suggestions
automatically while the user is typing.
<AutoCompleteTextView
android:id="@+id/autocomplete_planet”
android:layout_width=”match_parent”
/>

User Interfaces : Button
 Represents a push-button widget.
 Push-buttons can be pressed, or clicked, by the user to perform
an action.
<Button
android:id="@+id/my_button”
android:layout_width=”wrap_content”
android:text=“@string/button_text”
/>

User Interfaces : ImageButton
 Represents a push-button widget but with an image instead of
text inside.
<ImageButton
android:id="@+id/my_button”
android:layout_width=”wrap_content”
android:src="@drawable/logo_google"
/>

User Interfaces : ListView
 A view that shows items in a vertically scrolling list.
<ListView
android:id="@+id/my_list_view”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
/>

User Interfaces : ListView >> Adapter
ListView listView =
(ListView)
findViewById(R.id.my_list_view);
Cursor cursor = new
PersonDao(this).getAllPersons();
ListAdapter adapter =
new SimpleCursorAdapter(this,
android.R.layout.simple_list_item_1,
cursor, new String[] { "name"
},
new int[] { android.R.id.text1
});
listView.setAdapter(adapter);
 To populate the list, you need to use an ListAdapter object
again.

User Interfaces : Adapters
 The bridge between a component and the data that backs the list.
 The most used concrete subclasses are :
 ArrayAdapter
 Adapter to map object arrays or object lists to a view.
 SimpleCursorAdapter
 Adapter to map columns of a cursor to a view.
 We’ll see more about curser later…
 Constructors of these classes take a resource id :
 The layout to apply to the item of the view
 You can use one of proposed by the SDK.
 You can define your own layout.
 Remember : android.R ≠ R

User Interfaces : Events
 With Android, all user actions are events
 Click
 Long click
 Key pressed
 Item selected
 …
 You can link behaviors to this events.
 The interception mechanism based on the Listener notion.
 As with Swing !

User Interfaces : Click Event
 To add a listener to a click event on a view :
 setOnClickListener(View.OnClickListener)
 OnClickListener is an inner interface of the View class.
 You have three possibilities :
 Make your activity implements it.
 Create a new class implementing it.
 Create an anonymous class.

 First solution :
public class MyActivity extends Activity implements
View.OnClickListener {
protected void onCreate(Bundle savedInstanceState) {
Button button = (Button) findViewById(R.id.my_button);
button.setOnClickListener(this);
}
public void onClick(View view) {
// Display a notification popup during 1 second.
Toast.makeText(this, "Button clicked !", 1000).show();
}
}

 Second solution :
public class MyActivity extends Activity {
protected void onCreate(Bundle
savedInstanceState) {
Button button = (Button)
findViewById(R.id.my_button);
button.setOnClickListener(new
ButtonClickListener());
}
}
public class ButtonClickListener implements
View.OnClickListener {
// Display a notification popup during 1 second.
Toast.makeText(this, "Button clicked !",
1000).show();
}
}

 Third solution :
public class MyActivity extends Activity {
protected void onCreate(Bundle
savedInstanceState) {
Button button = (Button)
findViewById(R.id.my_button);
button.setOnClickListener(new
View.OnClickListener() {
// Display a notification popup during
1 second.
Toast.makeText(MyActivity.this,
“Clicked!", 1000)
.show();
}
});

Activity
 An activity is a sort of screen composed of several views and
controls.
 As many activities as application screens.
 Presentation layer of an application.

Activity
 Composed of two parts :
 The Activity Logic :
 Define in Java inside a class extending
android.app.Activity.
 The User Interface :
 Define either in Java inside the Activity class or
inside a XML file (in the folder /res/layout/).

Activity : example
 Activity class simple example :
package com.supinfo.hellodroid;
import android.app.Activity;
import android.os.Bundle;
public class Main extends Activity {
/** Called when the activity is first created. */
@Override
setContentView(R.layout.main);
}
}

Activity : example
 Layout file simple example :
<LinearLayout
xmlns:android=“http://schemas.android.com/apk/res/and
roid”
android:orientation="vertical”
android:layout_width="fill_parent”
android:layout_height="fill_parent”
>
<TextView
android:text="@string/hello”
/>
</LinearLayout>

Activity lifecycle
 An activity can have three states :
 Active
 The activity is visible and has the user focus.
 Paused
 The activity is at least partly visible but doesn’t have
the focus.
 Stopped
 The activity is not
visible.
 Activity class defines methods to manage life cycle.

Activity lifecycle
/**
* Appelée lorsque l’activité est créée.
* Permet de restaurer l’état de l’interface
* utilisateur grâce au paramètre savedInstanceState.
*/
// Placez votre code ici
}
/**
* Appelée lorsque que l’activité a fini son cycle de vie.
* C’est ici que nous placerons notre code de libération
de mémoire, fermeture de fichiers et autres opérations
* de "nettoyage".
*/
}
@Override
public void onDestroy(){
super.onDestroy();
}

Activity lifecycle
/**
* Appelée lorsque l’activité démarre.
* Permet d’initialiser les contrôles.
*/
@Override
public void onStart(){
super.onStart();
// Placezvotre code ici
}
/**
*
Appelée lorsque l’activité passe en arrière plan.
* Libérez les écouteurs, arrêtez les threads, votre
activité
* peut disparaître de la mémoire.
*/
@Override
public void onStop(){
super.onStop();

/**
* Appelée lorsque l’activité sort de son état de veille.
*/
@Override
public void onRestart(){
super.onRestart();
//Placez votre code ici
}
/**
* Appelée lorsque que l’activité est suspendue.
* Stoppez les actions qui consomment des ressources.
* L’activité va passer en arrière-plan.
*/
@Override
public void onPause(){
//Placez votre code ici
super.onPause();
}
Activity lifecycle

/**
* Appelée après le démarrage ou une pause.
* Relancez les opérations arrêtées (threads).
* Mettez à jour votre application et vérifiez vos écouteurs.
*/
@Override
public void onResume(){
super.onResume();
}
Activity lifecycle

Activity : declaration
 To be usable, an activity must be declared
 Inside the AndroidManifest.xml file.
… <category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=”.ourActivity"
android:label="@string/app_name">
</activity>
</application>
...

Intent
 An intent is an abstract description of an operation to be
performed.
 We can use it to :
 Launch an Activity.
 Communicate with components like :
 Background Services.
 Broadcast Receivers.
 The first one is the most common usage
 We’ll only see it.

Intent : Launch an Activity
 To simply launch an activity :
 One of Instant constructors take only this two parameters :
 The context of the intent, here the activity instance creating
it.
 The component class used for the intent.
 startActivity(Intent) :
 An instance method of Activity class to start a new activity
with an intent.
Intent intent = new Intent(this,
ActivityToLaunch.class);
startActivity(intent);

Intent : Important remark
Remember :
An Activity have
to be declared
inside Android
Manifest file to
be launched.

Intent : Include extra data
 When you launch another activity, you often need to
communicate some information.
 You can use the intent methods below :
 void putExtra(…)
 Bundle getExtras(…)
 Supported types are :
 Primitives : byte, short, int, long, float, double, …
 Primitive Arrays : int[], long[], …
 Strings
 Serializable objects.

Intent : include extra data
 To put an extra data :
 To retrieve it in the launched Activity :
 Intent getIntent() :
 Return the intent that started this activity.
Intent intent = new Intent(this, MyActivity.class);
intent.putExtra("smthg", "Hi Activity.");
startActivity(intent, MY_ACTIVITY_CODE);
Bundle extras = getIntent().getExtras();
if(extras != null) {
String message = extras.getString("smthg");
}

Persistence: Presentation
 Android provide four ways to store data :
 Instance State.
 Shared Preferences.
 SQLite databases.
 Files.
 We’re going to see the first three.

Persistence: Presentation
 To put an extra data :
 To retrieve it in the launched Activity :
 Intent getIntent() :
 Return the intent that started this activity.
Intent intent = new Intent(this, MyActivity.class);
intent.putExtra("smthg", "Hi Activity.");
startActivity(intent, MY_ACTIVITY_CODE);
Bundle extras = getIntent().getExtras();
if(extras != null) {
String message = extras.getString("smthg");
}

Persistence: Instance State
 You have seen earlier activities life cycle.
 A background activity can be unloaded if another one need
memory.
 How to save activity state to allow user to retrieve his activity as
before ?
 Thanks to Instance State !
 We’re going to see the two
activity methods to manage
instance state :
onSaveInstanceState(…)
onRestoreInstanceState(…)

 onSaveInstanceState(Bundle)
 Called to retrieve per-instance state from an activity before
being killed so that the state can be restored in
onCreate(Bundle) or onRestoreInstanceState(Bundle) (the
Bundle populated by this method will be passed to both).
 onRestoreInstanceState(Bundle)
 This method is called after onStart() when the activity is being
re-initialized from a previously saved state, given here in
Bundle type parameter.

 By default, Instance State save the values of all views with id
attribute.
 If you want to save more information, just override the two
methods we have just seen.
private String myInformation;
...
protected void onSaveInstanceState(Bundle outState)
{
outState.putString("anotherInformation",
myInformation);
super.onSaveInstanceState(outState);
}
protected void onRestoreInstanceState(Bundle
savedInstanceState){
super.onRestoreInstanceState(savedInstanceState);
myInformation =
savedInstanceState.getString("anotherInformat
ion");
}

Persistence: Shared Preferences
 Share across all components in an application.
 Set of key/value pair.
 Can only store boolean, int, long, float and String values.
 Permission can be given :
 MODE_PRIVATE
 Default value, the created file is only accessible by the
application that created it.
 MODE_WORD_READABLE
 Other applications can read the file but not modify it.
 MODE_WORD_WRITABLE
 Other applications can modify the file.

 Examples :
 Save shared preferences :
SharedPreferences prefs =
getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = prefs.edit();
editor.putString(“username”, “Droid”);
editor.putBoolean(“isAdmin”, true);
editor.commit();

 Examples :
 Retrieve shared preferences :
SharedPreferences prefs =
getPreferences(Context.MODE_PRIVATE);
// If there is no value for “username”, return null
String username = prefs.getString(“username”, null);
// If there is no value for “isAdmin”, return false
boolean admin = prefs.getBoolean(“isAdmin”, false);
// If there is no value for “id”, return zero
long id = prefs.getLong(“id”, 0L);

Persistence: SQLiteDatabases
 Relational Database Management System.
 Useful to stock complex data.
 Each database is dedicated to only one application.
 An application can have several databases.
 To share data with another application, you can use a Content
Provider (out of the course's scope).

Persistence: SQLiteDatabases
 Don’t design your SQLite database as a MySQL or PostgreSQL
ones.
 Mobile devices are not dedicated database server
 Little storage space.
 Little memory.
 Store only what you need.
 Avoid frequent requests.
 Design SQLite databases with :
 A simple structure.
 Data easily identifiable.
 Don’t store binary data !

Persistence: SQLiteOpenHelper
 To simplify your code to create or update a Database schema,
the SDK propose you a Helper class named :
SQLiteOpenHelper.
 To use it, create your proper class and extend it.
Abstract
Methods

 Example :
public class MyOpenHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME =
“my.db”;
private static final int DATABASE_VERSION = 2;
private static final String TABLE_NAME =
”persons";
private static final String TABLE_CREATE =
"CREATE TABLE " + TABLE_NAME + " (" +
”id INTEGER PRIMARY KEY AUTOINCREMENT, " +
“name TEXT NOT NULL);";
public MyOpenHelper(Context context) {
super(context, DATABASE_NAME, null,
DATABASE_VERSION);
}
...

 Example :
...
public void onCreate(SQLiteDatabase db) {
db.execSQL(TABLE_CREATE);
}
public void onUpgrade(SQLiteDatabase db,
int oldVersion, int newVersion) {
Log.w("Example", ”Upgrading database, this
will drop”
+ “tables and recreate.");
db.execSQL("DROP TABLE IF EXISTS " +
TABLE_NAME);
onCreate(db);
}
}

Persistence: SQLiteDatabase
 This class provides two other methods very useful :
 SQLiteDatabase getWritableDatabase()
 Return a SQLiteDatabase instance to read or write in
the Database. Throw an exception if the database
cannot be opened for writing (bad permission or full
disk).
 SQLiteDatabase getReadableDatabase()
 Return a SQLiteDatabase instance with read-only
access to the database.
 Both will create the database if it doesn’t exist.

 Exposes methods to manage a SQLite database.
 Has methods to create, delete, execute SQL commands, and
perform other common database management tasks.
 We’re going to see some useful methods :
 void execSQL(...)
 long insert(…)
 int update(…)
 int delete(…)
 Cursor query(…)

 void execSQL(String sql) :
 Execute a single SQL statement that is not a query.
 For example, CREATE TABLE, DELETE, INSERT, etc.
 Example :
SQLiteDatabase db = ...
db.execSQL("DROP TABLE IF EXISTS
my_table");

 long insert (String table, String nullColumnHack,
ContentValues values) :
 Convenience method for inserting a row into the database.
 Three parameters :
 table : The table to insert the row into.
 nullColumnHack :
 SQL doesn't allow inserting a completely empty row.
 If initialValues is empty this column will explicitly be
assigned a NULL value.
 values :
 Map containing the column values for the row
 The keys should be the column names.
 The values the column values.

 long insert (String table, String nullColumnHack,
ContentValues values) :
 Return the row ID of the inserted row.
 Example :
ContentValues values = new ContentValues();
values.put(“name”, “bentahar”);
db.insert(“persons”, null, values);

 int update (String table, ContentValues values,
String whereClause, String[] whereArgs) :
 Convenience method for updating rows in the database.
 Four parameters :
 table : the table to update in.
 values : a map from column names to new column values.
 whereClause : the optional WHERE clause to apply when
updating.
 whereArgs : an array of the value to apply to the WHERE
clause.
 Return the number of rows affected.

 int update (String table, ContentValues values,
String whereClause, String[] whereArgs) :
 Example :
ContentValues values = new ContentValues();
values.put("name", ”Zakaria");
String[] whereArgs = { "1" };
db.update(“persons”, values, "id=?", whereArgs);

 int delete (String table, String whereClause,
String[] whereArgs) :
 Convenience method for deleting rows in the Database.
 Three parameters :
 table : the table to delete from.
 whereClause : the optional WHERE clause to apply
when deleting.
 whereArgs : an array of the value to apply to the
WHERE clause.
 Return the number of rows affected.

 int delete (String table, String whereClause,
String[] whereArgs) :
 Example :
String[] whereArgs = { "1" };
db.delete("persons", "id=?", whereArgs);

 Cursor query(String table, String[] columns,
String selection, String[] selectionArgs,
String groupBy, String having,
String orderBy) :
 Query the given table, returning a Cursor over the result
set.
 Seven parameters :
 table : The table name to compile the query.
 columns : A list of which columns to return.
 selection : A filter declaring which rows to return,
formatted as an SQL WHERE clause.

String orderBy) :
 Seven parameters :
 selectionArgs : You may include ?s in selection, which will
be replaced by the values from selectionArgs.
 groupBy : A filter declaring how to group rows, formatted
as an SQL GROUP BY clause.
 having : A filter declare which row groups to include in the
cursor, if row grouping is being used, formatted as an SQL
HAVING clause.
 orderBy : How to order the rows, formatted as an SQL
ORDER BY clause.

String orderBy) :
 Example :
String[] columns = { ID_COLUMN, NAME_COLUMN };
String[] params = { “Cartman” };
Cursor result = db.query(TABLE_NAME, columns,
”name=?",
params, null, null, null, "1");

Persistence: Cursor
 Provide access to the result set returned by a database query.
 Methods commonly used are :
 getCount() : returns the number of rows.
 moveToFirst() : moves the cursor to the first row.
 moveToNext() : moves the cursor to the next line.
 isAfterLast() : returns true if the cursor position is after the
last row.
 getColumnNames() : returns a string array holding the
names of all of the columns in the result set.
 getColumnIndex(String name) : return the index of the
corresponding column name.

Persistence: Cursor
String[] columns = { “id”, “name”};
Cursor result = db.query(“persons”, columns, null,
null, null, null, null);
List<Person> persons = new ArrayList<Person>();
result.moveToFirst();
while(!result.isAfterLast()) {
Person person = new Person();
person.setId(result.getLong(0));
person.setName(result.getString(1));
persons.add(person);
result.moveToNext();
}
result.close();
return persons;
 Example of use :

Android cours

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Android cours (20)

Recently uploaded (20)

Android cours

Editor's Notes