Ogni anno vengono effettuati miliardi di download di applicazioni mobile da milioni di utenti sparsi per il mondo, ad un punto tale che molti paragonano il creare un app e pubblicarla nei vari stores ad una vera propria miniera d’oro. Ed il numero sta crescendo a dismisura.

La stima dei numero di download di applicazioni mobile nei prossimi anni

Tuttavia, se in alcuni casi gli app stores hanno rappresentato (e rappresentano ancora) una grandissima fonte di ricchezza (come Ruzzle o FlappyBird, tanto per citare le prime app che mi vengono in mente), per ogni app di successo ce ne sono migliaia che non riescono a decollare.

Il fatto è che quando si parla di creare un app, puntualmente ci vengono presentati solamente quei progetti che hanno raggiunto la vetta. E tutte quelle applicazioni che al contrario hanno fallito?

La dura verità: le app che non hanno successo

In particolare, di tutti i milioni di applicazioni scaricate, solo un piccolissima parte (circa il 5/10%) viene effettivamente utilizzata dopo la prima volta.

Quante volte ti sarà capitato di scaricare un’app nel tuo smartphone o tablet, dargli un’occhiata veloce, per poi non aprirla mai più, o addirittura cancellarla?

A seconda dell’utente, la maggior parte delle applicazioni vengono completamente ignorate o cancellate dopo il primo utilizzo.

Il mio iPhone è continuamente colmo di applicazioni di vario tipo, ed ogni giorno mi presenta minimo 50 notifiche di aggiornamenti da effettuare per applicazioni che non ricordo nemmeno di avere.

Così, periodicamente, appena riesco a ritagliarmi un attimo di tempo, mi metto a cancellare tutte quelle app che non mi piacciono o che non utilizzo.

Ma dopo qualche giro di esplorazione su App Store, sono di nuovo al punto di partenza.

E credo che questo sia lo stesso scenario della maggior parte degli utenti che possiedono un dispositivo mobile.

Da cosa dipende?

Semplice: dall’utilità dell’applicazione.

Prima di perdere tempo con la creazione di un’applicazione, cerca di capire se è effettivamente utile

Verifica l’utilità della tua applicazione

Molti vengono a chiederemi delle consulenze per progetti riguardanti applicazioni mobile che risultano veramente inutili, come se si dimenticassero che qualsiasi smartpthone o tablet possiede un browser.

Ora ti chiederai: “cosa c’entra il browser con l’app?”

C’entra eccome.

Uno dei miei clienti (per il quale ho realizzato un e-commerce con WordPress) sapendo che oltre a siti ed applicazioni web mi occupo anche della realizzazione di mobile app,  qualche tempo fa si era fissato con l’idea di voler creare a tutti i costi un’applicazione mobile che offrisse all’utente tutte le funzionalità dell’e-commerce che gli avevo già sviluppato.

Che senso avrebbe avuto realizzare l’applicazione di un’e-commerce già ottimizzato per dispositivi mobile, e quindi già facilmente fruibile da un normale mobile browser?

Provai a spiegargli l’inutilità della cosa, ma non mollò la presa, nemmeno dopo avergli mostrato il mio preventivo.

Morale: il cliente finì per spendere alcune migliaia di euro per un’ottima e funzionale applicazione, ma che non venne mai utilizzata da nessuno (dei circa 900 utenti che avevano effettuato il download nell’arco di un anno, non registrammo nemmeno un acquisto da dispositivi mobili).

Completo fallimento.

Pensaci bene: prima di metterti a testa bassa e impegnarti nella realizzazione di un’applicazione mobile, cerca di capire quali funzionalità e contenuti deve avere.

Se si tratta di elementi disponibili anche su un normale web browser, allora la verità è che non hai bisogno di un’applicazione mobile, o almeno di un’applicazione da distribuire sui vari stores.

Molte delle funzionalità come la geolocalizzazione o il salvataggio dei dati (leggi questo articolo oppure questo per saperne di più) possono essere implementate anche in normali siti web.

Una buona soluzione che personalmente adotto molto spesso è quella di creare una versione mobile del sito web, utilizzando delle tecniche per realizzare HTML Mobile app fluide ed altamente performanti.

In questo modo è possibile creare un’applicazione mobile a tutti gli effetti, ma che sia accessibile anche da un normale browser mobile, e che allo stesso tempo possa essere facilmente trasformata in un’applicazione ibrida, grazie adei tools come Phonegap o Titanium.

È la stessa cosa che ha fatto per esempio Financial Times con la sua applicazione mobile.

Conclusioni: in base a quali fattori puoi capire se tu o il tuo cliente avete veramente bisogno di un app?

Per capire se hai veramente bisogno di creare un’applicazione da poter scaricare nei vari stores, i metri di giudizio ai quali dovresti affidarti e su cui focalizzarti sono:

1. posso fornire all’utente le stesse funzionalità con un normale sito web responsive?
2. quanto tempo, risorse e denaro dovrei impiegare per creare un app e quali per creare un sito web che offra le stesse funzionalità?
3. qual è lo scopo finale (effettivo) del tuo progetto/lavoro?
4. quali sono le reali esigenze dell’utente?

Più semplicemente, se hai bisogno di offrire un prodotto che deve essere accessibile da diversi tipi di dispositivi (sia da quelli desktop che da quelli quelli mobili) allora la miglior cosa è sicuramente optare per una versione responsive del sito web.

Nei vari app stores possiamo trovare un numero sempre più grande di applicazioni che integrano il login di Facebook al proprio interno per dare la possibilità all’utente di effettuare l’accesso molto più comodamente e velocemente, evitando di costringerlo ad iscriversi ad un nuovo servizio, con tutti i rischi che tale operazione comporta (come per esempio perdere una grande fetta di utenti).

Per aggiungere questa funzionalità nei miei progetti da pubblicare come applicazioni ibride (mobile app in HTML5 “inglobate” all’interno di app native), ho sempre utilizzato il plugin Phonegap “Phonegap Facebook Plugin“, che utilizza una combinazione dei “moduli” nativo e javascript messi a disposizione dall’SDK di Facebook.

Grazie al Facebook Plugin di Phonegap è quindi possibile “manovrare” il login nativo mediante delle semplici API javascript.

 

In fondo è proprio questo lo scopo dei plugin per Phonegap, ed anche un dei vantaggi di sviluppare mobile app in HTML5: quello di riuscire ad accedere alle funzionalità native del dispositivo direttamente da codice Javascript.

Tuttavia questa strada porta alcuni svantaggi, come quello di dover comunque dipendere da un plugin di terze parti, oppure quello di non poter essere utilizzato nel caso in cui non volessimo distribuire la nostra applicazione HTML5-CSS3-Javascript sotto forma di app ibrida (compilandola quindi con strumenti come Xcode o Eclipse), ma volessimo renderla accessibile in remoto, collegandosi semplicemente ad una pagina web (come per esempio hanno fatto Financial Times e Forecast.io con le loro HTML5 mobile app, vedi immagine seguente).

 

Le applicazioni HTML5 ottimizzate per mobile di Financial Times e Forecast.io

---

#facebook #mobileapp login – Come implementarlo in #HTML5
Click To Tweet

---

Facebook mobile login: una strada alternativa

In questo articolo ti voglio mostrare una risorsa molto interessante, che ho trovato utilissima  per poter implementare un Facebook mobile login su di un’HTML5 mobile app senza necessariamente utilizzare dei tools nativi, come il plugin per Phonegap sopra citato.

Si tratta di una micro-libreria Javascript realizzata da Christophe Coenraets, brillante sviluppatore professionista che lavora per Salesforce.com (ti consiglio vivamente di seguirlo, se sei interessato a come creare un app in HTML5, CSS3 e Javascript), il cui lavoro è principalmente focalizzato sullo sviluppo di applicazioni mobile web-based ( quindi single-page-application).

La libreria si chiama OpenFB e risulta molto utile per poter implementare il Facebook mobile login sulla propria applicazione, senza affidarsi necessariamente a dei componenti nativi.

Coenraets, che avendo la necessità di implementare questa funzionalità in uno dei suoi lavori ha pensato di adattarla in una soluzione standard in modo tale che tutti potessero usufruirne, ha dato la possibilità a chiunque di inserire facilmente il login di Facebook nel proprio progetto.

---

#facebook #mobileapp login – Come implementarlo in #HTML5
Click To Tweet

---

Facebook mobile login: come si usa la libreria OpenFB

Utilizzare la libreria si presenta piuttosto semplice, vediamo come funziona:

Semplice Login:

openFB.login(scope, successHandler, errorHandler);

Riprendere la lista degli amici dell’utente:

openFB.api({path: '/me/friends', success: successHandler, error: errorHandler});

Pubblicare un post nella bacheca dell’utente:

openFB.api(
{
     method: 'POST',
     path: '/me/feed',
     params: {
          message: 'Messaggio di prova per le API di Facebook'
     },
     success: successHandler,
     error: errorHandler
});

Facebook mobile login: primi passi

Per integrare la risorsa nei tuoi progetti hai solamente bisogno di:

1. Creare un’applicazione Facebook da associare al tuo progetto recandoti a questo link
2. Copiare l’ID dell’applicazione Facebook appena creata ed usarlo come primo parametro della funzione di inizializzazione della libreria OpenFB posta nella pagina principale della tua Single Page Application (index.html): openFB.init().
3. Eseguire la pagina index.html da un indirizzo che corrisponda a quello inserito al momento della creazione dell’applicazione Facebook, in corrispondenza del parametro “Valid OAuth redirect URIs” situato nella scheda “Settings”.

---

#facebook #mobileapp login – Come implementarlo in #HTML5
Click To Tweet

---

Facebook mobile login: conclusioni

Come vedi il funzionamento è piuttosto semplice, e chiunque può facilmente integrarlo nella propria applicazione, app che non deve essere necessariamente distribuita sotto forma di app ibrida/nativa ma che può essere benissimo pubblicata online.

Infatti l’autore della libreria mette a disposizione anche la demo di un’applicazione-base che puoi consultare per capire meglio come integrare OpenFB nella tua Single Mobile Application; la demo che funziona anche se visualizzata con un normale browser, sia mobile che desktop.

In particolare, la libreria è stata pensata per fare in modo che il Facebook mobile login funzioni sia nel caso in cui il progetto preveda l’utilizzo di Phonegap (quindi nel caso di un’applicazione ibrida), sia nel caso di applicazioni “browser-based“: se eseguita con Cordova essa sfrutta una web view nativa, mentre se eseguita su browser, il login sarà mostrato attraverso una finestra di popup.

Io l’ho già implementata in una mia applicazione, e la trovo molto utile.

Ma mi piacerebbe sapere il tuo parere: cosa ne pensi?

Fammelo sapere nei commenti!

PS. Quasi dimenticavo: ecco il link all’ottimo ed utilissimo articolo originale di Coenraets, ai sorgenti e alla demo:

Uno dei dilemmi più frequenti su cui si imbatte chiunque decida di affacciarsi sul mondo dello sviluppo mobile è sicuramente quello su come creare un app: “quale sistema di sviluppo dovrei adottare? E’ meglio cominciare con il codice nativo oppure affidarsi all’HTML?“.

In effetti è una domanda che i miei lettori mi pongono molto frequentemente.

Come avrai notato personalmente prediligo la via dell’HTML5, CSS3 e Javascript per realizzare i miei progetti destinati a dispositivi mobile. Ma quella che per me è la strada principale, non è detto che lo debba essere per gli altri sviluppatori.

Ognuno, durante il proprio percorso formativo/professionale, capita davanti a situazioni ed ostacoli differenti, una miriade di combinazioni che lo portano a prendere determinate decisioni invece che altre.

E’ così anche per quanto riguarda la decisione sul linguaggio da utilizzare per realizzare una mobileapp.

La risposta non è delle più semplici, ma dipende da numerosi fattori. In questo articolo vedremo quali secondo me dovresti considerare per prendere la tua decisione.

---

Come creare un #mobileapp – #HTML5 o linguaggio nativo?
Click To Tweet

---

Il settore di provenienza

La cosa incide maggiormente sulla decisione da prendere per quanto riguarda la metodologia di sviluppo di una mobile app è dal mio punto di vista il settore professionale al quale apparteniamo.

Se non sei un ragazzo che è appena uscito da scuola o dall’università e vuole iniziare a crearsi una carriera nel mondo delle mobile app, allora dovresti decidere sulla base della tua principale professione attuale e le tue esperienze lavorative.

Chi come me opera nel campo del web design e delle web application, ed ha cominciato le sue esperienze professionali in questo settore, allora sarà molto più facile che scelga la strada dell‘HTML5, il CSS3 ed il Javascript, linguaggi con cui ha già molta familiarità e tra cui sa muoversi molto bene.

Come ti ho mostrato in altri articoli, nello sviluppo di HTML Mobile App bisogna fare attenzione ad elementi come performance e fluidità, per non rischiare di rilasciare un prodotto di scarso valore e con una user-experience che non si avvicina nemmeno minimamente a quella delle applicazioni native.

Tuttavia è molto più facile affidarsi a linguaggi che già conosciamo piuttosto che studiarne di nuovi.

Per approfondire il discorso delle perfomance e fluidità, ti consiglio di leggere questi articoli:

• Web e Mobile App fluide con layer e hardware acceleration
• Le 6 migliori tecniche per aumentare le performance di un’ HTML Mobile App

Mentre per una serie di tutorial pratici su come creare un app in HTML5, puoi consultare la sezione tutorials di questo blog.

Per un individuo che invece “parte da zero”, e vuole specializzarsi specificatamente nello sviluppo di mobile app, allora quella del linguaggio nativo potrebbe essere la strada che fa più al caso suo.

E’ molto difficile pensare infatti che gli possa arrivare a padroneggiare molto bene sia linguaggi web che linguaggi nativi (i quali possono essere più di uno, se si decide di sviluppare per più di una piattaforma: Objective-C, Java ecc.) in modo parallelo.

Non sto dicendo che è impossibile, ma sicuramente è molto meno probabile.

Il target dell’applicazione

La scelta del linguaggio è molte volte determinata anche dal target dei dispositivi per i quali decidiamo di rendere disponibile la nuova applicazione.

Se hai bisogno di pubblicare una determinata applicazione solamente per iOS o per Android, per esempio, allora potresti decidere si svilupparla interamente con linguaggio nativo.

Ovviamente ciò va considerato anche in base al futuro: c’è la possibilità che questa app possa più avanti essere resa disponibile anche per altri tipi di sistemi operativi?

Nel caso in cui abbiamo tale necessità o vogliamo che fin dall’inizio l’applicazione sia fruibile da più di un sistema operativo, allora la decisione più opportuna sarebbe quella di optare per l’HTML5.

La tipologia dell’applicazione

Un altro fattore influenzante da sottolineare è quello delle funzionalità e del tipo di interfaccia che l’applicazione deve avere.

Se hai la necessità di creare un videogioco molto complesso o un’interfaccia con una dinamica particolare, allora dovresti usare il linguaggio nativo, che ti consentirà di produrre un prodotto più leggero e molto meno dispendioso in termini di processore, oltre che più performante.

Se invece la tua necessità è quella di realizzare un’interfaccia “standard” con delle normali liste, delle schermate ad entrata che non prevedono effetti troppo complessi (con i CSS3 è possibile realizzare degli effetti “elaborati” che risultano comunque molto performanti, come pop, slide, flip, skew ecc.), headers, tab-bar ecc., allora potremmo portare avanti il progetto tramite linguaggi web-based.

Se vuoi sapere come realizzare gli effetti delle interfacce native con HTML5 e CSS3 allora resta aggiornato sul mio e-book “HTML Mobile Accelerato“, in cui ti mostrerò come realizzare un sistema di animazioni performante che non ha nulla da invidiare ad un’applicazione nativa:

 

 

---

Come creare un #mobileapp – #HTML5 o linguaggio nativo?
Click To Tweet

---

Come creare un app: I benefici dell’HTML5

Vediamo i principali benefici dei linguaggi nella realizzazione di mobile app con linguaggi web-based.

• Centralizzare il processo di sviluppo. Se nel caso dei linguaggi nativi siamo costretti a sviluppare la stessa applicazione da zero per ogni sistema operativo per il quale decidiamo di renderla disponibile, nel caso di mobile app in HTML5, CSS3  e Javascript possiamo utilizzare lo stesso progetto per tutte le piattaforme (apportando qualche piccolo aggiustamento, se vengono utilizzati dei plugin personalizzati per l’accesso a funzionalità del dispositivo, come vibrazione, bussola ecc.)
• Velocità e facilità di sviluppo. Come accennato in precedenza, per chi padroneggia molto bene il linguaggi web, è più facile e veloce realizzare l’interfaccia di una mobile app. In rete si possono inoltre trovare sempre più framework che adottano la filosofia del “mobile first“, e velocizzano ulteriormente le varie fasi di sviluppo
• La libertà negli aggiornamenti. Quando decidiamo di pubblicare un’applicazione su App Store, PlayStore e gli store delle altre piattaforme, siamo costretti ad attendere lunghi tempi di approvazione (2 settimane nel caso di App Store) prima che essa venga approvata. Lo stesso vale per ogni aggiornamento che invieremo. Con le HTML5 Mobile app, è possibile bypassare questo processo impostando un sistema che all’avvio dell’applicazione controlla il server per verificare la disponibilità di nuovi aggiornamenti, ed eventualmente effettuarne il download.

Come creare un app: i benefici del codice nativo

Vediamo quali sono invece i benefici dello sviluppo con codice nativo:

• Maggior facilità di accesso alle funzionalità native. Se da un lato nel caso di mobile app web-based abbiamo dei tools (come Phonegap o Appcelerator) che ci offrono la possibilità di accedere e controllare alcune funzionalità native del dispositivo grazie a degli appositi plugin, è anche vero che il loro utilizzo è molte volte limitato, senza contare il fatto che per alcune delle funzionalità non esistono plugin. Con il linguaggio nativo, abbiamo piena libertà e maggior facilità di accesso a tutte le funzionalità del dispositivo.
• Possibilità di realizzare interfacce più complesse. Come già accennato in precedenza, sviluppando con linguaggio nativo è più facile creare una user-experience molto più avanzata ed interattiva, grazie anche alla possibilità di utilizzare i controlli e gli effetti messi a disposizione dello sviluppatore.
• La qualità dei controlli. Abbiamo detto che nel caso di HTML5 mobile app possiamo sfruttare molti framework CSS mobile-first. In alternativa possiamo anche scrivere personalmente le istruzioni CSS per ricreare gli stessi tipi di controlli nativi (come pulsanti, header, tab-bar, icone ecc.). Tuttavia la qualità di tali controlli non è ancora allo stesso livello dei UI-Kit da cui possiamo attingere con grazie ai linguaggi nativi.

---

Come creare un #mobileapp – #HTML5 o linguaggio nativo?
Click To Tweet

---

Conclusioni

Il linguaggio da adottare per creare un app dipende da numerosi fattori, ma credo che il principale sia la predisposizione e la familiarità che ogni sviluppatore ha con i vari tipi di linguaggi.

Personalmente sono molto più orientato verso i linguaggi web e l’HTML5, anche perchè mi sono specializzato fin dal principio nella realizzazione di siti web e soprattutto, di applicazioni web.

E tu? Di quale settore fai parte ? Anche tu sei un web designer e sei più predisposto ai linguaggi web, oppure sei più indirizzato verso linguaggi nativi?

O ancora, sei un web designer a cui piace spaziare a 360° e conosci sia i linguaggi nativi che quelli web?

Fammelo sapere nei commenti o inviami una mail, sono curioso di sapere quale metodologia stai adottando o ti piacerebbe adottare, e magari quali sono i tuoi obiettivi in merito.

 

In questa mini-guida divisa in due parti, ti ho mostrato come gestire i dati di un’applicazione mobile o di una web app sfruttando il Web SQL, un tipo di database che permette di salvare record in locale sul dispositivo utilizzato dall’utente, tramite istruzioni SQL, linguaggio ben conosciuto dalla maggior parte dei web designers.

I metodi di salvataggio lato-client sono molto utili nel caso di applicazioni mobile sviluppate in HTML5, CSS3 e Javascript, ed è per questo che oggi voglio condividere con te un tutorial incentrato su un’altro sistema di salvataggio dati lato-client, il localStorage.

L’idea di scrivere questo post nasce dalla domanda di uno dei lettori di upCreative.net (a proposito, ringrazio sixdas per lo spunto) su come poter creare l’interfaccia di un’applicazione mobile che mostri all’utente una schermata di login oppure il contenuto dell’app, a seconda se è stato effettuato o meno il login con username e password.

Alle fine dell’articolo potrai trovare il link per il download dei file sorgenti.

---

Come creare la view di login in un #HTML5 #mobileapp con #backbonejs
Click To Tweet

---

Tutorial su come creare un app: l’obiettivo finale

In altre parole, all’avvio dell’applicazione controlleremo se nel localStorage è stata salvata una variabile che identifica l’username dell’utente: se è presente lo rimanderemo ai contenuti dell’applicazione, altrimenti visualizzeremo la schermata attraverso la quale egli potrà inserire i propri dati, che useremo poi per impostare la variabile di controllo nel localStorage.

Come view interna dell’app, quella accessibile solamente una volta effettuato il login, useremo la stessa del tutorial “Semplice Mobile App con Bootstrap Ratchet e Backbone.js” che ti ho mostrato in precedenza, che sarà quindi utilizzato come “base” per questo esperimento (in sostanza, quello che faremo è aggiungere la parte di login).

Il localStorage, di cui avevo parlato in questo articolo che ho scritto per YourInspirationWeb.com, è un sistema di salvataggio dati non-relazionale, che analogamente all’indexedDB, si basa sul concetto di coppia chiave-valore, per cui in corrispondenza di ogni chiave possiamo salvare qualsiasi tipo di variabile javascript: una stringa, un numero, un oggetto JSON e così via.

Noi lo utilizzeremo semplicemente per salvare l’username dell’utente in corrispondenza della chiave “user“, in modo da poter ricontrollare quella variabile ogni volta che l’applicazione viene avviata, ovvero ogni volta che il documento della pagina index.html viene ricaricato.

La view del login

L’esperimento precedente, basato su Backbone.js, era strutturato in questo modo:

Quello che dobbiamo fare è aggiungere la view di login, esattamente allo stesso livello DOM della view principale mostrata nell’immagine con il colore azzurro, ed effettuare il .render() di una o dell’altra, a seconda del contenuto della variabile del locaStorage.

Come prima cosa definiamo l’oggetto Backbone.View all’interno del file demo.js, il file javascript demo.js, in cui sono già presenti tutte le altre view:

//view per il login che viene mostrata solo quando l'utente non è loggato
var LoginView = Backbone.View.extend({

    // comunichiamo a backbone che deve inserire il markup del template di questa view all'interno di un oggetto dal tag 'section'
    tagName:  "section",

    //settiamo la classe che deve avere il tag 'section'
    className: "page-wrapper login-wrapper",

    //impostaiamo l'id del template da cui generare il markup di questa view
    template: "#loginview-template",

    initialize: function() {

        //compiliamo il template in una variabile
        this.template = _.template($(this.template).html());

        this.AnimEndEventName = this.getAnimEndEventName();
    },

    //funzione che genera il markup di questa view
    render: function () {
        this.$el.html(this.template()); 
        return this;
    },

    /* Grazie a modernizr riprendo il nome dell'evento di fine animazione, che cambia a seconda del browser */

    getAnimEndEventName: function(){

        var animEndEventNames = {
            'WebkitAnimation' : 'webkitAnimationEnd',
            'OAnimation' : 'oAnimationEnd',
            'msAnimation' : 'MSAnimationEnd',
            'animation' : 'animationend'
        };

        return animEndEventNames[ Modernizr.prefixed( 'animation' ) ];
    },

    // Deleghiamo gli eventi per la ricerca sull'input di testo 
    events: {
        //evento //selettore    //funzione da eseguire
        "submit  form":    "login"
    },

    //funzione che gestosce il login del form
    login: function (e) {

        e.preventDefault();
        var _this = this,
            form = $(e.currentTarget); 
            username = $.trim(form.find("[name=username]").val()),  
            password = $.trim(form.find("[name=password]").val()),
            submitBtn = form.find("button");

        //controllo sulla lunghezza di username e password
        if(username.length==0 || password.length==0){
            alert("Username e password sono obbligatori");
            return;
        }

        //qui andrebbe il controllo username e password (magaro tramite SQLite, Web SQL o su Ajax mediante database)
        //ma per questo esperimento simuliamo la cosa con un setTimeout di 2 secondi

        submitBtn.text("Login in corso...");
        setTimeout(function(){
            submitBtn.text("Login");

            //una volta verificate le credenziali di login salvo l'utente in modo persistente sul dispositivo tramite localStorage
            localStorage.setItem("user", username);
             //richiamo la funzione che inizializza i dati degli articoli e mostra la view della lista
            showList();
            //nasondo la view di login in modo da mostrare quella degli articoli
            _this.hide();

        }, 2000);      

    },

    show: function(callback){

        var _this = this;

        //aggiungendo la classe 'opened' al contenitore di questa view 
        //(elemento 'section.login-wrapper') innesco l'animazione di entrata
        this.$el.addClass("opened");

        //se è stata passata una funzione di callback, la richiamo una volta terminato l'evento di fine animazione
        if(callback){
            _this.$el.one( this.AnimEndEventName, function(){
                callback();
            });  
        }

    },

    hide: function(callback){

        var _this = this;
        //aggiungendo la classe 'hidden' al contenitore di questa view 
        //(elemento 'section.login-wrapper') inneschiamo l'animazione di uscita
        _this.$el.addClass("hidden");        
        //al termine della'animazione, rimuoviamo l'oggetto DOM dal documento tramite il metodo backbone 'remove()', in modo da alleggerire il lavoro 
        //della memoria centrale del dispositivo, contribuendo a rendere la nostra applicazione più fluida e performante 
        _this.$el.on( this.AnimEndEventName, function(){
            _this.remove();
            //se è stata passata una funzione di callback, la richiamo una volta terminato l'evento di fine animazione
            if(callback)
                callback();

        });   
    }

});

Nel momento in cui si verifica l’evento submit del form di login, viene richiamato il metodo “login“, all’interno del quale, dopo aver verificato che username e password siano stati inseriti, simuliamo una richiesta al server con un setTimeout  di 2 secondi, durante il quale cambiamo il testo del pulsante di login.

Al termine dei due secondi salviamo in corrispondenza della chiave “user” del localStorage l’username fornito dall’utente, mediante il metodo “.setItem()” e richiamiamo la funzione “showList”, che inizializzerà e mostrerà all’utente la view principale, quella che contiene la lista degli articoli (StartView) .

Come la view principale, anche quella di login utilizza come contenitore il tag <section> con con la classe “.page-wrapper“; in più è stata aggiunta la classe “login-wrapper” in modo da poter attribuire a questa view degli stili CSS aggiuntivi.

Grazie ad essi potremo infatti mostrare la view con un’animazione fluida e performante di tipo slideIn dal basso verso l’alto, che sfrutta la tecnica dell’accelerazione hardware.

Se vuoi approfondire il discorso delle animazioni fluide e perfomanti, e quello della tecnica dell’accelerazione hardware, forse potrebbe interessarti il seguente articolo:

• Web e Mobile App fluide con hardware acceleration

---

Come creare la view di login in un #HTML5 #mobileapp con #backbonejs
Click To Tweet

---

Inoltre sono da sottolineare i due metodi “show” e “hide“, i quali aggiungono all’elemento contenitore della view (l’elemento DOM “section.login-wrapper”) le classi “opened” ed “hidden“, che scateno le animazioni CSS di entrata e di uscita.

Grazie a Modernizr, incluso nel documento all’interno del file index.html (nel tag <head>), riusciamo ad “agganciare” all’evento di fine animazione (il cui nome cambia a seconda del browser utilizzato dall’utente) una funzione nel momento in cui l’animazione definita nei CSS giunge al termine (vedi questo articolo per avere maggiori informazioni).

Gli stili CSS

Vediamo gli stili CSS3 utilizzati per definire la dinamica dell’animazione di entrata e di uscita della schermata di login:

/* codice CSS3 performante per l'animazione della view di login */

section.login-wrapper {

  /*stili per il posizionamento*/
  position: fixed;
  left: 0;
  top: 0;      
  right: 0;    
  bottom:0;  
  z-index: 30;

  visibility: hidden;

  /* migliora le prestazioni prevenendo il render della parte 'posteriore' dell'elemento */
  -webkit-backface-visibility: hidden;
  -moz-backface-visibility: hidden;
  -ms-backface-visibility: hidden;
   backface-visibility: hidden;

   /* 
   	forziamo l'utilizzo della tecnica dell'accelerazione hardware per avere aniamzioni più fluide e reattive;
   	mpostando come elemento scatenante per l'effetto la proprietà 'translate3d'
   	il processo di rendering per l'elemento sarà delegato alla GPU (memoria grafica) 
   	prima, dopo e durante l'animazione
   */
   -webkit-transform: translate3d(0,0,0);
   -moz-transform: translate3d(0,0,0);
   -ms-transform: translate3d(0,0,0);
   transform: translate3d(0,0,0);               
}    

section.login-wrapper.opened{

	/*
	nel momento in cui all'elemento 'section.article-wrapper' viene aggiunta la classe 'show-article'
	innescchiamo l'animazione di entrata specifcandola in corrispondenza dell'attributo 'animation'
	*/

    -webkit-animation: showFromBottom .25s ease both;
    -moz-animation: showFromBottom .25s ease both;
    animation: showFromBottom .25s ease both;

    visibility: visible;
}

section.login-wrapper.hidden{
    /*
      nel momento in cui all'elemento 'section.article-wrapper' viene aggiunta la classe 'hide-article'
      inneschiamo l'animazione di uscita specificandola in corrispondenza dell'attributo 'animation'
    */
    -webkit-animation: hideToBottom .25s ease both;
    -moz-animation: hideToBottom .25s ease both;
    animation: hideToBottom .25s ease both;
}

/* definizione delle animazioni di entrata e di uscita per la view dell'articolo: muoviamo sempliemente l'elemento in verticale sull'asse delle ordinate */

/*animazione di entrata*/
@-webkit-keyframes showFromBottom {
    from { -webkit-transform: translateY(100%); }
}
@-moz-keyframes showFromBottom {
    from { -moz-transform: translateY(100%); }
}
@keyframes showFromBottom {
    from { transform: translateY(100%); }
}

/*animazione di uscita*/
@-webkit-keyframes hideToBottom {
    to { -webkit-transform: translateY(100%); }
}
@-moz-keyframes hideToBottom {
    to { -moz-transform: translateY(100%); }
}
@keyframes hideToBottom {
    to { transform: translateY(100%); }
}

La dinamica e le caratteristiche delle animazioni sono state riprese da uno dei miei precedenti tuorial sull’argomento. Per avere maggiori informazioni visita il relativo link:

• Come creare un HTML5 Mobile App con Backbone.js

Il template

Come prima cosa aggiungiamo il template della view all’interno del tag <body> file index.html, dove sono già presenti quelli della view principale, delle view della lista e della view dell’articolo singolo:

<!-- template per la view del login  (LoginView su demo.js) -->
	<script type="text/template" id="loginview-template">

		<header class="bar bar-nav">
			<button class="btn btn-link btn-nav pull-left" onclick="window.location.href='http://www.upcreative.net/iscriviti-alla-newsletter/'">
			    Altre guide
			</button>
		    <h1 class="title">Ultimi Articoli</h1>
		    <button class="btn btn-link btn-nav pull-right" onclick="window.location.href='http://www.upCreative.net'">
			    upCreative.net
			</button>
		</header>
		<div class="content">
			<h3>Effettua il login</h3>
			<form>
			  <input type="text" name="username" placeholder="Username">
			  <input type="password" name="password" placeholder="Password">
			  <button class="btn btn-primary btn-block">Login</button>
			</form>
		</div>

	</script>

Anche questa view, come le altre, è stata realizzata in modo tale che sfrutti gli stili di Ratchet 2, un set di CSS pronti da utilizzare come base per la realizzazione di una mobile app.

Al suo interno abbiamo inserito un semplice form di login con 2 campi per username e password.

Come creare un app: il controllo del login

Nell’esperimento precedente, dove il login non era presente, ci preoccupavamo subito di inizializzare la view princiaple; in questo tutorial dobbiamo invece controllare il contenuto della variabile localStorage per la chiave “user” prima di decidere se mostrare all’utente la view di login piuttosto che quella della lista degli articoli.

---

Come creare la view di login in un #HTML5 #mobileapp con #backbonejs
Click To Tweet

---

Pertanto inseriamo l’inizializzazione della view di iniziale (StartView) all’interno di una funzione denominata “showList“, in modo da poterla richiamare inizialmente oppure dopo che l’utente ha effettuato correttamente l’operazione di login:

//per poter inizializzaere e mostrare la view della lista degli articoli in più parti dell'applicazione
//la inseriamo all'interno di una funzione globale

var showList = function(){
    //creiamo una nuova istanza per la collection degli articoli con 4 models iniziali
    var articles = new ArticleList([
        {
            title: "App su upCreative.net",
            image: "1.jpg",
            article: "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
        },
        {
            title: "Secondo articolo su upCreative.net",
            image: "2.jpg",
            article: "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur"
        },
        {
            title: "Articolo senza immagine 3",
            image: "3.jpg",
            article: "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat"
        },
        {
            title: "Quarto articolo sulla  lista",
            image: "4.jpg",
            article: "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat"
        },
        {
            title: "Quinto articolo sulla  lista",
            image: "5.jpg",
            article: "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat"
        },
        {
            title: "Sesto articolo sulla  lista",
            image: "1.jpg",
            article: "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat"
        },
        {
            title: "Settimo articolo sulla  lista",
            image: "2.jpg",
            article: "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat"
        }
    ]);
    //creiamo una nuova istanza per la view iniziale 
    //associandogli la collection appena creata e popolata
    var startView = new StartView({
        collection : articles
    });
    $("body").append(startView.render().el);
};

Una volta fatto ciò, non dovremo far altro che controllare la variabile “user” all’interno del localStorage, nel momento in cui l’applicazione viene lanciata:

$(function(){

    //riprendo il contenuto della variabile "user" del localStorage
    var user = window.localStorage.getItem("user");

    if(user){
        //se in localStorage è presente un oggetto in corrispondenza della chiave "user", 
        //allora significa che l'utente è già loggato, quindi mostriamo direttamente la view della lista degli articoli
        showList();
    }else{
        //se l'utente non è loggato (quindi il contenuto della variabile è vuoto), allora mostriamo la view di login
        var loginView = new LoginView();
        $("body").append(loginView.render().el);
        loginView.show();
    }

});

Come creare un app: il pulsante di logout

Una volta predisposti la view di login ed il controllo della sessione tramite localStaorage, è buona norma aggiungere un pulsante per effettuare il logout, in modo da dare la possibilità all’utente di riaccedere con un username differente.

Inseriamo quindi nel template della view “StartView” un footer contenente il nuovo pulsante:

<!-- template per la view del contenuto iniziale  (StartView su demo.js) -->
	<script type="text/template" id="startview-template">

		<header class="bar bar-nav">
			<button class="btn btn-link btn-nav pull-left" onclick="window.location.href='http://www.upcreative.net/iscriviti-alla-newsletter/'">
			    Altre guide
			</button>
		    <h1 class="title">Ultimi Articoli</h1>
		    <button class="btn btn-link btn-nav pull-right" onclick="window.location.href='http://www.upCreative.net'">
			    upCreative.net
			</button>
		</header>
		<div class="bar bar-standard bar-header-secondary">
		    <input class="search-term" placeholder="Cerca articoli" type="text"/>
		</div>
		<div class="content">
			<div class="info">
				<h4>Benvenuto/a "<%=username%>"</h4>
				<p>Prova ad aggiornare la pagina, il login non verrà richiesto, a meno che non venga effettuato il logout. ;) </p>
			</div>
		</div>

		<!-- Footer con il pulsante di logout -->
		<div class="bar bar-standard bar-footer">
		  <button class="btn btn-primary btn-block logout">Logout</button>		 
		</div>

	</script>

Il click (o tap) su di esso sarà poi gestito all’interno della view di Backbone:

var StartView = Backbone.View.extend({

    ...

    // Deleghiamo gli eventi per la ricerca sull'input di testo 
    events: {
        ...
        "click    .logout":      "logout"  //gestione del pulsante di logout
    },

    ...

    logout: function(){

        var _this = this;

        //azzero la variabile del lovalStorage
        window.localStorage.removeItem("user");

        //mostro di unovo la view di login, per poi rimuovere questa view
        var loginView = new LoginView();
        $("body").append(loginView.render().el);
        loginView.show(function(){
            _this.remove();
        });

    }
});

Come puoi vedere dal codice, il compito del metodo  “logout” è quello di azzerare la variabile di controllo di login e mostrare la view “LoginView“, per poi rimuovere quella corrente al termine dell’animazione di entrata (passando al metodo “show“, definito nella view di login, una funzione di callback).

Il risultato finale

---

Come creare la view di login in un #HTML5 #mobileapp con #backbonejs
Click To Tweet

---

Download dei sorgenti

Aiutami a condividere la risorsa per ottenere il download:

Più volte ho accennato all’importanza della scalabilità e mantenibilità per un applicazione mobile sviluppata in HTML5, che permette allo sviluppatore (o agli sviluppatori, se si tratta di un team) di estendere o ridurre le dimensioni del progetto più facilmente, e di aggiornare i vari componenti anche singolarmente, avendo minime ripercussioni o ripercussioni inesistenti sugli altri componenti dell’applicazione.

Grazie ad un progetto scalabile è possibile evitare quello che personalmente ho rinominato l’ “effetto Shangai”  (pensa ad ogni parte di un’applicazione come un bastoncino, ogni volta che si modifica la posizione di un bastoncino è possibile coinvolgere, se si è fortunati, almeno 3 bastoncini,  che nel nostro caso rappresentano altri componenti dell’applicazione, come views, models, collections, ecc.).

Per avere vedere un esempio funzionante di una HTML5 mobile app basata su views, model e collection, ti consiglio di leggere questo articolo: Semplice HTML5 Mobile App con Bootstrap Ratchet e Backbone.js

Il gioco da tavolo dello Shangai. Fonte: Flickr  

---

Come creare #HTML5 #mobileapp: il #javascript modulare
Click To Tweet

---

Come creare un app: l’importanza di scrivere javascript modulare

Nel mondo della programmazione, per risolvere questo tipo di problema e per aumentare mantenibilità e scalabilità del codice, di solito si cerca di rendere il progetto “modulare“, concetto che non è riservato solo alle applicazioni mobile, ma che può essere esteso a tutte le web app javascript in generale, realizzate in HTML5, CSS3 e Javascript.

Usando questo termine ci riferiamo ad un tipo di struttura che viene suddivisa in moduli separati, ovvero singole parti o funzionalità dell’applicazione, ognuna di esse avente solitamente uno o più compiti specifici.

Ciò facilita notevolmente la mantenibilità rimuovendo, dove possibile, la dipendenza di una parte dell’applicazione rispetto alle altre (un componente è dipendente dall’altro quando ha bisogno di esso per poter funzionare).

Quando questo concetto è applicato correttamente, è molto più facile limitare le ripercussioni che operazioni come aggiunta, modifica o aggiornamento di un componente possano avere su altri altri del progetto.

Come creare un app: rendere un progetto modulare

Come creare un app: i namespace

Una delle pratiche comuni per rendere modulare un progetto sviluppato in HTML5, CSS3 e Javascript è quella di attribuire alle varie parti del DOM dell’interfaccia, o alle varie funzioni javascript che le gestiscono, dei “nomi” secondo una certa logica.

Tali nomi dovrebbero essere assegnati in modo tale che ogni elemento sia identificabile in modo univoco dal un proprio namespace, ovvero un nominativo che solitamente deriva dalla combinazione di due elementi:

• le funzionalità per il quale è stato concepito l’elemento al quale viene assegnato il namespace
• il nome della parte dell’interfaccia in questione.

Ciò permette di evitare eventuali collisioni con altri elementi o variabili globali.

Se volessimo identificare per esempio, in un’eventuale mobile app, la view di creazione di un articolo alla quale è possibile accedere dalla lista delle novità, potremmo associare all’elemento DOM che contiene la view il namespece “news_article_create”, da inserire all’interno dell’attributo “id”, o magari all’interno di un microdata personalizzato (es: data-namespace = ”news_article_create”).

Il namespace è molto utile per selezionare e manipolare via javascript un o più elementi DOM del documento (come accade molto spesso con i selettori di jQuery).

Un’altro metodo che rende molto facile la modularizzazione di un progetto, è quello di utilizzare l’AMD.

Come creare un app: l’AMD

L’AMD (Asynchrounous Module Defnition) è una tecnica che permette di caricare all’interno del progetto file e moduli esterni in modo asincrono, dopo il caricamento della pagina, ovvero dopo che sono state caricate tutte le risorse esterne indicate del documento iniziale (stili CSS, file javascript ecc.).

Oltre ad aumentare le performance, l’AMD permette , in fase di sviluppo, di mantenere tutti i moduli della struttura del progetto organizzati in file distinti fra loro, con la stessa logica di altri tipi di linguaggi di programmazione.

Grazie a dei tools esterni, è anche possibile concatenare e minimizzare tutti i file sorgenti Javascript in un unico file più leggero al momento della distribuzione del prodotto.

Fonte: Wikipedia

---

Come creare #HTML5 #mobileapp: il #javascript modulare
Click To Tweet

---

Come creare un app: gli script loaders

Suddividere la propria applicazione in moduli senza organizzarli in file separati non è molto diverso dal non utilizzarli affatto.

Definendo tutti i moduli in un unico file può contribuire ad evitare la situazione dell’ Effetto Shangai, anche se in tutti i casi ricercare una funzione o un determinato modulo tra 5000 righe di codice javascript non è per niente facile (è uno scenario in cui ti sei già trovato/a vero?).

Inoltre ciò renderebbe molto difficile il lavoro simultaneo di più sviluppatori all’interno del progetto.

E’ per questo motivo che solitamente la tecnica di suddivisione in moduli và di pari passo con l’utilizzo degli Script Loaders, librerie esterne che permettono appunto di caricare nel documento dei moduli o dei template collocati in file esterni.

In rete è possibile trovare moltissimi script loader (come per esempio Curl.js  oppure il loader del framework Dojo, ma il mio preferito, oltre che uno dei più diffusi, rimane Require.js.

Se ti interessa, ecco una lista di script loaders client-side:

• RequireJS
• curl.js
• bdLoad
• Yabble
• PINF

Con Require.js possiamo anche concatenare tutti gli script in un unico file grazie a dei tools di ottimizzazione aggiuntivi come il Require.js optimizer, che permettono tra l’altro di rimuovere completamente il discorso del caricamento asincrono e dell’AMD per nella versione “production” del nostro progetto.

---

Come creare #HTML5 #mobileapp: il #javascript modulare
Click To Tweet

---

Conclusioni

Quando si sviluppa un’applicazione web in HTML5, CSS3 e Javascript di complessità medio-alta (in riferimento al numero di funzionalità e al numero di schermate o view presenti nell’interfaccia), rendere il progetto modulare può aiutare incredibilmente a svolgere più facilmente comuni operazioni come modifica, eliminazione ed aggiornamento di alcune delle parti che lo compongono.

Qualsiasi applicazione è in costante aggiornamento, ed organizzare elementi come schermate, dati, template in moduli separati può velocizzare anche il flusso di lavoro, specie se questo è portato avanti non singolarmente, bensì da un team di sviluppatori.

E tu hai mai pensato alla modularità dei tuoi progetti e web app?

Se hai dei tools e strumenti da aggiungere alla lista, o per qualunque dubbio o perplessità, scrivilo pure nei commenti!

Nella  prima parte di questa mini-guida ho introdotto i database lato-client come soluzione per il salvataggio di quel tipo di dati che non necessitano di essere salvati su qualche sistema di storage remoto, utile sia per tipi di progetto come normali siti web, ma soprattutto per lo sviluppo di mobile app in HTML5, CSS3 e Javascript.

Molti sviluppatori (troppi) non sono a conoscenza del fatto che è possibile salvare dei dati in maniera relazionale sul browser dell’utente (o del visitatore), utilizzando uno dei linguaggi maggiormente conosciuti nel mondo del web design: l’SQL.

Da qui nasce l’idea di questa mini-guida.

Nello scorso articolo ti ho mostrato quali sono i database lato-client disponibili, ed in particolare ho anticipato i tre metodi fondamentali per poter sfruttare tutte le potenzialità del database Web SQL:

• openDatabase
• transaction
• executeSql

Vediamo come utilizzarli più nel dettaglio.

---

Come creare una #mobileapp: i metodi del #database #SQL lato-client
Click To Tweet

---

Come creare un app: Creare ed aprire un database

Per salvare i nostri dati abbiamo bisogno come prima cosa di cerare un database. Se si tenta di aprire un Database che non esiste l’API del Web SQL lo creerà automaticamente per noi.

Per creare ed aprire un database, proseguiamo come segue:

var db = openDatabase(“nomeDatabase”, “1.0”, “IL mio primo database!”, 3 * 1024 * 1024 , function(database){
      alert(“Database creato e aperto correttamente”);
});

Nell’esempio abbiamo creato e aperto un nuovo Database associando la sua istanza ad una variabile “db”, il tutto passando 5 parametri al metodo openDatabase:

1. Il nome del Database
2. Il numero della versione da utilizzare
3. Una descrizione di testo
4. Dimensioni stimate del Database
5. Callback di creazione

Se usiamo come primo parametro il nome di un database che è già stato creato in precedenza, non viene creato un nuovo database, ma viene aperto quello già presente.

---

Come creare una #mobileapp: creare e aprire un #database #SQL lato-client
Click To Tweet

---

Come creare un app: le transaction di Web SQL

Una volta aperto il Database, possiamo istanziare l’oggetto transaction, che ci servirà per eseguire le query di cui abbiamo bisogno.

Ma perché servirsi di un oggetto aggiuntivo come la transaction invece di scrivere semplicemente le nostre righe di SQL?

Le transaction ci permettono di usufruire di una funzionalità di rollback: ciò significa che, se una transaction contenente una o più query SQL per qualche ragione fallisce, gli aggiornamenti al database non vengono effettuati, come se la transazione non fosse mai avvenuta.

E’ una logica di funzionamento molto simile a quella delle transazioni dei database MSSql, e rappresenta un grande vantaggio, soprattutto quando abbiamo la necessità di eseguire più operazioni di modifica in coda.

Il metodo transaction dà  allo sviluppatore anche la possibilità di gestire eventuali errori nella transazione con delle apposite callback di errore e di successo.

Ma vediamo più nel dettaglio come si utilizza.

La transaction non è altro che una semplice funzione con una callback di ritorno:

var db = openDatabase(“nomeDatabase”, “1.0”, “IL mio primo database!”, 3 * 1024 * 1024);
db.transaction(function(tx){
     /* Effettuare le proprie query qui */
}, function(){
     //callback di successo
     alert(“Istruzioni SQL eseguite correttamente”);
});

L’oggetto “tx” restituito nella prima funzione di callback, rappresenta l’oggetto della transaction, che useremo per eseguire le query di cui abbiamo bisogno.

Oltre al metodo transaction, è possibile usare anche il metodo readTransaction, che funziona in modo del tutto analogo al primo, ma che non può essere impiegato per eseguire delle istruzioni SQL di modifica del database (come per es. la creazione o l’eliminazione di tabelle, oppure istruzioni come INSERT ed EDIT), in quanto è stato creato appositamente per velocizzare le query di lettura.

Tuttavia con i metodo transaction possiamo effettuare sia query di lettura che di modifica.

Una volta ottenuto il nostro oggetto transaction, procediamo con l’esecuzione delle query.

Come creare un app in HTML: il metodo executeSQL

Eccoci finalmente al punto in cui possiamo divertirci con le istruzioni SQL.

executeSQL può essere utilizzato sia per query di lettura che per query di modifica del database, include un controllo implicito per l’SQL Injection, e fornisce una callback di ritorno per poter processare i risultati delle query effettuate.

Come creare una tabella

Il metodo executeSql è un metodo dell’oggetto transaction (ovvero dell’oggetto fornito con il parametro di ritorno “tx”) e viene utilizzato in questa maniera:

var db = openDatabase(“nomeDatabase”, “1.0”, “IL mio primo database!”, 3 * 1024 * 1024);

db.transaction(function(tx){
	/* Effettuare le proprie query qui */
}, function(){
	//callback di successo
	tx.executeSql("CREATE TABLE Employees (id unique, name)", [] , 			
		function(sqlTransaction, sqlResultSet){
				alert("La tabella è stata creata.");
		}, 
		function(sqlTransaction, sqlError){			
			/* Gestione degli errori */
		}
	);
});

L’esempio che ti ho appena mostrato crea una tabella dal nome “Employees” all’interno del nostro Database “nomeDatabase”.

Ovviamente, se la tabella già esiste sarà restituito un errore, che possiamo gestire all’interno della funzione passata come terzo parametro, oppure possiamo evitare l’errore a priori con una query del tipo:

var db = openDatabase(“nomeDatabase”, “1.0”, “IL mio primo database!”, 3 * 1024 * 1024);
db.transaction(function(tx){
	/* Effettuare le proprie query qui */
}, function(){
	//callback di successo
	tx.executeSql("CREATE TABLE IF NOT EXISTS Employees (id unique, name)");
	tx.executeSql("INSERT INTO Employees (id, name) VALUES (1, ‘Giacomo')");
});

Ora la tabella “Employees” ha un record al suo interno.

---

Come creare una #mobileapp: effettuare query in un #database #SQL lato-client
Click To Tweet

---

Come inserire un nuovo record in una tabella

Ma se volessimo inserire una riga mediante dei valori dinamici?

Ciò è possibile utilizzando il secondo argomento da passare al metodo executeSQL:

tx.executeSql(“INSERT INTO Employees (id, name) VALUES (?, ?) ”, [variabile_id, variabile_name] );

In questo modo le variabili “variabile_id” e “variabile_name” saranno sostituite ai caratteri “?” all’interno della query in modo sequenziale.

Come leggere i record di una tabella e processarli con il javascript

Infine, per eseguire query di lettura nella nostra tabella, basterà utilizzare la callback di ritorno processando i risultati ottenuti:

tx.executeSql('SELECT id, name FROM Employees', [  ], function (tx, resultsData) {
	//i record restituiti sono all’interno della proprietà “rows” dell’oggetto resultsData
	//loop per scorrere tutti i risultati ottenuti
	for (var i = 0; resultsData.rows.length < len; i++) {
		var employee = resultsData.rows.item(i);
		console.log(employee .name);
	}
});

La callback riceve due parametri di ritorno:

• l’oggetto della transazione (lo stesso che abbiamo usato per effettuare la query)
• l’oggetto javascript dei risultati contenente un attributo “rows” strutturato come un array, anche se non lo si può definire un’array a tutti gli effetti: per accedere ai dati di un singolo record dobbiamo utilizzare la sintassi “rows.item(i)“, dove “i” rappresenta l’indice del record  all’interno della lista dei risultati, mentre in un normale array sarebbe bastato scrivere “rows[i]”).

Dall’istruzione “var employee = resultsData.rows.item(i);” otteniamo quindi l’oggetto di un singolo record, che avrà le stesse proprietà dei campi richiesti nella query (nel nostro caso avrà quindi due proprietà: “id” e “name” );

Come creare un app: conclusioni sui metodi del Web SQL

Queste sono a grandi linee tutte le nozioni di cui abbiamo bisogno per sfruttare la maggior parte delle funzionalità del Web SQL.

Come ho spiegato nella prima parte di questa mini-guida, il Web SQL è un metodo molto utile per salvare dati in forma relazionale all’interno di qualsiasi single page application, sia quelle destinate ad essere compilate con strumenti come Phonegap e distribuite su dispositivi mobile, sia quelle che saranno disponibili come web app ed accessibili direttamente da un indirizzo remoto.

Personalmente trovo questo metodo di salvataggio molto utile per salvare le impostazioni personali dell’utente, come nel caso di Tint (la mia app per il meteo), o per salvare i dati sul dispositivo per quelle applicazioni che non devono essere sincronizzate in cloud, come ho fatto per Dieta SI o NO?.

Tuttavia va ricordato il fatto che le specifications del W3C hanno abbandonato il supporto al Web SQL a favore del database non-relazionale IndexedDB e, in un futuro molto prossimo, il Web SQL non sarà più supportato dai browser, inclusi quelli mobile.

---

Come creare una #mobileapp: i metodi del #database #SQL lato-client
Click To Tweet

---

Ed Ora?

Se hai mai utilizzato sistemi di memorizzazione come i database lato-client mi piacerebbe avere un tuo riscontro per quanto riguarda le tue reali esperienze, i tuoi progetti e/o reali case-study.

Sentiti libero/a inoltre di esporre tutti i tuoi dubbi o perplessità al riguardo, sia inviandomi una mail all’indirizzo info@upcreative.net, o meglio ancora, commentando questo articolo.

Molti sviluppatori javascript forse non ne sono a conoscenza, ma esiste un metodo per poter salvare i dati in un Database lato-client. Ciò significa che è possibile utilizzare database situati nel dispositivo dell’utente.

Esso costituisce un grande vantaggio nella realizzazione di HTML Mobile App e single page application in generale, anche se i database SQL lato-client possono essere utilizzati per qualunque sito web, in quanto si tratta di una funzionalità HTML5.

In un articolo che ho scritto per YourInspirationWeb.com, avevo riportato le varie modalità con cui è possibile salvare i dati per una HTML Mobile App sviluppata in CSS3 e Javascript: HTML Mobile App: Tecniche per il salvataggio dei dati.

In questo post prenderemo in considerazione il terzo metodo per il salvataggio dati esposto nell’articolo di YourInspirationWeb.com: il Database HTML5.

La maggior parte degli sviluppatori web è abituata a salvare i propri dati tramite metodi relazionali, utilizzando perlopiù database come mySql o MsSql, e chi si occupa dello sviluppo di Mobile App in HTML5, CSS3 e Javascript solitamente è prima di tutto un web designer impegnato nella realizzazione di siti web (tramite appunto questo tipo di database, come nel caso di sviluppatori WordPress).

Pertanto molti saranno contenti del fatto che per la creare mobile app è disponibile un metodo di salvataggio che sfrutta database lato-client.

Se infatti lato-server è possibile usare qualsiasi sorta di database, anche l’HTML mette a disposizione un tipo di database lato-client, che lo sviluppatore può sfruttare per poter inserire, modificare, cancellare e leggere i dati del proprio progetto sul dispositivo, secondo una metodologia relazionale, tramite vere e proprie query SQL.

Ma cosa intendo per “database lato-client“?

Per database lato-client intendo un tipo di database che risiede nel browser utilizzato dall’utente, grazie al quale possiamo evitare di dover comunicare con il server, come per esempio per mezzo di chiamate ajax.

---

Come creare una #mobileapp: salvataggio dati con #database #SQL lato-client
Click To Tweet

---

Come creare un app: due tipi di database lato-client

Lo sviluppatore ha a disposizione due tipi diversi di database lato client in HTML5:

• Web Sql (di tipo relazionale): mette a disposizione un modello di API che permettono di eseguire delle query tramite una variante di linguaggio SQL.
• IndexedDB (di tipo coppia chiave-valore): definisce un modello API con le quali è possibile lavorare in un database di record con valori semplici ed oggetti gerarchici.

Come per il localStorage, anche nel caso dei Database Web Sql ed IndexedDB  generalmente abbiamo a disposizione una capacità di memoria predefinita di 5MB, che può variare a seconda della versione del browser del dispositivo e delle impostazioni scelte dall’utente.

Come creare un app: la compatibilità dei database lato-client

Purtroppo nel momento in cui scrivo ci troviamo ancora in una terra al quanto instabile, per quanto riguarda i database lato-client: 

se da un lato il WebSql non sarà più mantenuto in modo attivo dalle specifications dello staff W3C (ecco il link alla pagina ufficiale w3c), il che significa che in un futuro molto prossimo sarà abbandonato, dall’altro l’IndexedDB non è ancora supportato da Mobile Safari per iOS, che invece supporta ancora il Web SQL (per la tabella delle compatibilità di IndexedDB visita questo link). Puoi consultare la pagina ufficiale w3c dell’IndexedDB collegati a questo indirizzo.

Siccome stiamo parlando di Mobile App, e siccome il numero di dispositivi Apple rappresenta una grandissima fetta dell’utenza mondiale (quindi una grandissima portata al livello di audience e possibilità di mercato), è opportuno secondo me lavorare ancora con il database WebSql, per dirigersi poi verso l’IndexedDB mano a mano che esso sarà supportato da tutti i dispositivi.

Tra l’altro, anche le versioni desktop di Chrome, Safari ed Opera supportano il WebSql, il che ci dà la possibilità di testare eventualmente il salvataggio dati anche su browser desktop, evitando di effettuare ogni volta il deploy nel dispositivo mobile.

L’indexedDB inoltre non è un modello di database relazionale.

Per ora prenderemo quindi in considerazione solamente il database WebSql.

---

Come creare una #mobileapp: salvataggio dati con #database #SQL lato-client
Click To Tweet

---

Come creare un app: Il database Web SQL

Abbiamo detto che il Database Web SQL permette di utilizzare l’SQL lato-client.

Quindi, se hai un background da programmatore back-end (come la maggior parte dei web designers) oppure sei un programmatore front-end con nozioni di back-end, non avrai problemi con l’SQL, altrimenti apprendere l’SQL sarà uno stimolo per poter imparare una nuova competenza.

La sintassi del Web Sql è basata sull’SQLite, ma è molto similare anche ad altri database relazionali com MySql, MSSql e via dicendo.

Come si usa

Vediamo le nozioni principali del Web SQL (ovviamente se vuoi approfondire l’argomento, dal nostro caro “amico Google” potrai trovare tutte le informazioni che ti interessano).

Per sfruttare le funzionalità del Web SQL e poter salvare i dati della nostra applicazione in un database lato-client, sono 3 i metodi da prendere principalmente in considerazione:

• openDatabase
• transaction
• executeSql

Come creare un app: il database SQL lato client parte 1 – conclusioni

Nella seconda parte di questa guida analizzeremo come poter utilizzare le funzionalità principali del Web SQL tramite i 3 metodi appena elencati, che ci forniscono tutto ciò di cui abbiamo bisogno per poter creare nuovi database e stabilire una connessione con quelli già esistenti, oppure effettuare altre operazioni fondamentali come la creazione di tabelle, l’inserimento, la modifica o la cancellazione di records.

E tu? Hai mai utilizzato i database lato-client per i tuoi progetti?

Magari l’hai utilizzata per salvare qualche tipo di dato, oppure pensi che potrebbe essere una possibile soluzione per il tuo prossimo progetto. Scrivi pure tutte le tue considerazioni e/o perplessità al riguardo nei commenti, e sarò lieto di aiutarti a capire se il Web SQL potrebbe essere implementato nei tuoi lavori.

Per creare una Mobile App in HTML o una qualsiasi web app javascript è fondamentale organizzare il progetto secondo una struttura ben adeguata, evitando di produrre codice secondo la “non-logica” Spaghetti Code (leggi questo articolo per saperne di più).

Come già affrontato in altri numerosi post, adottare una logica di sviluppo basata sull’MVC può aiutare notevolmente lo sviluppatore a raggiungere tale obiettivo.

Un altro metodo molto utile per mantenere il codice scalabile e mantenibile, oltre che aumentare le performance dell’applicazione, consiste nell’utilizzo di sistemi di Javascript templating in stretta relazione con le view, che si occupano della rappresentazione visiva dei vari componenti dell’interfaccia.

I sistemi di templating Javascript consentono infatti di generare il markup dinamico di una determinata view (leggi questo articolo che ho scritto per YourInspirationWeb  per sapere come utilizzare una view con backbone.js) in base ai dati che gli vengono passati al momento della compilazione.

Prima di entrare più nel dettaglio, vediamo quali sono solitamente le alternative adottate per la generazione di markup in una Mobile App sviluppata in HTML5, CSS3 e Javascript.

---

Come creare #MobileApp in #HTML5: il sistema di #javascript templating
Click To Tweet

---

Creare Mobile App in HTML: come viene generato solitamente il markup

Siccome in una HTML5 Mobile App tutta la generazione del markup e degli elementi DOM dell’interfaccia avviene tramite linguaggio lato-client, e quindi tramite javascript, generalmente si tende a seguire 3 strade principali per inserire il codice HTML di ogni schermata (o view) all’interno del progetto:

1 – Effettuare chiamate ajax che restituiscono dati HTML da un server remoto.

Rappresenta secondo me il tipo di approccio più sbagliato.

Stiamo parlando di applicazioni mobile e ciò comporterebbe il trasferimento di una grande quantità di dati e tempi di attesa più lunghi, soprattutto se l’utente sta usando l’applicazione in una zona fisica in cui il traffico è limitato o quasi assente.

Senza contare il fatto che il codice restituito (stringa formata dall’HTML generato dal server) risulta difficile da interpretare per l’applicazione JavaScript, e solitamente necessita di un’adeguata formattazione prima dell’immissione all’interno del documento.

La comunicazione in remoto dovrebbe essere pertanto utilizzata solo al fine di reperire o inviare dati “puri” (come per esempio un oggetto JSON).

2 – Inserire l’HTML di tutte le schermate nel documento

Per creare una Mobile App in HTML si utilizza un file principale index.html. 

Secondo questo metodo all’interno di quel file viene inserito tutto il markup necessario per far funzionare l’applicazione, relativo a alle varie view che la compongono.

Può andar bene per progetti formati al massimo da 4/5 schermate, dopo di ché diventa facile smarrirsi nei meandri del codice HTML come un bambino di 3 anni in un bosco.

Se poi consideriamo il fatto che in quelle view possiamo avere la necessità di inserire dati dinamici, per aggiungerli al DOM dovremmo comunque servirci di codice Javascript, utilizzando così non uno, ma due tipi di approcci diversi per lo stesso scopo (1 – html statico, 2 – generazione di markup via javascript).

Inoltre, inserire tutti i nodi DOM all’interno del documento riduce notevolmente le prestazioni di rendering, a causa del numero di elementi HTML per i quali la CPU è costretta a ricalcolare gli stili nel momento in cui si verifica qualsiasi modifica CSS, oppure ogni volta che un elemento si sposta nello schermo (quando ciò questo accade vengono coinvolti nello spostamento anche altri nodi del documento).

3. Generare codice tramite javascript con una concatenazione di stringhe

E’ provato che creare grandi blocchi di codice HTML tramite una concatenazione di stringhe riduce drasticamente la velocità per le prestazioni di esecuzione, in quanto la variabile in-memory utilizzata per svolgere tale operazione va ad occupare parte della CPU.

Coloro che adottano questa tecnica inoltre, si perdono spesso in cicli nidificati in cui non si capisce quale tag chiude l’altro, e dove non si riesce a distinguere dati puri dall’HTML.

Ecco un possibile esempio di questa tecnica:

var markup = "<div class=\"main-wrapper\">"+
				"<header class=\"page-header\" role=\"header\"><h1 class=\"\"></h1></header>"+
				"<section class=\"page-section\"></section>"+
				"<ul class=\"contacts-list\">";

			for(var i=0;i<contacts.length;i++){
				markup+="<li class=\"contact-list-item\">"+contacts[i].name+" "+contacts[i].surname+"</li>";
			}

			markup+="</ul></div>";

$(".content").append(markup);

 

E’ preferibile invece lasciare libera la memoria del dispositivo per le operazioni di rendering, che influiscono sulla user-experience del prodotto finale, così come è preferibile lasciare separati codice HTML da codice Javascript, in modo da aumentare la mantenibilità e la scalabilità del progetto e poter facilmente riutilizzare uno stesso template in diverse parti.

Creare Mobile App in HTML: il funzionamento dei sistemi di templating

Gli sviluppatori javascript hanno a disposizione diversi framework di templating per generare via client il markup HTML delle view che compongono le loro applicazioni (come per esempio Handlebars.js, Mustache, o il sistema interno al framework underscore.js).

Per conoscere anche altri sistemi di javascript templating, ti consiglio di leggere questo mio precedente articolo:

• I sistemi di javascript templating e le migliori librerie

I template possono essere savat in variabili in-memory, in file HTML indipendenti o all’interno del documento, solitamente racchiusi in tag <script> con un attributo “type” personalizzato (per esempio “text/template”:  “<script type=“text/template”> <!– markup del template —> </script>”).

---

[Tweet “Come creare #MobileApp in #HTML5: il sistema di #javascript templating
Click To Tweet

---

“]

Ogni template ha accesso a delle variabili, a seconda dei dati che gli vengono passati.

Utilizzare le variabili è molto semplice e generalmente è possibile farlo all’interno di appositi delimitatori, il cui funzionamento non è molto diverso da quello della generazione del markup HTML dinamico tramite i più diffusi linguaggi lato-server (ASP, PHP, C# ecc.).

Il lavoro è reso ancora più facile per il fatto che la maggior parte di questi sistemi accetta dati in formato JSON (formato in cui può essere convertito facilmente qualsiasi tipo di dati).

I delimitatori delle variabili possono differire a seconda del framework utilizzato, ma il funzionamento logico rimane pressoché sempre lo stesso.

Due sono le categorie principali in cui si suddividono i vari tipi di sistemi di templating:

• embedded javascript, comprende i frameworks che permettono l’utilizzo di codice javascript all’interno dei propri template
• logic less, comprende quelli che non permettono l’utilizzo di javascript al loro interno, ma limitano l’uso di logiche come cicli e condizioni a sintassi personalizzate

Vediamo il funzionamento del sistema di templating di underscore.js, che appartiene alla prima categoria, e che può essere utilizzato per creare mobile app in html con il framework MVC Backbone.js.

Più concretamente, vediamo l’esempio di un ciclo che genera in maniera dinamica l’HTML necessario per mostrare una lista di individui.

Consideriamo di dover generare il markup della lista servendoci dei seguenti dati in formato JSON:

{
	'employees': [
		{‘name': ‘Giacomo Freddi’, occupation: ‘Web Designer / Front-End Developer’},
		{‘name': ‘Mario Rossi’, occupation: ‘CEO’},
		{‘name': ‘Franco Mancini’, occupation: ‘Web Marketer’},
		...
	]
}

Ecco come potrebbe presentarsi il template secondo il sistema di templating di underscore.js

<ul>
   <%for(var i=0;i<employees.length;i++){%>
   <li><%=employees[i].name%> - <%=employees[i].occupation%></li> 
   <%}%>
</ul>

In tal caso il risultato del markup generato sarebbe:

<ul>
   <li>Giacomo Freddi - Web Designer / Front-End Developer</li>
   <li>Mario Rossi - CEO</li>
   <li>Franco Mancini - Web Marketer</li>
   …
</ul>

Con i javascript templating lo sviluppatore ha sicuramente una cosa in meno a cui pensare, in quanto la maggior parte del lavoro di generazione del markup viene svolto dal sistema stesso.

Creare mobile app in HTML: i benefici del sistema di templating

Ciò porta ad un gran numero di benefici nel creare mobile app in HTML o qulasiasi single page application, in particolare se si decide di salvare i template di ogni view all’esterno del documento principale dell’applicazione (index.html), inserendo ognuno di essi in un apposito file (es.: nome-della-view.html).

Il contenuto del file viene poi caricato dinamicamente, solamente se e quando abbiamo bisogno di effettuare il render di quella view all’interno dell’interfaccia.

Quello appena esposto è il metodo che preferisco, in quanto permette di separare completamente all’interno del progetto il concetto di templating da tutto il resto (sinonimo di mantenibilità e scalabilità) e, nel senso più “fisico” del termine, ogni view dall’altra.

Così facendo è possibile mantenere la struttura dei file dell’applicazione ancora più organizzata.

Bisogna comunque  fare attenzione al fatto che i template non rappresentano di per sé delle view, bensì lo strumento grazie al quale esse possono effettuare il render del markup HTML che le rappresenterà all’interno del documento. Molti sviluppatori spesso confondono il concetto di view con quello di template, ma non sono assolutamente la stessa cosa.

Una view è un oggetto che che osserva un modello dati (in MVC i cosiddetti model) e mantiene la propria rappresentazione visiva aggiornata in base ad esso. Una view è definita da codice Javascript.

Il template potrebbe essere lo strumento di cui si serve la view per generare parte del proprio markup necessario alla visualizzazione, o di tutto il markup necessario.

---

Come creare #mobileapp in #HTML5 – i benefici del #javascript #templating
Click To Tweet

---

Conclusioni

Oltre che per creare mobile app in HTML o qualsiasi altro tipo di web app sviluppata in HTML, CSS3 e Javascript, i sistemi di templating sono molto utilizzati anche per la realizzazione di siti web che forniscono una user-experience di qualità molto elevata.

Solitamente gli sviluppatori front-end più affermati si servono di sistemi di javascript templating per generare markup da template salvati in file .html esterni, o dichiarati all’interno della pagina in appositi script personalizzati.

E tu hai mai utilizzato i sistemi di javascript templating? Ne hai privato qualcuno da suggerire? Scrivilo nei commenti e sarò felice di risponderti!

Più volte ho discusso l’importanza di usare i pattern di sviluppo MVC nella realizzazione di applicazioni web ed HTML5 Mobile App realizzate in Javascript e CSS3: scrivere codice come capita e senza alcuna logica può andar bene per progetti di piccolissime dimensioni o singole pagine web, ma se stiamo parlando di una single page application, quindi un’applicazione in cui il codice lato-client gestisce, oltre ai dati, anche la generazione di markup, il discorso cambia.

 

Spaghetti code

E’ ciò che dobbiamo evitare in quei casi. In altre parole dobbiamo evitare di sviluppare single page application e web app senza un’architettura logica che ci consenta di scrivere codice ben organizzato, facilmente leggibile, mantenibile e riusabile.

Questo è lo scopo principale dei metodi di sviluppo MVC.

Abbiamo visto quanto possono essere importanti le view nel web in generale e perché considerare di usare un framework javascript MVC per la realizzazione di HTML5 Mobile App.

In un post che ho scritto per YourInspirationWeb, metto in evidenza l’importanza dell’impiego delle view in ambito web ed il perchè esse sono così importanti:

• HTML5 Mobile App: il web ha bisogno delle view

---

#HTML5 #MobileApp definire la struttura dati con #backbonejs
Click To Tweet

---

HTML5 Mobile App: MVC per rendere il javascript mantenibile e riusabile

Per molti anni il pattern di sviluppo MVC è stato usato in moltissimi linguaggi di sviluppo. Al giorno d’oggi, tutti i web designer e front-end developer hanno già cominciato da qualche tempo ad applicare la logica MVC al linguaggio che per noi risulta più rilevante: il Javascript.

Con il Javascript abbiamo a disposizione diversi tipi di frameworks che offrono supporto per l’MVC nelle sue numerose variazioni ( la famiglia di pattern MV*), permettendoci di estendere la struttura delle nostre applicazioni senza troppe difficoltà.

Alcuni dei frameworks più famosi possono essere per esempio Backbone o AngularJS. Il loro ruolo è fondamentale, in quanto consentono allo sviluppatore di evitare la scrittura del codice in modalità Spaghetti code. Pertanto è importantissimo capire di cosa possiamo beneficiare con un adeguato pattern di programmazione.

In un precedente articolo avevo spiegato come realizzare una semplice HTML5 Mobile App con Backbone.js:

• Semplice HTML5 Mobile App con Bootstrap Ratchet e Backbone.js

In questo capitolo ti voglio mostrare più nel dettaglio una delle parti che compongono l’acronimo MVC: il model (o modello).

Lo farò in relazione ad uno dei sopra citati framework MVC, ovvero Backbone.js, che è proprio quello che approfondiremo per la realizzazione di HTML5 Mobile App.

Gestire i dati con il model per una HTML5 Mobile App

I modelli costituiscono i dati dell’applicazione.

Un modello può rappresentare per esempio un individuo, una nota, un articolo, un libro, o qualunque altra entità che possa avere 1 o più caratteristiche (nome, cognome, sesso, codice ISBN, matricola, colore, ecc..).

I modelli possono essere visti in modo completamente separato dagli elementi che compongono l’interfaccia-utente, anche se quando un modello subisce delle modifiche, esso normalmente avvisa gli “osservatori” (altre parti della struttura come per esempio le view – viste ) che si è verificato un cambiamento, permettendogli di agire di conseguenza.

Facciamo un esempio concreto al fine di comprendere meglio i modelli. Più nello specifico, prendiamo come punto di riferimento Tint, la mia applicazione per il meteo.

In una normale applicazione meteo, il concetto di località ha bisogno di un suo modello che la rappresenti come un tipo di dato unico, con delle specifiche caratteristiche, che possono essere il nome (città o luogo), la latitudine, la longitudine, il paese di appartenenza ed altri possibili dati aggiuntivi.

Una specifica località potrebbe essere salvata nell’istanza di un model, che sarebbe accessibile e riusabile in più parti dell’applicazione.

Vediamo la definizione di un semplice modello che rappresenta il tipo di dati “località” con Backbone.js:

var LocationModel = Backbone.Model.extend({

	initialize:function () {
	//ci assicuriamo che ogni modello appena creato abbia un ordine numerico
	if( isNaN ( this.get(“order”) ) )
		this.set( {“order”, 0 } );
	},

	//dati predefiniti per la località

	defaults:{
		defaultLocation: false,
		userLocation: false,
		viewed: false
	}

});

---

#HTML5 #Mobileapp come definire un model con #Backbonejs
Click To Tweet

---

La funzionalità integrate dei modelli variano a seconda del framework utilizzato, ma generalmente tutti i framework danno la possibilità di definire gli attributi, ovvero le proprietà di ogni modello, (come per esempio la cilindrata, il colore, la gamma o la marca per un ipotetico modello “macchina da strada”).

Backbone, come molti altri MVC frameworks, offre anche la possibilità di salvare i dati secondo varie modalità, come per esempio il localStorage o la sincronizzazione con un database.

Per avere maggiori informazioni sul metodo di salvataggio dei dati, ti consiglio di leggere  questo articolo che ho scritto per YourInspirationWeb.com:

• HTML5 Mobile App: tecniche per il salvataggio dei dati

Gli osservatori dei modelli

Un modello può avere anche diverse view (parti visuali dell’interfaccia) che lo stanno “osservando”, pronte a reagire ad eventuali cambiamenti.

Ritornando all’esempio di Tint, ogni località presenta la lista dei giorni e relativo meteo, oltre che una lista di orari, anch’essi ciascuno con la relativa condizione meteo.

L’applicazione usa 3 diverse view per ognuna delle località:

• la view per mostrare i dati principali e il meteo attuale del luogo
• la view per mostrare il meteo nelle prossime ore della giornata
• la view per mostrare il meteo nei prossimi giorni della settimana

Tutte le view sopra elencate risultano “associate” allo stesso modello, e osservano eventuali cambiamenti che lo stesso può avere.

Backbone.js e HTML5 Mobile App: le collection

Nella maggior parte dei framework MV*, i modelli possono essere organizzati in gruppi: con Backbone.js tali gruppi vengono chiamati “Collection” (o collezioni).

Gestire i modelli in collezioni aiuta a sviluppare applicazioni secondo una logica che permetta non osservare ciascun modello individualmente, ma reagire di conseguenza a qualunque modello che subisce delle modifiche in maniera “centralizzata”.

Per comprendere meglio questo concetto, prendiamo di nuovo l’esempio su Tint: consideriamo 2 view in particolare, tra quelle che compongono l’interfaccia:

• la view ManageLocations: quella che consente di aggiungere, eliminare o modificare l’ordine delle località
• la view Locations: che viene mostrata subito dopo l’avvio dell’applicazione ed offre all’utente la possibilità di scorrere orizzontalmente le varie località secondo l’ordine con cui esse sono state organizzate nella prima view menzionata. Questa view si preoccupa di creare per il modello di ogni località presente nella collection la relativa “sotto-view” inserendola al suo interno.

L’applicazione è impostata in modo tale che la view “Locations” osservi i cambiamenti della collezione “LocationCollection”, la quale contiene tutti i modelli di ciascuna località aggiunta dall’utente, oltre a quella relativa alla sua posizione.

Così, non appena un‘utente aggiunge, elimina o modifica l’ordine di una località usando la view delle impostazioni (ManageLocations), la view Locations aggiunge la view associata al nuovo modello, rimuove quella del modello eliminato, o, qualora si trattasse di un riordinamento, reinizializza lo slider orizzontale.

 

Di seguito ti mostro l’esempio della definizione di una Collection di località tramite Backbone.js, che ho usato per Tint:

var LocationCollection = Backbone.Collection.extend({

	//definisce a quale modello di riferisce la collezione
	model: LocationModel,

	//definisco che il metodo di salvataggio per collection debba essere il localStorage (voglio salvare tutte le località aggiunte dall’utente nel dispositivo,
	//in modo da potergliele ripresentare al prossimo avvio)
	localStorage: new Backbone.LocalStorage("Parallax_Weather-locations"),

	//funzione che ho usato per generare in modo sequenziale l’ordine di ogni nuovo model,
	//per far sì che possa essere aggiunto all’ultimo posto

	nextLocation: function(newModel) {
		if (!this.length) return 1;
		return this.last().get('order') + 1;
	},

	//definisco la modalità di ordinamento dei modelli, in questo caso in base all’attributo ‘order'
	comparator: function(location) {
		return location.get("order");
	}

});

---

#HTML5 #MobileApp definire un #collection con #Backbonejs
Click To Tweet

---

Conclusioni

L’astrazione dei dati è un fattore fondamentale nella realizzazione di qualsiasi progetto web, e lo diventa ancora di più nel caso di HTML5 Mobile App sviluppate in CSS3 e Javascript.

Grazie ai numerosi framework MVC (e tutte le varianti dell’MVC, solitamente indicate con MV*) è possibile organizzare i dati di un progetto secondo una struttura logica che consenta di modificarli facilmente, oltre che separare totalmente la loro gestione da quella dell’interfaccia e della user-experience, di cui solitamente si occupano altri componenti come view e controllers.

E tu? Cosa pensi dei javascript framework MVC? Fammelo Sapere nei commenti!

Tutti gli sviluppatori e web designers hanno a che fare prima o poi con la manipolazione di elementi HTML DOM, momento in cui fanno conoscenza solitamente di jQuery, che con  tutti i plugin disponibili offre una mano non indifferente.

Il problema sorge di solito quando non si tratta più di realizzare siti web, ma iniziamo ad affacciarsi al mondo delle web app, dove è facilissimo perdersi in una pila infinita di elementi DOM e callback javascript intrecciate e nidificate tra di loro.

Visto che il numero di dispositivi mobile sta crescendo a vista d’occhio e sempre più sistemi operativi stanno rivolgendosi verso la direzione delle single page applications, (hai notato che anche le applicazioni di Windows-8 sono single-page-app costruite in HTML5?), ma soprattutto perché esse costituiscono il metodo principale per lo sviluppo di HTML5 Mobile App ibride, è opportuno considerare l’approccio a Frameworks Javascript Moderni. 

Tali frameworks ci possono assistere nel processo di strutturazione ed organizzazione dei nostri progetti, facendo in modo che essi risultino facilmente mantenibili e scalabili anche a lungo-termine.

---

#Javascript #HTML #mobileapp: l’importanza del #framework #MVC
Click To Tweet

---

HTML5 Mobile App: MVC, Di cosa si tratta?

Questi nuovi framework sono nati con il preciso scopo di fornire allo sviluppatore un modo efficace di organizzare il codice usando delle variazioni del design pattern MVC, ovvero quella logica di programmazione che prende in considerazione tre tipi di entità:

• Modelli (models): rappresentano l’astrazione dei dati. Un modello notifica a tutti i componenti che stanno “osservando” il suo comportamento quale sia il suo stato attuale. Per fare un esempio più concreto, un modello definisce il tipo di dato in questione: può rappresentare una persona, una nota, un file, un articolo.
• Viste (views): sono gli elementi che compongono l’interfaccia di un’applicazione. Generalmente (ma non necessariamente) ad ogni vista è associato un model (per esempio, nella parte di interfaccia che mostra un’ipotetica lista di articoli, ogni riga della lista è costituita da una view, quindi ad ogni view è associato il model dell’articolo). Il compito della view è quello di “osservare” il comportamento del model associato ed agire di conseguenza, ma senza interferire con esso.
• Controller: è quella parte dell’ applicazione che gestisce gli input (ovvero le azioni dell’utente) e modifica i model di conseguenza. Quando un model viene modificato o cambia di stato per mezzo del controller, la view associata, che sta “osservando” quel model, opera gli opportuni cambiamenti. Quindi possiamo dire che il controller gestisce le view indirettamente.

Solitamente i models sono raggruppati in collections, ovvero “liste di models” che possono anch’essi essere associati ad una o più views, come succede per i models.

Ecco uno schema di come funziona la maggior parte dei frameworks MVC:

Per sapere di più sui javascript design patterns ti consiglio di leggere questo mio articolo:

• Web Applications: scrivere codice ben strutturato con i Javascript Design Patterns

HTML5 Mobile App: perché usare un framework MVC

Un’applicazione Mobile realizzata in HTML5, CSS3 e Javascript rappresenta a tutti gli effetti una single-page-application.

Anche le app più semplici, che magari sono costituite da 3 o 4 schermate, il più delle volte hanno una user-interface molto complicata, a causa di tutte le richieste HTTP presenti, gli aggiornamenti del markup, le modifiche del DOM ecc. (senza contare che una schermata ne può avere di per sé altre al suo interno, come per esempio in una lista di elementi ).

Gli sviluppatori che scrivono “a naso” il loro codice, quindi senza utilizzare dei framework per la struttura logica dell’applicazione, inconsapevolmente creano delle view, dei model, e dei controller: l’unica differenza è che tutto ciò che fanno non è riusabile, ne tantomeno mantenibile.

In altre parole, finché il progetto rimane di piccole dimensioni riesce a “stare in piedi”, ma appena si complica anche solo di poco e diventa necessario aggiungere o modificare una parte dell’interfaccia, allora molto probabilmente cadrà in mille pezzi.

I Javascripts frameworks MVC, oltre a fornire robusti e stabili controlli come Models, Views e Controllers, forniscono anche una solida struttura, comprensiva di soluzioni testate negli anni da una gigantesca community di sviluppatori, che prima di noi hanno affrontato e risolto tutti gli stessi problemi logici e di programmazione in cui potremmo incappare nei nostri progetti.

Ciò può costituire un incredibile risparmio di tempo (se sei un web designer o sviluppatore sicuramente saprai cosa significa).

Non so se hai mai notato applicazioni come Asana, Trello, Todoist, Wunderlist, ma anche Twitter o gli stessi Gmail e Google Drive (la lista sarebbe infinita): si tratta di single page application che caricano tutte le risorse come script, stili e views all’inizio, per poi modificare l’interfaccia con i dati che hanno già ottenuto, senza mai ricaricare la pagina, ma lasciando tutto il “duro lavoro” della gestione dei dati (creazione, modifica, eliminazione) al server, attraverso opportune richieste HTTP asincrone (le chiamate ajax).

Quindi, ricapitolando, se stai progettando un’applicazione che, come appunto tutte le HTML5 mobile app Ibride (ma anche le web application desktop), si serve di un servizio dati API di back-end, e si deve solo preoccupare di gestire le varie parti dell’interfaccia senza ricaricare mai la pagina (Single Page Application), allora l’impiego di un Javascript Framework MVC è proprio quello che ti serve.

Tuttavia, se stai progettando una semplice app in cui la generazione del markup risiede perlopiù nel server, mentre lato-client sono sufficienti pochi comandi jQuery per modificare il DOM del documento (come generalmente accade in un normale sito web), allora forse non ha senso impostare il tuo prossimo progetto basandolo su di un framework MVC, situazione in cui tutte le sue funzionalità sarebbero superflue.

Ma noi stiamo parlando di HTML5 Mobile App giusto?

Il framework MVC è quello che fa al caso nostro.

---

La scelta giusta per #HTML #mobileapp – i #framework #MVC
Click To Tweet

---

La difficoltà nell’apprendere la programmazione MVC

A causa del vertiginoso progresso dei dispositivi client (in particolare di quelli mobili) che sta avvenendo in questi ultimi anni, il numero di sviluppatori javascript (quindi in particolare quelli che si occupano di interfacce front-end) è cresciuto a dismisura, e questo tipo di programmazione ha subìto come una “rinascita”.

Il tipo di linguaggio non è molto diverso da quello con il quale la maggior parte degli sviluppatori sono stati abituati a programmare in passato, sia per quanto riguarda la realizzazione di desktop software che di web application. Nel corso degli anni, infatti, gli sviluppatori sono stati abituati ad usare diversi tipi di linguaggi, come C++ o Java per i software client, o PHP, ASP, Python, ASP.NET ecc. per quelli web-based.

Linea temporale della nascita e dell’utilizzo nel corso degli anni dei linguaggi di programmazione più usati

Possiamo affermare che la logica dell’ MVC per strutturare un’applicazione deriva effettivamente dalle precedenti generazioni di linguaggi, sin dagli anni 70.

Tuttavia, per tutti coloro che in questi ultimi anni hanno iniziato la propria carriera di web designers con linguaggi come ASP o PHP, è ancora molto difficile iniziare a comprendere il funzionamento di un’applicazione Javascript MVC.

E’ normale.

E’ normale soprattutto per quelli che fanno un utilizzo massiccio di codice lato-server per la generazione dell’interfaccia, i quali si trovano molto confusi, in particolare per quanto riguarda i concetti di view e di generazione di markup lato-client.

Effettivamente quello di comprendere la logica MVC è uno scoglio abbastanza grosso da abbattere, ma una volta superato questo ostacolo il divertimento è assicurato:

• velocità di scrittura
• organizzazione tra le viste
• riusabilità di una stessa vista da tutte le parti dell’applicazione
• scalabilità del codice: l’applicazione è facilmente espandibile e riducibile senza alcun problema
• estrema separazione del codice lato-client e codice lato-server – che costituisce un’altro elevato fattore di scalabilità e mantenibilità

sono solo alcuni dei vantaggi che offre l’MVC.

Sei mai stato a Mirabilandia?

Periodicamente mi piace andare con i miei amici a Mirabilandia, che si trova a Ravenna, a sole due ore di macchina da dove vivo (Città di Castello, Perugia); nonostante i vari impegni, cerco di andarci nel mezzo della settimana, quando c’è meno gente ed è possibile divertirsi con le varie giostre senza fare code troppo elevate.

La giostra che mi piace di più è il Katun (l’hai mai provato?).

Fonte della foto: Flickr

 

Il Katun è progettato in modo tale che appena la giostra parte c’è una salita non indifferente, che viene percorsa molto piano, in modo da alimentare la paura del visitatore, prima di partire a grande velocità.

E ci riesce eccome! Ogni volta che salgo per la prima volta nel Katun dopo molto tempo, l’ansia e la paura durante quella salita sono alle stelle, ma appena la giostra parte il divertimento è assicurato da una grandissima scarica di adrenalina, tanto che appena finito il giro, mi fiondo di nuovo a fare la fila per farne un’altro.

Posso dire che vado a Mirabilandia solo per salire sul Katun.

Imparare il framework MVC è un po come andare sul Katun, superata la salita iniziale, progettare interfacce web javascript e single page application diventa un vero e proprio divertimento, grazie alla semplicità e alla facilità con cui è possibile aggiornare le varie views in modo indipendente dagli altri componenti.

---

Programmare con #frameworks #MVC è come andare a Mirabilandia!
Click To Tweet

---

HTML5 Mobile App ed MVC: Conclusioni

Visto che stiamo parlando di HTML5 Mobile App sviluppate in HTML5, CSS3 e Javascript, e che applicazioni di questo tipo sono a tutti gli effetti single page application, ovvero quei tipi di progetti in cui la pagina non viene mai ricaricata e tutte le operazioni di creazione, modifica e cancellazione dei dati viene delegata al server tramite un servizio di restful API, invito enormemente tutti gli sviluppatori client a cominciare ad interessarsi all’MVC.

Siccome, analogamente a molti altri campi (come quello del  web marketing), ci stiamo affacciando solo ora a questo aspetto della programmazione, mentre molti altri paesi lo stanno già facendo da tempo, e siccome il mondo delle client web application è in costante evoluzione, qualsiasi web designer e sviluppatore front-end dovrebbe secondo me considerare di inserire l’MVC nelle proprie skills, magari dedicando parte del proprio tempo a capirne il funzionamento.

E tu cosa ne pensi? Hai mai provato a sviluppare un tuo progetto Javascript con la logica dell’MVC? Scrivilo nei commenti!