Ciao a tutti,
rieccoci ad un nuovo appuntamento all’insegna della programmazione in modalita’ grafica su Android. Nel post precedente, che potete leggere qui, abbiamo visto in maniera semplice come accedere alla modalita’ grafica, disegnando a schermo testi ed elementi geometrici. In questo post vedremo come caricare e visualizzare un’immagine.
Come dicevano gli antichi romani, “repetita iuvant” (tradotto “le cose ripetute aiutano”). Rivediamo quindi insieme alcuni passaggi iniziali per poi continuare su questo nuovo argomento.
Il codice che segue si compone di 3 classi inserite in un singolo sorgente. Cominciamo con la classe madre:
[java]
package com.android.ViewImage;
import android.app.Activity;
import android.os.Bundle;
import android.content.Context;
import android.view.View;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.content.res.Resources;
import android.content.res.AssetManager;
import android.util.DisplayMetrics;
import android.content.res.Configuration;
import android.graphics.Canvas;
import android.graphics.Paint;
public class ViewImage extends Activity {
private View2 _view;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
_view = new View2(this);
setContentView(_view);
}
}
[/java]
Come avevamo visto nel precedente articolo, cerchiamo di commentare le varie righe del sorgente. All’inizio del codice si possono vedere gli “import” necessari per poter usare le varie classi di oggetti ed i relativi metodi:
- “import android.app.Activity“: permette di creare la prima finestra dell’applicazione, nella quale si potranno disegnare i vari contenuti;
- “import android.os.Bundle“: permette la gestione delle stringhe e dei tipi di dati;
- “import android.content.Context“: permette la gestione del contesto relativo all’applicazione e l’interfacciamento dei vari componenti.
- “import android.view.View“: permette la gestione e la manipolazione dello schermo mediante la creazione di UI e gestendone gli eventi;
- “import android.graphics.Bitmap“: permette la gestione e la manipolazione di oggetti immagine e relative proprieta’ ;
- “import android.graphics.BitmapFactory“: permette di creare oggetti immagine a partire da determinati tipi di sorgenti (files, risorse, array di bytes);
- “import android.content.res.Resources“: permette di accedere alle risorse messe a disposizione dall’applicazione e mette a disposizione delle API di alto livello con le quali e’ possibile ottenere dati dai vari “assets”;
- “import android.content.res.AssetManager“: permette di accedere ai files degli assets e mette a disposizione delle API che permettono la lettura e la scrittua dei files raw forniti con l’applicazione come semplici “streams” di bytes;
- “import android.util.DisplayMetrics“: permette di accedere alla struttura dati riguardante le proprieta’ del display (grandezza, densita’ e dimensione caratteri);
- “import android.content.res.Configuration“: permette di accedere alla configurazione dei devices. Sia specificata dall’utente, sia legata alle dinamiche di funzionameno dei devices, quali ad esempio l’input da tastiera;
- “import android.graphics.Canvas“: permette la creazione delle sfondo e degli elementi grafici che possono poi essere stampati a schermo;
- “import android.graphics.Paint“: permette di definire gli stili ed i colori desiderati per il disegno degli elementi grafici e testuali;
- “import android.graphics.Color“: permette la gestione e la conversione dei codici colori;
Si continua, quindi, con l’esecuzione del codice:
- Il costruttore “onCreate” inizializza l'”Activity“, crea l’ oggetto “_view” di tipo “View2” (in verita’ “View2” è una classe che estende “View“) e gli passa il contesto dell’applicazione corrente “this” (cioè se stessa);
- Viene instanziato l’oggetto “_view“, che crea l’oggetto “_paint” (instanza della classe “Paint“) e l’oggetto “_bitmapcreator” (instanza della classe “LoadImage“). A quest’ultimo viene passato ancora il contesto dell’applicazione corrente “this” (cioè se stessa). Ecco il codice della seconda classe:
[java]
class View2 extends View {
private Paint _paint;
private LoadImage _bitmapcreator;
private Bitmap _ffbitmap;
public View2(Context context) {
super(context);
_paint = new Paint();
_bitmapcreator = new LoadImage(context);
bitmapLoader();
}
@Override
public void onDraw(Canvas _canvas) {
_canvas.drawBitmap(_ffbitmap, 0, 0, _paint);
}
public void bitmapLoader() {
_bitmapcreator.createResourcesManager();
_ffbitmap = _bitmapcreator.createBitmap();
}
}
[/java]
- Viene creato l’oggetto “_bitmapcreator” (instanza della classe “LoadImage” che estende “BitMapFactory“) ci permettera’ di accedere ai file delle risorse ed agli assets. Con l’oggetto “_bitmapcreator” vengono creati due metodi ad esso correlati, “createResourcesManager” e “createBitmap”;
- Sempre durante la creazione dell’oggetto “_view” viene eseguita la chiamata al metodo “bitmapLoader()“, interno alla classe stessa;
- La classe “bitmapLoader()” chiama il metodo “createResourcesManager” e “createBitmap” (assegnando il valore di ritorno di quest’ultimo all’oggetto di tipo Bitmap “_ffbitmap“) dell’oggetto “_bitmapcreator” (instanza della classe LoadImage);
- Il metodo “createResourcesManager” esegue le seguenti operazioni:
- crea l’oggetto AssetManager “_assmgr” con “_assmgr = _cont.getAssets()” ricanvadolo dal contesto dell’applicazione corrente;
- crea l’ogggeto”_displaym” (parametri fisici del display), instanza della classe DisplayMetrics, con “_config = new Configuration()” e lo inzializza con valori di default (“_displaym.setToDefaults()“);
- crea l’oggetto “_config” (gestore della configurazione del device), instanza della classe Configuration, con “_config = new Configuration()” e lo inzializza con valori di default (“_displaym.setToDefaults()“);
- crea l’oggetto “_res” (permette l’accesso alle risorse a disposizione dell’applicazione), instanza della classe Resources, con “_res = new Resources(_assmgr, _displaym, _config)” sfruttando i relativi oggetti precedentemente creati;
- ricava l’ID della risorsa immagine che vorremmo visualizzare (file caricato nella cartella “res/drawable” del progetto con il nome “final_fantasy_xiii.jpg“), con “_resid = _res.getIdentifier(“final_fantasy_xiii”, _res.getResourceTypeName(R.drawable.final_fantasy_xiii), _res.getResourcePackageName(R.drawable.final_fantasy_xiii))“.
- La classe “bitmapLoader()” chiama il metodo “createBitmap” (assegnando il valore di ritorno di quest’ultimo all’oggetto di tipo Bitmap “_ffbitmap“) dell’oggetto “_bitmapcreator” (instanza della classe LoadImage);
- Il metodo “createBitmap” crea un oggetto “_ffbitmap” di tipo Bitmap con “_ffbitmap = decodeResource(_res, _resid)“, accedendo e decodificando il file salvato tra le risorse. Attenzione: l’oggetto “_ffbitmap” ivi creato, pur essendo dello stesso tipo ed avendo lo stesso nome di quello presente nella classe “View2“, e’ in verita’ differente (essendo stato definito come “private” in ambedue le classi);
- L’oggetto “_ffbitmap” viene ritornato al metodo chiamante con “eturn _ffbitmap“;
- La chiamata “setContentView(_view)” manda in esecuzione e visualizza i risultati dell’elaborazione effettuata dall’oggetto “_view“, instanza della classe “View2” (che estende View). Qui di seguito potete vedere il codice della terza classe:
[java]
class LoadImage extends BitmapFactory {
private Context _cont;
private AssetManager _assmgr;
private Configuration _config;
private DisplayMetrics _displaym;
private Resources _res;
private int _resid;
private Bitmap _ffbitmap;
public LoadImage(Context context) {
_cont = context;
}
public void createResourcesManager() {
_assmgr = _cont.getAssets();
_displaym = new DisplayMetrics();
_displaym.setToDefaults();
_config = new Configuration();
_config.setToDefaults();
_res = new Resources(_assmgr, _displaym, _config);
_resid = _res.getIdentifier(“final_fantasy_xiii”, _res.getResourceTypeName(R.drawable.final_fantasy_xiii), _res.getResourcePackageName(R.drawable.final_fantasy_xiii));
}
public Bitmap createBitmap() {
_ffbitmap = decodeResource(_res, _resid);
return _ffbitmap;
}
}
[/java]
- A questo punto viene eseguito l’Override del metodo “onDraw” della classe “View2” (che estende la classe View) da parte dell’oggetto “_view” che crea il “Canvas” (lo sfondo) dove verra’ visualizzata l’immagine desiderata con:
- “_canvas.drawBitmap(_ffbitmap, 0, 0, _paint)“: stampa a video l’oggetto di tipo immagine definito alle coordinate (0,0), a partire dall’angolo in alto a sinistra.
Il risultato finale delle operazioni e’ il seguente:
Ed ecco stampata la nostra immagine a video! Spero proprio che questo articolo vi piaccia.
Il sorgente lo potete scaricare qui: viewimage
Ciao ed alla prossima!;-)