Evoluzione dei dispositivi mobili: Evoluzione dei dispositivi mobili



Scaricare 445 b.
02.02.2018
Dimensione del file445 b.









Evoluzione dei dispositivi mobili:

  • Evoluzione dei dispositivi mobili:

    • furono telefoni.. Ora "a volte" sono anche telefoni;
    • da dispositivi "sfortunati" (schermi microscopici a cristalli liquidi, tastiera minimale)..
    • ..a dispositivi «smart» e «phone», con schermo (multi)touch, rete, GPS, …
    • da sistemi embedded custom scritti dalle aziende produttrici di dispositivi mobili…
    • ..ad aziende che si preoccupano di supportare un sistema operativo oramai standard de-facto (uno dei).
  • Il mobile, i tablet, i futuri dispositivi di uso quotidiano, i «Very personal computers»…

    • …promettono di divenire gli strumenti più diffusi per la grande massa.. Avendo già oggi enorme diffusione.


Cha sviluppato per dispositivi mobili di "vecchia" generazione sa che:

  • Cha sviluppato per dispositivi mobili di "vecchia" generazione sa che:

    • il panorama dei dispositivi mobili è enorme,
    • testare una applicazione su tutti è un lavoro titanico,
    • l’hw è svariato, ma anche i so/framework sono tanti e molto diversi da utilizzare per sviluppare applicazioni,
    • il supporto a java (JME) da parte del mobile ha permesso l’esistenza di applicazioni (quasi) portabili..
    • ..ma non del tutto e non sufficientemente robuste.
  • Cosa serve?

    • un sistema operativo unico, modulare, customizzabile dai produttori di dispositivi, che supporti tutte le periferiche presenti su mobile, robusto, aperto, …
    • un framework standard di sviluppo che permetta la realizzazione di applicazioni portabili e "controllate".




Ci fornisce:

  • Ci fornisce:

    • un framework comune programmabile in un linguaggio di programmazione unico e portabile,
    • strumenti di sviluppo (SDK) e di emulazione standard,
    • librerie di utilità comune contenenti API di base,
    • una «struttura» per le apps «incasellandole in un framework comune», non disomogenee tra loro,
    • strumenti per gestire periferiche, comunicazione, sicurezza, storage, interazione fra apps…
  • Prevede la realizzazione/utilizzo di:

    • Attività  porzioni di GUI
    • Servizi  attività "di background"
    • Persistenza  astrazione sulla persistenza dei dati
    • Notifiche  da mostrare all’utente permettendo interazione


Storage:

  • Storage:

    • strumenti di gestione della persistenza, alcuni dati fissi possono essere incorporati nell’applicazione come risorse, altri possono essere scritti nel dispositivo, su sd-card o quant’altro.
  • Networking:

    • accesso alla rete indipendente dal canale (WiFi, GPRS, …), a qualunque livello (socket utilizzabili).
  • Multimedia:

    • dipendono dalle capability del dispositivo.. Che possono essere verificate per adattare l’app.
  • Location access:

    • tramite GPS o IP, per identificare la posizione del dispositivo nel globo, si vedano navigatori, gmaps, …
  • Phone services:

    • accesso alle funzionalità del telefono come la gestione di chiamate, SMS, …


Java è un linguaggio portabile:

  • Java è un linguaggio portabile:

    • il codice sorgente (alto livello di astrazione) viene compilato in linguaggio macchina (basso livello di astrazione, bytecode) per una macchina virtuale il cui microprocessore non esiste;
    • una macchina virtuale (JVM) interpreta il bytecode per la CPU su cui la JVM viene eseguita;
    • il Just In Time compiler (JIT) traduce «al volo» (e ottimizza) il bytecode, fornendo performance migliori rispetto alla compilate per CPU «generiche».
  • Java è Object Oriented:

    • esistono i concetti di classe, interfaccia, oggetto, enumerazione, annotazione, package, polimorfismo riferimento, composizione, meccanismo, pattern, …


Classi, classi astratte, interfacce:

  • Classi, classi astratte, interfacce:

    • diversi livelli di astrazione:
      • classi  implementazione concreta
      • classi astratte  implementazione parziale
      • interfacce  dichiarazione di capacità
    • beata ignoranza… e indipendenza:
      • in una architettura SW le dipendenze devono essere minimizzate.
    • un occhio all’ereditarietà e al polimorfismo:
  • Facciamo un esempio assieme!



A cosa serve il class nesting?

  • A cosa serve il class nesting?

    • In qualunque architettura SW viene l’ora di implementare una classe concreta, solo metodi e niente classi innestate porta al procedurale!
    • Le classi anonime permettono il lambda-calcolo: porzioni di codice viene passato come parametro.
  • Che differenza c’è tra nesting e nesting statico?

    • il nesting statico altera il naming e permette hiding;
    • Il nesting mantiene riferimento all’oggetto di classe esterna generatore dell’istanza (ci può accedere).
  • In quale caso si trovano le classi anonime?

    • nesting NON statico, possono accedere agli attributi della classe esterna e alle variabili locali final.
  • Vediamo un esempio di nesting NON statico.



L’albero di mele può produrre mele:

  • L’albero di mele può produrre mele:

    • le mele SONO SUE e non di un altro albero;
    • le mele sanno a che albero appartengono;
    • senza albero non si producono le mele.


Classi astratte:

  • Classi astratte:

    • permettono di definire un’implementazione parziale;
    • consentono di forzare il polimorfismo;
    • tramite l’ereditarietà divengono uno strumento formidabile per il riciclo del codice.
  • Interfacce:

    • NON descrivono l’implementazione ma solamente l’interfaccia di chi dichiara di implementarle;
    • rappresentano delle capacità o un tipo;
    • clonabile, eseguibile, ascoltatore, esecutore, …
  • Come scegliere?

    • Separare i concetti astratti dalle problematiche implementative concrete, utilizzare il proprio framework per poterne valutare la correttezza.


eXtendible:

  • eXtendible:

    • l’XML è un meta-linguaggio, è quindi possibile definirne istanze proprietarie che lo “estendano”;
    • nuovi tag e nuovi attributi possono essere definiti, assieme alle regole grammaticali per utilizzarli.
    • esempio: XHTML e RSS sono due diverse applicazioni XML, con scopi e gramatiche differenti.
  • Markup:

    • “come per le bustine da congelatore”, l’XML ha lo scopo di contenere e conservare… dati etichettati;
    • i tag sono i contenitori, gli attributi sono le etichette.
  • Language:

    • sarebbe più corretto meta-language, solo la sintassi è definita, la grammatica dei tag è definita nelle istanze.




Strumenti:

  • Strumenti:

    • kit di sviluppo applicazioni in java (JDK JSE),
    • un ambiente di sviluppo (noi useremo NetBeans),
    • Android SDK tools (gestione SDK e AVD),
    • SKD per una specifica piattaforma Android, da installare tramite SDK Manager dei tools,
    • Android Virtual Devices da installare tramite AVD Manager (emulazione dispositivi hardware),
    • plug-in per l’ambiente di sviluppo (ADT per Eclipse, Android di kenai per NetBeans), eventuali altri plug-in (ad esempio per lo unit testing di applicazioni).
  • Per iniziare:

    • installato il SW richiesto, creare un dispositivo virtuale (e configurarne l’hardware), avviarlo (e giocarci un po’), creare un primo progetto di prova (hello world), e provarlo.


da AVD Manager, creare un dispositivo…

  • da AVD Manager, creare un dispositivo…

  • selezionare l’hardware di interesse (periferiche come l’SD e il touch screen sono in generale utili),

  • Start! Il dispositivo avrà a bordo un SO (Linux) e una versione di Android, nell’esempio 2.3.3.



Creare un nuovo progetto Android in NetBeans

  • Creare un nuovo progetto Android in NetBeans

    • installato il plugin, filenuovo progettoAndroid…
    • …ERRORI… di già! Perché?
    • Gli strumenti di Android autogenerano parte di codice, in particolare la classe R delle risorse (vedremo),
    • compilare per ottenere le classi autogenerate in gen.
  • Struttura dell’applicazione impacchettata:

    • in un file apk.. Che è un file zip «camuffato»,
    • all’interno un android manifest in XML,
    • la directory delle risorse con un layout in XML,
    • le classi, le risorse,
    • un certificato firmato per lo sviluppo,
    • META-INF con manifest.. con l’SHA delle risorse.


L’attività è una porzione di interfaccia utente:

  • L’attività è una porzione di interfaccia utente:



Cosa rappresenta R.layout.main???

  • Cosa rappresenta R.layout.main???

    • una costante della classe R, vediamola:


Compilazione:

  • Compilazione:

    • Build… e lo script ant esegue:
      • la generazione del codice (classe R)
      • la compilazione del codice
      • il packaging delle classi e delle risorse
      • la firma digitale di sviluppo
      • il packaging dell’applicazione in un file apk (android package, file zip «camuffato»).
    • Dare un occhio a tools/ant/build.xml nell’SDK.
  • Esecuzione:

    • installazione nell’emulatore (deve essere avviato),
    • esecuzione dell’applicazione con creazione attività.


AndroidManifest.xml:

  • AndroidManifest.xml:

    • meta-dati che descrivono l’applicazione:
        • nome, icona, elenco delle attività, …
  • Struttura directory:

    • /res  risorse (immagini, layout in xml, valori, …)
    • /gen  codice generato a partire dal contenuto di res
    • /src  sorgenti java scritti da noi
    • /assets  se vi serve incapsulare file custom vostri come risorse, da aprire come raw data…!
  • Classe R:

    • la troviamo nello stesso package della main activity;
    • nella radice dei package troviamo R.java.d
        • elenco di file utilizzati per produrre il contenuto della classe R


Proviamo in maniera «rozza» a creare una piccola applicazione che inverte una stringa:

  • Proviamo in maniera «rozza» a creare una piccola applicazione che inverte una stringa:

    • nuovo progetto «InvertiStringhe»,
    • modifichiamo la onCreate dell’attività come segue:


In esecuzione otteniamo quanto segue:

  • In esecuzione otteniamo quanto segue:



Cos’è ADB?

  • Cos’è ADB?

    • Android Debug Bridge
    • Un tool per interagire da console con il dispositivo fisico o emulato (leggere, scrivere, intallare, …).
    • Utilizzato principalmente per un debug veloce su dispositivi fisici (installazione molto più comoda).
    • Già a disposizione con Android SDK (driver?)
  • Installare i driver USB:

    • NON lasciate che windows installi i driver per voi (non ci riuscirà) ma scaricate quelli del vostro device.
    • Aggiungere al PATH: «…\android-sdk\platform-tools».
  • Sul dispositivo attivate l’opzione:

        • Impostazioni  Applicazioni  Sviluppo  Debug USB


Un primo test da cmd:

  • Un primo test da cmd:

    • da cmd: «adb devices»
        • List of devices attached
        • BC76704D2B24 device
    • notare che anche l’emulatore, se avviato, viene rilevato e può essere controllato tramite adb.
  • Copiare file:

    • adb push miofile percorsoSulDevice
    • adb pull percorsoSulDevice miofile
  • Installare applicazioni:

    • adb –s BC76704D2B24 install –s -r miaApp.apk
        • Installa miaApp sul dispositivo BC76704D2B24 reinstallandola (-r) e scrivendo sulla SD invece che nel telefono (-s)
  • Accedere al sistema tramite una console (shell):

  • Altre funzionalità «di rete» le scopriremo «giocando» con la rete per implementare applicazioni client/server:

    • connessione PPP, port forwarding sul device, …


Compilare in BetBeans per generare l’apk;

  • Compilare in BetBeans per generare l’apk;

  • da riga di comando (cmd):

    • entrare in Code\00_overview\InvertiStringhe\bin
    • eseguire il seguente comando adb:
      • per installare sul device (unico):
        • adb –d install –s –r InvertiStringhe-debug.apk
      • per installare sull’emulatore (unico):
        • adb –s install –s –r InvertiStringhe-debug.apk
      • se avete più dispositivi collegati:
        • adb -s BC76704D2B24 install -s -r InvertiStringhe-debug.apk
      • sostituendo il seriale col vostro.
  • Provate la vostra app! 



Preparazione della release:

  • Preparazione della release:

    • ogni applicazione installata in Android DEVE essere firmata digitalmente (automatico con chiave di debug durante lo sviluppo);
    • generiamo una nostra chiave con:
        • keytool -genkey -v -keystore miaChiave.keystor
      • ci chiederà password e altre info nostre;
    • modifichiamo ant.properties (build properties):
        • key.store=./miaChiave.keystor
        • key.alias=mykey
      • usate sempre lo stesso certificato, altrimenti:
        • gli utenti non potranno fare update a nuove versioni dell’app;
        • applicazioni/moduli diversi non potranno girare nello stesso processo;
        • applicazioni interagenti non potranno condividere permessi.
      • la procedura ant usa queste info per firmare automaticamente l’applicazione, fine lavoro!
    • ant release  il pacchetto di installazione apk viene generato 
  • Google Play:

    • registrarsi a https://market.android.com/publish;
    • richiesto la prima volta un pagamento di 25$;
    • occhio, una applicazione gratuita lo è permanentemente;
    • possibile aggiungere screen-shot, descrizioni, …


Approfondiremo l’analisi della struttura del progetto e della classe R (più risorse!).

  • Approfondiremo l’analisi della struttura del progetto e della classe R (più risorse!).

  • Passeremo dalla gestione «programmatica» della GUI dell’ultimo esempio a MVC.

  • Molti strumenti NON sono stati nemmeno menzionati, li scopriremo poco a poco!







©astratto.info 2017
invia messaggio

    Pagina principale