Esempio pratico di utilizzo di Couchbase Lite

Home  >>  Couchbase News  >>  Esempio pratico di utilizzo di Couchbase Lite

Esempio pratico di utilizzo di Couchbase Lite

On aprile 21, 2015, Posted by , In Couchbase News,Sviluppo App, By ,, , With 1 Comment

Introduzione

In questo primo articolo della serie dedicata alla realizzazione di app Android utilizzando Couchbase Lite come sistema di memorizzazione locale al dispositivo mobile, vedremo in maniera molto stringata quali sono i metodi offerti dalle API CBLite per la implementazione di operazioni CRUD sui documenti JSON. L’app realizzata è estremamente semplice, senza alcuna cura dell’aspetto grafico o di navigazione, proprio per evidenziare quanto detto qui sopra.

la versione di Couchbase Lite utilizzata è la 1.0.4, mentre l’ambiente di sviluppo è Android Studio, versione AI-140 di Google Inc, disponibile all’indirizzo:

http://tools.android.com/recent

Il tool di compilazione e build è Gradle, embedded in Android Studio, che deve essere configurato per ottenere gli artefatti dal repository centrale di Maven, per cui non è necessario scaricare le librerie Couchbase Lite.

Per l’esecuzione dell’app si può usare o un dispositivo con sistema operativo Android 4.1.x Jelly Bean, con versione minima SDK 16, oppure, in alternativa, al posto dell’AVD Manager embedded in Android Studio, si può usare Genymotion,  molto più veloce e performante.

Primo passo: creazione del progetto

Per prima cosa occorre creare un progetto Android Studio nella modalita` usuale; successivamente occorrera` modificare i file di configurazione di Gradle, per poter importare ed utilizzare le librerie CBLite, contenute nel package:

com.couchbase.lite.*

Scegliamo la BlankActivity come Activity principale dell’app e la chiamiamo MainActavity; per semplicita` inseriremo tutto il codice necessario per effettuare le operazioni CRUD nel metodo

onCreate()

dell’Activity.

Prevediamo anche di utilizzare un semplice layout per l’activity contenente un’area di testo ed un bottone per terminare l’esecuzione dell’app e liberare esplicitamente le risorse utilizzate. Qui ci interessa solamente vedere quali metodi utilizzare per effettuare operazioni CRUD sul database CBLite, per cui l’app realizzata non ha alcuna funzionalità grafica particolare, mostra semplicemente nello screen principale la successione di operazioni eseguite.


 

Activity_main.xml

 

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">

    <TextView
android:id="@+id/textView1"
android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_centerHorizontal="true"
android:background="#fff3ffd6" android:autoText="false" android:elegantTextHeight="false"
android:shadowColor="#ff6aff34" android:textColor="#ff2532ff"
android:textColorHighlight="#ffffffc9"/>
    <Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="ESCI"
android:id="@+id/button" android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true" android:elegantTextHeight="true"
android:clickable="true" android:enabled="true" android:focusable="true"
android:focusableInTouchMode="true" android:shadowColor="#ff4f27ff"
android:textColor="#ffff1118"/>

</RelativeLayout>

 



Secondo passo: configurazione del progetto

Per poter importare le librerie CBLite e` necessario modificare i due files di configurazione del progetto e del modulo, nel seguente modo.

build.gradle (progetto):



//// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
    repositories {
  //      jcenter()
mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.0.1'
// NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
}
}
allprojects {
    repositories {
       // jcenter()
mavenCentral()
        maven {
            url "http://files.couchbase.com/maven2/"
}
    }
}

 build.gradle (modulo)



apply plugin: 'com.android.application'

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"
// workaround for "duplicate files during packaging of APK" issue
// see https://groups.google.com/d/msg/adt-dev/bl5Rc4Szpzg/wC8cylTWuIEJ
    packagingOptions {
        exclude 'META-INF/ASL2.0'
        exclude 'META-INF/LICENSE'
        exclude 'META-INF/NOTICE'
    }
    defaultConfig {
        applicationId "com.example.pierluigimiglioli.couchbaseliteexample"
        minSdkVersion 16
        targetSdkVersion 22
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.0.0'
    compile 'com.couchbase.lite:couchbase-lite-android:1.0.4'
}

 

 

 Compilazione e build dell’app

Cliccando sul widget “Sync Project with Gradle Files”, si crea una prima versione dell’app. Per ora non abbiamo ancora utilizzato le librerie CBLite, per farlo occorre importare le seguenti classi:


 

importcom.couchbase.lite.CouchbaseLiteException;
import com.couchbase.lite.Database;
import com.couchbase.lite.Document;
import com.couchbase.lite.Manager;
import com.couchbase.lite.android.AndroidContext;

 


 

e dichiarare le seguenti proprieta`:


 

final String TAG = "MainActivity";
//top level database manager
Manager manager;
//database in cui memorizzare gli oggetti
Database database;
// nome del database
String dbname = "hello";
//l'area di testo
TextView testo;
//il bottone per chiudere l'app
Button bottone;

 

creazione del Manager

La creazione di un oggetto di tipo Manager è realizzata passando nel costruttore il contesto applicativo e una costante che definisce la opzioni di default.


 

// creazione di un oggetto di tipo com.couchbase.lite.Manager;
try {
    manager = new Manager(new AndroidContext(this), Manager.DEFAULT_OPTIONS);
    testo.append("Manager Creato\n");
} catch (IOException e) {
    testo.setText("Impossibile creare l'oggetto Manager");
    return;
}
if (!Manager.isValidDatabaseName(dbname)) {
    testo.setText("Nome del Database errato");
    return;
}

creazione del database

La creazione del database è particolarmente semplice, e simile all’analoga istruzione SQLite:

SQLiteOpenHelper.getWritableDatabase();

Ovviamente utilizzando CBLite non dobbiamo, a differenza di SQLite, definire alcuna tabella mediante istruzioni SQL; la creazione del database risulta molto più semplice di SQLite, database relazionale di default per le applicazioni Android.

// creazione di un database

try {
      database = manager.getDatabase(dbname);
       testo.append("Database creato\n");
        } catch (CouchbaseLiteException e) 
       testo.setText("Impossibile accedere al database");
       return;
        }


 

creazione di un documento vuoto

// creazione di un documento vuoto

Document document = database.createDocument();


 

creazione dei dati da inserire nel documento

Analogamente alla modalità standard delle API Java 2.1 con cui è possibile creare documenti JSON, si utilizza una mappa per memorizzare i dati in forma chiave-valore:


 

// creazione di un oggetto che contiene i dati da memorizzare
Map<String, Object> docContent = new HashMap<String, Object>();
        docContent.put("messaggio", "contenuto originale del documento");
        docContent.put("temperatura attuale", "29");

// aggiungo i dati al documento
try {
       document.putProperties(docContent);
       testo.append("Documento scritto nel database " + dbname + "\n con ID = " + document.getId() + "\n");
        } catch (CouchbaseLiteException e) {
            testo.append("Impossibile memorizzare il documento nel database: " + e.toString());
        }


 

lettura del documento dal database

 

A questo punto basta ricavare l’ID del documento appena creato e memorizzato per ricavarne il contenuto mediante il metodo getDocument(). Ovviamente, trattandosi di database noSQL non è possibile effettuare query complesse basate su join particolari, ma l’oggetto:

 

com.couchbase.lite.Database;

fornisce una serie di metodi per eseguire una grande varietà di operazioni come transazioni, sincronizzazione con server remoti tramite il Sync Gateway, ecc. Per quanto riguarda le funzionalità di tipo map/reduce e le relative query sugli indici e la creazione di viste, Couchbase Lite utilizza lo stesso modello di programmazione che troviamo in Couchbase Server. Rimandiamo ad un prossimo articolo la descrizione di tali funzionalità.


// ottengo l'ID del documento appena creato
String docID = document.getId();
// ricerco il documento nel database
Document retrievedDocument = database.getDocument(docID);
// visualizzo il contenuto del documento appena inserito nel database
testo.append("contenuto del Documento=" + String.valueOf(retrievedDocument.getProperties()) + "\n");

 

modifica del documento

Sfruttando il fatto che i dati sono memorizzati in forma chiave-valore in una mappa, si sostituisce il valore corrispondente alla chiave “messaggio” con il nuovo valore.


 

// modifica del documento
Map<String, Object> updatedProperties = new HashMap<String, Object>();
        updatedProperties.putAll(retrievedDocument.getProperties());
        updatedProperties.put("messaggio", "Testo del documento modificato");
        updatedProperties.put("temperatura attuale", "33");
        try {
            retrievedDocument.putProperties(updatedProperties);
            testo.append("documento modificato=" + String.valueOf(retrievedDocument.getProperties()) + "\n");
        } catch (CouchbaseLiteException e) {
            testo.append("Non riesco a modificare il documento " + e.toString());
        }

 


 

cancellazione del documento

 

// cancellazione del documento
try {
            testo.append("Cancello il documento\n");
            retrievedDocument.delete();
            testo.append("Documento cancellato, status = " + retrievedDocument.isDeleted() + "\n");
        } catch (CouchbaseLiteException e) {
            testo.append("Non riesco a cancellare il documento " + e.toString());
        }

Conclusioni

Eseguendo l’app sull’emulatore infine otterremo una schermata di questo tipo:

Immagine

 

One Comment so far:

  1. […] Esempio pratico di utilizzo di Couchbase Lite Comments are closed. © 2014 COUCHBASE All rights reserved. […]

Lascia un Commento