Coop Sociali Lombarde è l’app per android che consente di ricercare le cooperative sociali presenti sul territorio lombardo.

L’app localizza su google map le cooperative sociali lombarde.
I dati vengono recuperati dal servizio open data offerto da Regione Lombardia, consultabile all’indirizzo
https://www.dati.lombardia.it/resource/tuar-wxya.json.
Per ciascuna cooperativa mostra le informazioni di maggiore interesse per l’utente.
E’ presente una sezione che estrae delle statistiche e la possibilità di aggiornare i dati in ogni momento.
Nei rilasci verranno estese le funzionalità messe a disposizione dall’app.

RSA Lombardia è la l’app per android che consente di ricercare le RSA presenti sul territorio lombardo.

L’app localizza su google map le residenze sanitario assistenziali lombarde. I dati vengono recuperati dal servizio open data offerto da Regione Lombardia, consultabile all’indirizzo
https://www.dati.lombardia.it/Famiglia/Elenco-RSA-Accreditate/vef4-8fnp.
Per ciascuna residenza mostra le informazioni di maggiore interesse per l’utente.
E’ presente una sezione che estrae delle statistiche e la possibilità di aggiornare i dati in ogni momento.
Nei rilasci verranno estese le funzionalità messe a disposizione dall’app.

Agriturimi Lombardia è la nuova app sviluppata per android che consente di ricercare agevolmente tutti gli agriturismi presenti in Lombardia.Gli agriturismi vengono recuperati dal servizio open data esposto da Regione Lombardia e geolocalizzati tramite le api di google maps.

Per ogni agriturismo l’app recupera i dati identificativi, i dati di contatto e mostra le attività svolte dall’agriturismo. L’app consente di contattare telefonicamente l’agriturismo avviando in automatico il servizio di call, di inviare mail e di accedere al sito web se presente.

L’app presenta una base dati che consente di implementare una ricerca libera tra le varie informazioni del database. E’ inoltre presente un modulo statistiche che consente di estrarre una serie di statistiche di maggior interesse per l’utente.

L’app è disponibile qui per il download.

Prevediamo tre campi obbligatori:

• name
• city
• address

Questi 3 campi vengono definiti come EditText

<EditText android:id="@+id/cityMarketValue" 
android:inputType="textCapWords" />

L’attributo inputType impone il controllo sul formato del campo. Al salvataggio del form il sistema invoca la funzione di validazione che verificherà se il campo è valorizzato o no tramite la routine

Boolean controllo = true;
if (name.getText().toString().length()==0) {
controllo = false;
name.setError(getResources().getString(R.string.mandatory));
}
if (city.getText().toString().length()==0) {
controllo = false;
city.setError(getResources().getString(R.string.mandatory));
}
if (address.getText().toString().length()==0) {
controllo = false;
address.setError(getResources().getString(R.string.mandatory));
}
return controllo;

Qualora il controllo fallisse la classe  EditText mette a disposizione il metodo setErrorr che consente di abilitare il messaggio di errore attivo sul singolo campo, come si può vedere in foto

Per poter accedere al nostro database occorre estendere la classe SQLiteOpenHelper, che prevede l’implementazione dei metodi creazione del database.

public class DatabaseHelper extends SQLiteOpenHelper {

public static final String DB = "gestoremarket";
public static final int SCHEMA_VERSION = 1;
public static final String DATABASE_NAME = "gestoremarket.db";

public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}

@Override
public void onCreate(SQLiteDatabase db) {}

@Override
public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {}

}

Il costruttore prevede la creazione di un database con una determinata versione e sono previsti i metodi che verranno lanciati alla creazione del database e/o al suo aggiornamento., All’interno dei metodi è possibile lanciare degli script sql per aggiornare il database.

A questo punto dobbiamo definire la classe per la gestione della nostra tabella, tale classe implementa l’interfaccia BaseColumns, che prevede la presenza di una primary key _ID (tale approccio non è obbligatorio, ma è consigliato da Google per uno sviluppo più armonico)

Nel nostro caso prevediamo una classe così fatta

public class MarketTable implements BaseColumns {

public static String TABLE_NAME = "MARKET";
public static String NAME = "NAME";
public static String CITY = "CITY";
public static String ADDRESS = "ADDRESS";
public static String CANCELLATO = "CANCELLATO";

public static String[] COLUMNS = new String[] {_ID, NAME, CITY, ADDRESS, CANCELLATO };

}

Non resta che definire la classe DAO responsabile dei metodi di lettura e scrittura sul nostro db

public class MarketDao {

private DatabaseHelper databaseHelper;

public MarketDao(Context context) {
databaseHelper = new DatabaseHelper(context);
}

public List<Market> getAll() {
 
SQLiteDatabase database = databaseHelper.getReadableDatabase();
 
 List<Market> list = new ArrayList<Market>();
 
 String sql = 
 String.format("select " +
 "market._id, " +
 "market.name, " +
 "market.city, " +
 "market.address " +
 "from market " +
 "where market.cancellato = 0") ;
 Log.i(DatabaseHelper.DATABASE_NAME, sql); 
 Cursor cursor = database.rawQuery(sql, null);
 
 cursor.moveToFirst();
 while (!cursor.isAfterLast()) {
 Market market = getMarket(cursor);
 list.add(market);
 cursor.moveToNext();
 }
 
 cursor.close();
 
 database.close();
 
 return list;
}

public void delete(Long id) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
String sql = 
String.format("update market " +
"set cancellato = 1 " +
" where _id = %d ", id) ;
Log.i(DatabaseHelper.DATABASE_NAME, sql);
database.execSQL(sql);
database.close();
}

public void save(Market item) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = creaContentValues(item);
if (item.getId()==null) {
long insertOrThrow = database.insertOrThrow(MarketTable.TABLE_NAME, null, contentValues);
item.setId(insertOrThrow);
} else
database.update(MarketTable.TABLE_NAME, contentValues, " _id = " + item.getId(), null);
database.close();
}

private ContentValues creaContentValues(Market item) {
ContentValues contentValues = new ContentValues();
contentValues.put(MarketTable._ID, item.getId());
contentValues.put(MarketTable.NAME, item.getName());
contentValues.put(MarketTable.CANCELLATO, item.getCancellato());
contentValues.put(MarketTable.CITY, item.getCity());
contentValues.put(MarketTable.ADDRESS, item.getAddress());
return contentValues;
}
}

Dall’analisi della classe si vede come la classe Helper permetta di accedere al database in lettura e/o scrittura tramite i metodi

SQLiteDatabase database = databaseHelper.getWritableDatabase();

SQLiteDatabase database = databaseHelper.getReadableDatabase();

Ottenuta l’istanza del database la classe mette a disposizione dei metodi per la gestione dei dati, che permettono di eseguire del codice sql oppure tramite l’uso di classi container, tipo ContentValues, che consentono l’interazione con il database anche con una limitata conoscenza di sql.

Buona sperimentazione.

Nell’action bar sono individuate 4 aree funzionali con queste caratteristichie:

1. contiene l’icona dell’app ed eventualmente il pulsante Up per tornare all’activity precedente
2. permette di navigare tra i contenuti di un app
3. contiene i pulsanti che si attivano in base al contesto
4. è la cosidetta area di overflow, contiene in formato lista, le azioni che non sono visualizzabili per mancanza di spazio

Qualora lo spazio non sia sufficiente le azioni sono disponibili nell’area di overflow, oppure è possibile attivare una bottom area in cui tutto lo spazio a disposizione è occupato dalle azioni rimaste.

Passiamo alla nostra app e attiviamo la action bar. Nel nostro esempio l’app deve essere compatibile con dispositivi con Android 2.1, pertanto definiamo la nostra activity principale così

public class MainActivity extends ActionBarActivity {}

dove ActionBarActivity è una classe della Support Library disponibile nel package android.support.v7.app;

A questo punto l’action bar è già disponibile e mostra la nostra icona e nient’altro. Qualora volessimo rimuoverla è sufficiente nasconderla in modo semplice:

ActionBar actionBar = getSupportActionBar(); 
actionBar.hide();

Adesso abilitiamo il pulsante di Up che consente di gestire la navigazione ed accedere alle funzioni precedentemente visualizzate. Per farlo sono sufficienti due comandi:

getSupportActionBar().setHomeButtonEnabled(true);

(abilita il comportamento sull’icona dell’app )

o

getSupportActionBar().setDisplayHomeAsUpEnabled(true);

(abilita una icona dedicata )

Per gestire il comportamento occorre implementare il metodo onOptionsItemSelected(MenuItem item) nella nostra activity e in particolare per gestire l’evento occorre implementare qualcosa di simile:

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) { case android.R.id.home: finish(); }
return super.onOptionsItemSelected(item);
}

In questo caso mi limito a chiudere l’app, quello che è importante notare è come il pulsante di Home sia identificato univocamente tramite la costante android.R.id.home

Se adesso volessimo aggiungere dei pulsanti occorre definire un menu in formato xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"   
xmlns:yourapp="http://schemas.android.com/apk/res-auto" >
<item android:id="@+id/edit" 
android:title="@string/edit" 
android:icon="@drawable/ic_action_edit" 
yourapp:showAsAction="ifRoom" />
<item android:id="@+id/delete" 
android:title="@string/delete" 
android:icon="@drawable/ic_action_cancel" 
yourapp:showAsAction="ifRoom" />
</menu>

Per gestire l’action bar Big G ci mette a disposizione un set di icone per gli usi più comuni disponibili qui. E’ interessante notare l’attributo showAsAction, che stabilisce il comportamento del pulsante. Big G consiglia di usare il valore ifRoom con cui consentiamo al sistema di spostare il pulsante nell’area di overflow qualora lo spazio non sia sufficiente.

A questo per abilitare il pulsante implementiamo il metodo onCreateOptionsMenu, in questo caso mi trovo all’interno di un fragment

@Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { inflater.inflate(R.menu.action_list_market, menu); super.onCreateOptionsMenu(menu, inflater); }

e posso pilotare la sua comparsa tramite il comando setHasOptionsMenu, che mi permette di attivarlo in base alle mie esigenze.

Nel mio caso ho collegato il menù ad una lista in modo che si attivi alla selezione di un elemento.

In maniera dichiarativa occorre definire per il nostro spinner la sua fonte dati, disponibile in una delle risorse xml. Ad esempio possiamo dichiarare uno spinner che contiene l’elenco degli anni in questo modo:

<Spinner 
android:id="@+id/spinnerAnnoSottoscrizione" 
style="@style/Spinner"  
android:entries="@array/annoIscrizione" />

l’attributo id individua unicamente il nostro spinner all’interno dell’app, l’attributo style contiene le specifiche grafiche dell’oggetto e il tag entries individua l’elenco dei valori che lo spinner può assumere. Tale elenco è definito nel file strings.xml

<string-array name="annoIscrizioneLabel">
<item>2012</item>
<item>2011</item>
</string-array>

In questo modo abbiamo definito uno spinner che conterrà due voci (2012 e 2011), selezionabili dall’utente.

Possiamo ottenere lo stesso risultato programmaticamente in questo modo.

ArrayAdapter<String> adapter= 
new ArrayAdapter<String>
(this,  android.R.layout.simple_spinner_item  , 
getResources().getStringArray(R.array.annoIscrizioneLabel));
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
Spinner spinner =(Spinner) findViewById(R.id.annoIscrizioneLabel);
spinner.setAdapter( adapter );

All’interno della nostra activity recuperiamo il nostro spinner e settiamo l’adapter che fa al caso nostro. L’Adapter è un oggetto che definisce la logica di visualizzazione dello spinner e dei suoi elementi. In questo esempio ho usato il simple_spinner_item, che definisce l’aspetto grafico dello spinner, e il simple_spinner_dropdown_item, che definisce l’aspetto grafico dell’elenco mostrato per la selezione.

Se occorre modificare l’aspetto dello spinner o rendere dinamico l’elenco delle voci da mostrare la gestione programmatica è la scelta obbligata.

Android mette a disposizione adapter che soddisfano la maggior parte delle nostre esigenze, ma se il nostro layout è complesso o la logica di business è più evoluta possiamo definire un nostro adapter, estendendo una delle classi già presenti.

Per gestire l’effetto di selezione dobbiamo definire un listener, tramite la chiamata

spinner .setOnItemSelectedListener(this);

Con questa chiamata sto dicendo che l’activity è responsabile di implementare l’interfaccia OnItemSelectedListener e di conseguenza il metodo onItemSelected. Avrei potuto in alternativa definire una inner class e demandare a lei la gestione degli eventi di selezione. Personalmente scelgo cosa fare in base alla complessità della classe.

Il listener (sia inner class che activity) si attiva per ogni evento di selezione. Fate attenzione, perchè si attiva anche allo start della nostra activity, quando viene popolato il nostro oggetto.

Buona sperimentazione.

Sulle modalità per integrare un banner, rimando al sito di AdMob, recentemente acquisito da Google, dove potete scaricare l’SDK da integrare.

E’ mio interesse mostrare le modalità per integrare il banner all’interno dell’app, in modo da rendere l’operazione facile e indolore.

Approccio Dichiarativo

E’ possibile inserire direttamente il seguente blocco xml all’interno del nostro layout. Il parametro keywords deve essere valorizzato con l’ID Editore rilasciato da AdMob all’atto della creazione del profilo della nostra app.

<com.admob.android.ads.AdView
android:id="@+id/ad"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
app:keywords="xxxxxxxxxxx" />

In questo modo alla visualizzazione del nostro layout verrà anche visualizzato il banner. Con questo approccio, se vogliamo avere il banner in più activity della nostra app, dobbiamo inserire il blocco in ogni layout relativo all’activity.

Approccio Programmatico

E’ possibile gestire il banner programmaticamente, ovvero instanziare l’oggetto e configurarlo in uno dei metodi legati al ciclo di vita della nostra Activity, tipicamente il metodo onCreate.

AdView adView = new AdView(this, AdSize.BANNER, Costanti.MY_AD_UNIT_ID);
LinearLayout layout = (LinearLayout) findViewById(R.id.linearLayout);
layout.addView(adView);
AdRequest request = new AdRequest();
adView.loadAd(request);

Con questo approccio possiamo strutturare le nostre classi in modo da rendere trasparente per le nostre activity l’invocazione del banner, ad esempio tramite una activity astratta responsabile della gestione del banner, da cui ereditare le activity responsabili della logica della nostro app.

Tipici Problemi

Il problema che si può riscontrare è la mancata visualizzazione del banner. Fortunamente i log di Android ci danno tutte le indicazioni sulle possibili cause. Un motivo può essere il layout con spazio insufficiente per mostrare il banner e questo avviene tipicamente su dispositivi con display piccoli, dove abbiamo previsto di usare del padding. In questo caso l’errore che Android mostra è Not enough space to show ad! Wants: <320, 50>, Has: <270, 430>. Il problema si risolve agganciando il nostro banner al layout con una dimensione sufficiente a contenere il banner.

Altro problema è la posizione del banner, che può essere infelice o nella posizione non attesa. Per assicurarci la posizione desiderata possiamo usare il RelativeLayout e posizionare il banner nella posizione desiderata. Nell’esempio di sotto ho posizionato il banner in basso rispetto al container e l’oggetto ScrollView al di sopra del banner. In questo modo garantiamo la visualizzazione del banner nella posizione desiderata.

<RelativeLayout 
xmlns:android="http://schemas.android.com/apk/res/android"    >
<LinearLayout android:layout_alignParentBottom="true" />
<ScrollView android:layout_above="@id/mainAdv" >
</RelativeLayout>