04 Piattaforme di Sviluppo (e non solo) Panoramica, …lia.deis.unibo.it › Courses › sm1415-info › lucidi › 04...Panoramica su Piattaforme di Sviluppo Prevalentemente a livello

Piattaforme di Sviluppo - Sistemi Mobili M 1 1

Sistemi Mobili M

Alma Mater Studiorum - Università di Bologna

CdS Laurea Magistrale in Ingegneria Informatica

II Ciclo - A.A. 2014/2015

Corso di Sistemi Mobili M (8 cfu)

04 – Piattaforme di Sviluppo (e non solo):

Panoramica, J2ME e Android

Docente: Paolo Bellavista

[email protected]

http://lia.disi.unibo.it/Courses/sm1415-info/

http://lia.disi.unibo.it/Staff/PaoloBellavista/

mailto:[email protected]

Piattaforme di Sviluppo - Sistemi Mobili M 2

Panoramica su

Piattaforme di Sviluppo

Molte soluzioni possibili oggi per fare sviluppo di middleware

e applicazioni per sistemi mobili. Perché?

Eterogeneità e frammentazione

Scelta market-driven

Caratteristiche molto differenziate dispositivi disponibili,

“piattaforme” e requisiti applicativi

Pletora di soluzioni: Symbian, Palm, RIM, Maemo/Meego, iOS,

Android, Java Mobile Edition (J2ME), .NET Compact Framework (CF),

Python, Lazarus, Brew, Flash Lite, Web runtime environment (micro-

browser, HTML5, XHTML/CSS, JavaScript, Mobile Ajax, …), …

Proviamo a mettere un po’ d’ordine…

Quali livelli coinvolti?


Panoramica su


Livello di sistema operativo (ad es. Android è un sistema

operativo?)

Livello di supporto runtime all’esecuzione (framework,

container, macchine virtuali, …)

Livello di supporto allo sviluppo - SDK (librerie,

componenti di supporto, container, …)

Ancora una volta livelli NON con contorni netti e NON

facilmente separabili…

Prevalentemente a livello di SO: Symbian, Palm, RIM

(BlackBerry), Maemo/Meego, iOS, Linux?, …

Prevalentemente a livello di supporto runtime

all’esecuzione: Kernel-based Virtual Machine (KVM) o Dalvik Virtual

Machine per Java, Common Language Runtime (CLR) per .NET, Flash

Lite, Web runtime environment


Panoramica su


Prevalentemente a livello di supporto allo sviluppo: mondo

J2ME, mondo .NET CF, ActionScript per Flash Lite, mondo Android,

Web runtime environment

Due principali categorie di approccio:

Basato su applicazioni native

Basato su integrazione con Web (specie vedi sforzo di

standardizzazione legato a HTML5)

Partiamo dal primo approccio, scegliendo di dare un’occhiata

a 4 famiglie di soluzioni principali: J2ME, .NET CF, Flash

Lite, Android


Panoramica su

J2ME, .NET CF, Flash Lite, Android


J2ME in una Slide

Edizione del mondo Java per dispositivi a risorse limitate (smart phone, set-top box) – http://www.oracle.com/technetwork/java/

embedded/javame/index.html

Bytecode messo in esecuzione su Kernel-based Virtual

Machine (KVM), indipendenza da SO

Concetto di configurazione: minime caratteristiche VM e

insieme librerie supporto per una famiglia orizzontale di dispositivi

Connected Limited Device Configuration (CLDC)

Concetto di profilo: librerie specializzate per le caratteristiche di

una specifica tipologia/classe di dispositivi

Mobile Information Device Profile (MIDP), sopra CLDC

Applicazioni Java su CLDC/MIDP vengono chiamate

MIDlet

Avete già visto che cosa si intende per Java Community Process (JCP) e

Java Specification Request (JSR)?

http://www.oracle.com/technetwork/java/embedded/javame/index.html







.NET CF in una Slide

Sottoinsieme di piattaforma .NET (circa 30% classi e

funzionalità) per dispositivi con MS Windows Mobile

Uso di Common Language Runtime (CLR); in linea di

principio, supporto per differenti SO e differenti linguaggi (ancora solo WinMobile, C# e VB.NET)

Idea di transizione morbida da sviluppo applicazioni

desktop a sviluppo per mobile, comunque spinto da un grande

vendor e comunità di sviluppatori

Costo correlato a esecuzione di codice intermedio (Common Intermediate Language – CIL)

Costo relativamente alto in termini di memory footprint

Non ha problemi di “frammentazione” come nel caso

J2ME


Adobe Flash Lite in una Slide

Tecnologia proprietaria popolare per sviluppo di

contenuto multimediale e giochi

Di base, supporto a grafica vettoriale e animazioni;

aggiunta di logica applicativa e di presentazione tramite

linguaggio ad-hoc, chiamato ActionScript, che esegue in un

supporto runtime

Transizione morbida per sviluppatori esperti in Flash

Soluzione incompleta per applicazioni stand-alone full-

fledged; soluzione non-general purpose

Integrazione forte con caratteristiche di basso livello dei

dispositivi, con conseguente buona efficienza

Performance limitate per costo gestione grafica vettoriale

Vedi tentativo analogo del mondo Java con JavaFX Mobile –

https://www.java.net/community/javafx

https://www.java.net/community/javafx


Android in una Slide

Lanciato da Google nel 2007 come piattaforma Apache free-software, basato su Linux

Applicazioni sviluppate in linguaggio Java e compilate in Dalvik Executable format (DEX – bytecode di tipo custom, ad es. più compatto di usuali .class)

Sottoinsieme abbastanza ampio di J2SE + ricca libreria di funzionalità di supporto (Android SDK) a disposizione della comunità di sviluppatori Gestione touch screen, sensori locali (accelerometri, GPS, …),

grafica 3D, supporto per location-based service, …

Anche qui problemi di frammentazione fra versioni diverse di SO e utilizzo di estensioni dello stack di supporto (data la apertura della soluzione)


Un Confronto su un’Applicazione Giocattolo

(Gavalas et al, IEEE Software, 2011)


Un Primo Confronto


Un Primo Confronto


Un Primo Confronto


Un Primo Confronto


Un Primo Confronto


Scendiamo maggiormente nel dettaglio:

Java 2 Micro Edition

In termini generali, diverse edizioni di “distribuzioni” Java

Ruolo centrale

dello stack

KVM +

CLDC +

MIDP


JSR 248:

Mobile Service Architecture (MSA)

17

In realtà, situazione più

complicata e

articolata

Importanti problemi di

frammentazione

MSA, in due

versioni:

full (17/14) o

subset (8/9)


J2ME: Configurazioni e Profili

Una configurazione definisce una piattaforma minima

per un raggruppamento orizzontale di dispositivi

Requisiti analoghi su memoria e capacità computazionali

Definisce caratteristiche linguaggio Java e virtual machine

disponibile su tale gruppo di dispositivi

“A Configuration is a specification that defines a minimum Java Platform

functionality for a family of devices. It defines the minimum number of Java

libraries, VM capabilities, Security specification, and a Generic Connection

Framework.”

Profilo come insieme di API aggiuntive che estendono una

configurazione con capacità utili per un gruppo specifico

di dispositivi “A Profile is a collection of Java APIs that supplement a Configuration to

provide capabilities for a specific device group or market type.”


J2ME: Configurazioni Disponibili

Connected Device Configuration (CDC)

Tipicamente per dispositivi con maggiori risorse computazionali che non low-end device come telefoni (ancora valido oggi?)

Ad esempio set-top box, inizialmente alcuni tipi di PDA, …

Connected, Limited Device Configuration (CLDC)

Per dispositivi con risorse particolarmente limitate

Macchina virtuale per CLDC: Sun’s Kilo Virtual Machine (KVM) Piccolo footprint di memoria (60K)

Memoria minima totale = 160K

Processori 16/32-bit

Velocità processore = da 8 a 32MHz

Hardware tipico configurazione CLDC

Per CLDC l’unico requisito forte è dimensione di memoria disponibile: Almeno 128K non-volatile per KVM e librerie CLDC

Almeno 32K volatile per KVM runtime


Profili J2ME

Ogni profilo definisce requisiti per una famiglia di

dispositivi associati a uno specifico mercato verticale

Estende (con un layer superiore) una configurazione. Sempre on

top di una delle configurazioni previste

Definisce una piattaforma Java standardizzata per una famiglia di

dispositivi a fini di interoperabilità (tentativo di ridurre problema di

frammentazione)

Include librerie di classi con granularità più fine che non in una

configurazione

Profili disponibili:

Mobile Information Device Profile (MIDP)

on top of CLDC. Include funzionalità GUI aggiuntive, supporto

multimedia e gaming, sicurezza end-to-end, supporto esteso a

connettività di rete per telefoni mobili e PDA entry-level


Profili J2ME Disponibili

(continua…)

…

Foundation Profile on top of CDC. Insieme di API Java di base per dispositivi con

capacità limitate; punto cruciale è mancanza di supporto GUI standard

Personal Profile

on top of CDC. Assieme a Foundation Profile, Personal Profile realizza l’ambiente per sviluppo di applicazioni adatto a PDA high-end. Personal Profile include l’insieme completo di API AWT, supporto per applet e Xlet

Personal Basis Profile

on top of CDC. Fornisce un ambiente di sviluppo per applicazioni con connettività di rete e un livello elementare di supporto grafico alla presentazione contenuti


MIDP: Requisiti Hardware

Memoria (in aggiunta a quella per CLDC)

128K non-volatile per componenti MIDP

8K non-volatile per dati persistenti delle applicazioni

32K volatile per KVM

Display

Schermo almeno 96x54 pixel

Display depth (o color depth o bit per pixel) almeno pari a 1-bit

Fattore forma pixel (aspect ratio) = 1:1

Periferiche di Input (una o più)

One-handed keypad

Two-handed keypad

Touch screen

Networking

Two-way

Wireless

Gestione intermittenza

Banda limitata


Architettura MIDP

Mobile Information Device (MID)

CLDC

MIDP

SO Nativo + Software di Sistema

Applicazioni

MIDP

Applicazioni

OEM-Specific

Classi

OEM-Specific

Applicazioni

Native

Original Equipment Manufacturer (OEM)


Libreria di Classi

CLDC

java.lang

java.io

java.util

javax.microedition.io

MIDP

javax.microedition.lcdui javax.microedition.midlet

javax.microedition.rms


Modello Applicazioni MIDP

Applicazioni MIDP vengono indicate con il termine “MIDlet”

Modello MIDlet è per molti versi simile al modello applet in J2SE: modello componente-container e gestione ciclo di vita

Anche supporto a sicurezza per applicazioni che condividono risorse/dati (tramite MIDlet Suite)

Ciclo di vita MIDlet descritto da transizioni di stato in stato, come indicato a fianco: Start – acquisizione risorse e inizio esecuzione Pause – rilascio risorse e ingresso stato di

“quiescenza” (wait) Destroy – rilascio risorse, distruzione thread e

fine di tutte le attività

Java Application Manager (JAM) per gestione ciclo di vita MIDlet

Pause

Active

Destroyed

sta

rtA

pp

d

es

tro

yA

pp

pa

us

eA

pp

de

str

oyA

pp


Tipico Stack Supporto J2ME

Mobile Information

Device Profile

KVM

CLDC = KVM + J2ME Core

API in questo esempio DSP chip

(e.g., ARM)

J2ME core APIs

Your

MIDlet Pagine gialle, orario treni e biglietteria, giochi, …

UI, HTTP networking, ...

Supporto thread,

no floating point…

32-bit RISC, 256K ROM, 256K Flash, 64K RAM

KVM + CLDC + MIDP: si realizzano applicazioni on top di questo

stack standardizzato, indipendenti da SO e dettagli hw


CLDC/MIDP:

qualche Dettaglio su Package Principali Package

javax.microedition.io

javax.microedition.lcdui (user interface per display lcd)

javax.microedition.midlet

javax.microedition.rms (persistent storage)

Supporto a widget per GUI utente Form, TextField, TextBox, DateField, List, Image, Gauge, Alert,

Canvas, Graphics, Display

Due differenti tipologie di API (livello di astrazione più alto e più basso) per gestione GUI

High level per widget, scrolling, ...

Low level per grafica e controllo GUI fine-grained

Classi per gestione eventi – Command e CommandListener

Più importante: è per tutti ovvio, vero , qual è il modello di threading sottostante?


Solito “Hello World”

in forma di MIDlet

import javax.microedition.lcdui.*;

import javax.microedition.midlet.*;

public class HiMIDlet extends MIDlet {

private TextBox textbox;

public HiMIDlet() {

textbox = new TextBox ("", "Hello World!", 20, 0);

}

public void startApp() {

Display.getDisplay(this).setCurrent(textbox);

}

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

}


MIDlet:

Gestione Semplice GUI import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class HelloWorld extends MIDlet implements

CommandListener { private Form mainscreen; private Form detailsscreen; private Display myDisplay; private Command exitCommand; private Command resetCommand; private Command detailsCommand; public HelloWorld(){ myDisplay = Display.getDisplay(this); mainscreen = new Form("Hello World"); detailsCommand = new Command("Details",Command.SCREEN, 1); resetCommand = new Command("Reset",Command.SCREEN,1); exitCommand = new Command("Exit", Command.EXIT, 1); }


StringItem strItem = new StringItem("Hello", " World"); mainscreen.addCommand(detailsCommand);

mainscreen.addCommand(resetCommand);

mainscreen.addCommand(exitCommand);

mainscreen.append(strItem);

mainscreen.setCommandListener(this);


myDisplay.setCurrent(mainscreen); }

protected void pauseApp() { }

protected void destroyApp(boolean unconditional) { }

MIDlet:

Gestione Semplice GUI


public void commandAction(Command c, Displayable s) {

if (c == exitCommand) {

destroyApp(false);

notifyDestroyed(); }

else if (c == detailsCommand) {

detailsscreen = new Form("Details");

detailsscreen.addCommand(resetCommand);

detailsscreen.setCommandListener(this);

myDisplay.setCurrent(detailsscreen); }

else if (c == resetCommand) {

myDisplay.setCurrent(mainscreen); }

}

}

MIDlet:

Gestione Semplice GUI


import java.io.*;

import javax.microedition.io.*;

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

public class PrimitiveMIDlet extends MIDlet

implements CommandListener {

private Display mDisplay;

private Form mMainForm;

private Command mExitCommand, mConnectCommand;


mDisplay = Display.getDisplay(this);

if (mMainForm == null) {

mMainForm = new Form("PrimitiveMIDlet");

mMainForm.append(new StringItem("", "Select Connect to

make a network connection"));

mExitCommand = new Command("Exit", Command.EXIT, 0);

mConnectCommand = new Command("Connect",

Command.SCREEN, 0);

MIDlet:

un Esempio più Realistico


mMainForm.addCommand(mExitCommand);

mMainForm.addCommand(mConnectCommand);

mMainForm.setCommandListener(this); }

mDisplay.setCurrent(mMainForm); }


if (c == mExitCommand) notifyDestroyed();

else if (c == mConnectCommand) connect();

}

private void connect() {

String url = getAppProperty("NetworkThreading.URL");

try { //interroga server e riceve risposta

HttpConnection hc = (HttpConnection)Connector.open(url);

InputStream in = hc.openInputStream();

int contentLength = (int)hc.getLength();

if (contentLength == -1) contentLength = 255;

byte[] raw = new byte[contentLength];

int length = in.read(raw);

MIDlet:



in.close();

hc.close();

// Show the response to the user.

String s = new String(raw, 0, length);

Alert a = new Alert("Response", s, null, null);

a.setTimeout(Alert.FOREVER);

mDisplay.setCurrent(a, mMainForm); }

catch (IOException ioe) { Alert a = new Alert(

"Exception", ioe.toString(), null, null);

a.setTimeout(Alert.FOREVER);

mDisplay.setCurrent(a, mMainForm); }

}


public void destroyApp(boolean unconditional) {}

}

MIDlet:


Quali potenziali problemi in uno scenario reale di utilizzo?


MIDlet:


Quali potenziali problemi in uno scenario reale di utilizzo?

Nessun feedback GUI durante intervallo di tempo richiesto per

connessione => utente “spazientito” che genera altri comandi…

Più importante: modello di threading

thread di sistema “prestati” all’esecuzione di una MIDlet

i soli thread di appartenenza della MIDlet sono quelli che

MIDlet esplicitamente istanzia

Come in altre tecnologie, ad es. per gestione GUI: thread di

sistema che si occupa di fare da event dispatcher; gestori

eventi devono restituire controllo rapidamente per non

bloccare interfaccia MIDlet

La soluzione più sensata sarebbe quindi…



if (c == mExitCommand)

notifyDestroyed();

else if (c == mConnectCommand) {

Thread t = new Thread() {

public void run() {

connect(); }

};

t.start(); }

}

MIDlet:


Quali potenziali problemi in questo caso?


Classe SingleWorker …

public synchronized void run() {

while (mTrucking) {

try { wait(); }

catch (InterruptedException ie) {}

if (mTrucking) connect(); }

}

public synchronized void go() {

notify(); }

Classe SingleMIDlet import java.io.*;

…

public class SingleMIDlet extends MIDlet implements CommandListener {

private Display mDisplay;

private Form mMainForm, mWaitForm;

private SingleWorker mWorker;

private Command mExitCommand, mConnectCommand, mCancelCommand;

…

MIDlet:




mDisplay = Display.getDisplay(this);

if (mMainForm == null) {

//preparazione form

…

mWorker = new SingleWorker(this, url);

mWorker.start(); }

mDisplay.setCurrent(mMainForm); }


if (c == mExitCommand) notifyDestroyed();

else if (c == mConnectCommand) {

mDisplay.setCurrent(mWaitForm); mWorker.go(); }

else if (c == mCancelCommand) {

mDisplay.setCurrent(mMainForm); mWorker.cancel(); }

}


public void destroyApp(boolean unconditional) {

mWorker.stop();

} …

MIDlet:



J2ME: Tipologie di

Connessione Web Supportate

HTTP/HTTPS Semplice da utilizzare

XML over HTTP/HTTPS Uso più diffuso di recente grazie a disponibilità di vari parser

Model: crea rappresentazione a oggetti di documento in memoria, ad es. DOM

Push: fa parsing di un intero documento, distribuendo eventi ai listener registrati, ad es. SAX

Pull: fa parsing di una porzione di documento alla volta, restituendo singolo elemento o tag

Inoltre, molto spesso, sfruttamento funzionalità fornite da JSR addizionali: fra tutte, JSR82 (Bluetooth), JSR179 (Location), JSR135 (Mobile Media), JSR180 (SIP), JSR172 (Web Services)


Esercitazione su J2ME: Come si Progetta Applicazione MIDlet

Identificare i dispositivi target

Identificare i profili supportati da quei dispositivi

Sviluppare applicazione Ad esempio, se in forma di MIDlet perché supportato

CLDC/MIDP, applicazione adatta per cellulari e piccoli pager

Richiede che l’ambiente di sviluppo sia integrato con ambiente CLDC/MIDP: MIDP reference implementation http://www.oracle.com/technetwork/java/index-jsp-138820.html

Possibilità di esecuzione per validazione e testing su emulatori MIDP Ad esempio si può utilizzare J2ME Wireless Toolkit e ktoolbar

per creare un progetto, progettare, implementare, configurare e validare la MIDlet

Probabilmente sarete più comodi a utilizzare Eclipse ME http://eclipseme.org/

http://www.oracle.com/technetwork/java/index-jsp-138820.html





http://eclipseme.org/


Ad es. Nokia J2ME SDK


Ricordatevi:

Processo Caricamento MIDlet

Web Page

JAM

Downloads

App

User

Selects

App

Advertise

App on

Web Page

Network Transfer Java Application

Manager

(Name,

Version,

Size,

…)

Jar File

Descriptor

File


Esercitazione su J2ME: Come si Progetta Applicazione MIDlet

Realizzare una piccola MIDlet context-dependent (ad

esempio, capace di fare playing di suoni o video differenti a seconda

della locazione corrente dell’utente), sfruttando funzionalità

definite in JSR 135 (nota anche come Mobile Media API,

http://java.sun.com/products/mmapi/) e JSR 179 (nota anche

come Location API, diverse implementazioni più o meno

“facilmente” disponibili, ad es. http://code.google.com/p/openlapi/)

Utilizzare, a propria scelta, strumenti di sviluppo come JavaME

Wireless Toolkit oppure Eclipse ME

Notare il sempre minore supporto a tecnologie “datate”

come Java ME…

http://java.sun.com/products/mmapi/

http://code.google.com/p/openlapi/


Cenni sul Modello di Sicurezza

J2ME non può supportare l’usuale modello di

sicurezza completo di J2SE Implementazione dei soli domini di protezione J2SE è più

grande dell’intera implementazione CLDC

Quindi, come implementare una qualche soluzione di

sicurezza per J2ME?

Linea guida - dividere il problema in due parti:

Sicurezza a livello VM (low-level)

Garantita dal verificatore a due fasi per class file inserito

in CLDC

Sicurezza a livello applicativo

Modello sandbox


Sicurezza:

Verificatore di Class File a 2 Fasi

Verifica off-device Strumento per pre-verifica aggiunge un attributo “stack map” a

ogni metodo nel file class Java per facilitare verifica in-device

Processo di pre-verifica (oneroso computazionalmente) è eseguito su

un sistema server o desktop prima che class file sia scaricato sul

dispositivo mobile

“stack map” aiuta poi a rendere più efficiente verifica in-device

più veloce

minore codice in VM e minore consumo memoria

Verifica in-device Verifica ambiente (ad es. requisiti memoria per esecuzione)

Bytecode check

Type check

Terminazione “propria”, ovvero opportuna (ad es. no istruzioni di

salto incondizionato)


Stack map attribute accresce dimensione di classfile di circa 5%

Sicurezza:

Verificatore di Class File a 2 Fasi


Sicurezza a Livello Applicativo:

Modello Sandbox

Applicazioni (MIDlet ma non solo) devono eseguire in un

ambiente chiuso da cui possono avere accesso solo alle

API definite da configurazione, profilo e da classi licenziate

supportate dal dispositivo Vi ricordate, vero, il modello di esecuzione in sandbox delle applet?

Più specificamente modello sandbox per MIDlet prevede: Class file devono essere stati adeguatamente verificati (garanzia

di essere validi)

Garanzia che sono disponibili all’applicazione solo le API definite da

CLDC, profilo e classi di estensione licenziate

Download applicazione avviene a livello cosiddetto nativo

(native code level) tramite Java Application Manager (JAM)

Vietato fare overriding del meccanismo di class loading standard

Vietato l’accesso a insieme di funzioni native che VM può utilizzare


Android: Architettura

Classica architettura di tipo gerarchico, strutturata a layer (a

complessità crescente dal basso verso l’alto)

Livelli:

Linux kernel

Librerie (native Linux)

+ Android runtime

(Dalvik VM + librerie

core)

Application

Framework

Applicazioni


Android: Architettura

Kernel Layer basato su classico kernel Linux

v3.x ed evoluzioni

introduce Hardware Abstraction Layer (HAL)

Libraries in linguaggio nativo (C/C++)

Android Runtime ambiente di esecuzione delle

applicazioni, scritte in Java

basato su Dalvik VM

Application Framework fornisce servizi evoluti, sempre

incapsulati in oggetti Java, alle applicazioni

Application Core App: fornite dal sistema

App scritte dagli sviluppatori…

Piattaforme di Sviluppo - Sistemi Mobili M

Android:

curiosità su evoluzione versioni

Ice Cream Sandwich 4.0.1 (Ottobre 2011) Linux kernel 3.0.1; launcher personalizzabile; App "Contatti" con integrazione social network; Android Beam (scambio di dati tramite NFC); Wi-Fi Direct, etc. etc.


Android:

curiosità su evoluzione versioni Jelly Bean 4.1.1 (Luglio 2012) Linux kernel 3.1.10; nuove funzionalità per condivisione foto/video tramite NFC; riconoscimento vocale avanzato; abbandono ufficiale al supporto Adobe Flash, etc. etc.

Kit Kat 4.4 (Ottobre 2013) Supporto per 3 nuovi tipi di sensore (vettore di rotazione geomagnetica, rilevatore e contatore di passi), aggiunta funzione contapassi; diminuito consumo batteria durante riproduzione audio; Android RunTime (ART) e nuovo compilatore, in via sperimentale, attivabile dalle Opzioni Sviluppatore (non su tutti dispositivi); ottimizzato funzionamento su dispositivi con poca RAM, …

Key Lime Pie 5.0 (Novembre 2014) Introduzione di Google Fit per attività fisiche; nuovo kernel Linux 3.10.x.; eliminazione della runtime Dalvik in favore di ART; supporto nativo a 64 bit; Bluetooth 4.1; miglioramento prestazioni grafiche grazie supporto OpenGL ES 3.1; miglioramento fotocamera grazie ad API dedicate; aggiunto multi-utente su smartphone; …


Kernel Linux 3.x

Hardware Abstraction Layer (HAL)

Gestione memoria

Gestione processi

Network stack

Power management standard Linux

…

52

Estensioni kernel Ashmem: gestore della memoria

condivisa; reference counting e deallocazione automatica da parte del kernel

Binder IPC: minimo overhead grazie all’uso di Ashmem (maggiore disciplina di accesso tramite descrittore di blocco di memoria)

Power Management avanzato: uso di varie politiche di gestione energia attraverso i WakeLock

Android:

SO Kernel Layer

Non è un vero e proprio SO kernel Linux. Mancano: Sistema gestione finestre nativo

Completo supporto GNU C library

Completo supporto utility standard Linux


Power Management

e WakeLock

Esempio evidente di cross-layering

Applicazione Android (con permessi di accesso a Power Manager) può ottenere controllo consumi energetici imponendo politica desiderata:

CPU sempre attiva, anche con display spento

CPU prioritaria con display almeno retroilluminato

…

Tramite WakeLock: lock di accesso alle funzionalità di Power Manager (diverse tipologie di WakeLock). Ad es:

… @Override

protected void onCreate(Bundle savedInstanceState) {

PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);

wl = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "DoNotDimScreen"); }

@Override

protected void onPause() { super.onPause(); wl.release(); }


Librerie native per grafica e multimedia

Dalvik VM progettata per dispositivi mobili: registry-based (sfrutta l’architettura

ARM). Perché, invece, com’è organizzata JVM tradizionale?

interpreta ed esegue i file dex, ottenuti dalla trasformazione dei file class

(riduzione 30% istruzioni necessarie e incremento prestazioni runtime)

supporto a garbage collector

Android:

Librerie Native e Dalvik VM

Surface Manager + Media Framework

3D Surface3D Surface3D Surface3D Surface

2D Surface2D Surface2D Surface2D Surface

SurfaceSurfaceFlingerFlingerSurfaceSurfaceFlingerFlinger

FrameFrameBufferBufferFrameFrameBufferBuffer

Audio Flinger

Audio Audio FlingerFlinger

App App App App

CameraCamera

Camera

Service

Camera

Service

OpenCOREOpenCOREVorbisVorbis MIDIMIDI

Media Player Service


Media RecorderService


Media Server

CameraCamera

Camera

Service

Camera

Service






CameraCamera

Camera

Service

Camera

Service






Media Server


Activity Una singola azione che l’utente può compiere attraverso una finestra (corrisponde di solito ad una schermata) È componente fondamentale in Android

Ad es. home activity

Intent Massima riusabilità delle activity Richiesta di compiere un’operazione (ad es. selezione numero telefonico) Raccolta da un componente che ha un Intent Filter compatibile

Service In esecuzione in background (no interazione con utente come activity) Utilizzabile da 1+ componenti No processo/thread dedicato in background

Broadcast Receiver Risponde agli Intent compatibili eseguendo le operazioni previste In genere, azioni di notifica (chiamata, sms) Ciclo di vita limitato alla risposta

Android:

Application Framework


Package e Activity Manager Gestiscono cicli di vita delle Activity e delle app, contenute in Android Package

(APK). Ogni APK contiene un descrittore (manifest), l’eseguibile dex e le risorse (xml, png, …), secondo una struttura di file system fissa e predefinita

Window Manager e View System Offrono servizi grafici evoluti impiegati direttamente dalle app. View System si basa

su classe View, ovvero componenti grafici che interagiscono con l’utente e responsabili della gestione degli eventi (no Java Swing e AWT)

Applications

Resource Manager e Content Provider Gestione risorse (tutti file eccetto codice) e accesso

condiviso a dati locali (RDBMS SQLite e persistenza tramite file)

Telephony, Notification, Location Manager

Consentono di accedere alle funzionalità telefoniche, di notifica e di localizzazione

Android: Application Framework


Core Application

Applicazioni vere e proprie (stesso modello di esecuzione che per

applicazioni sviluppate da terze parti e scaricate in secondo momento), pre-installate a default su macchine Android

Home application (e activity correlata): applicazione manager da cui è possibile lanciare esecuzione di altre applicazioni. Quale modello di threading?

Gestione messaggistica

Applicativo cliente per email

Rubrica contatti

Gestione mappe

Browser Web: browser engine WebKit

(open-source); utilizzato anche in Safari

e Google Chrome

Solo browser engine (parser HTML +

renderer + motore JavaScript)

Applications

Android: Core Application


Ciclo di Vita di una Activity

È il componente attraverso cui avviene

l’interazione con l’utente Estende classe Java Activity

In genere sono in esecuzione tante

activity in contemporanea: quella attiva

(in RUNNING) è però unica. Se è

visibile ma non attiva, è PAUSED,

altrimenti STOPPED

Per gestire il ciclo di vita è possibile

ridefinire i metodi di callback

OnCreate, OnStart, OnResume,…

Le activity impegnano risorse: una

activity può essere deallocata per

mancanza di risorse→ stato KILLED

Android dispone di un contenitore di

informazioni Bundle, con cui è

possibile salvare lo stato da ripristinare

alla riallocazione

STOPPED

OnCreate()

OnStart()

OnResume()

RUNNING

a) Nuova activity b) Tasto back

OnPause()

PAUSED

Activity non più visibile

OnStop()

OnDestroy()

INACTIVE

L’activity torna in primo piano


OnRestart()

Risorse di memoria scarse

INACTIVE

(KILLED)


OnRestoreInstanceState(Bundle)

OnSaveInstanceState(Bundle)

Bundle


Concetto di Conversazione:

Android Task Una App può contenere più activity:

indipendenti e disgiunte

fra loro correlate

Activity sono diverse dalle form

devono essere semplici

devono essere usabili e riusabili

→ è necessario strutturare activity a formare

una conversazione complessa con utente

(come per pagine Web)

Un task modella una conversazione

contiene stack di activity, anche di

app diverse: in cima c’è activity del task

attiva

Apertura di una activity la pone in cima

allo stack; sua chiusura la rimuove dallo

stack

può essere in foreground o in

background

MyFirstProject

processo

it.mypackage

MyActivity

App Dialer

processo Dialer

Contatti

Dialer

…

MyActivity

Contatti

TASK

root activity

top dello

stack


Intent e Intent Filter

Attivazione di un componente avviene tramite un Intent (di solito per passare da una activity alla successiva)

esplicito: componente da attivare è noto a compile time; necessita del descrittore Class del componente

implicito: componente da attivare non è noto a compile time; necessita che vengano specificate le seguenti informazioni

action e category: descrivono il tipo e l’azione che l’applicazione vorrebbe essere eseguita

url: specifica i dati che il componente attivato deve elaborare

mime type: specifica il tipo di dati Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setData(Uri.parse(“http://www.unibo.it”));

Componente viene scelto in base a Intent Filter (descrizione di quali intent una activity può gestire) dichiarati nel manifest, secondo un algoritmo di Intent Resolution

Intent repository su www.openintents.org

http://www.openintents.org/


Intent e Intent Filter

protected void onCreate(Bundle savedInstanceState) {

...

Intent intent = new Intent(); intent.setAction(MY_ACTION);

intent.addCategory(Intent.CATEGORY_ALTERNATIVE);

intent.addCategory(Intent.CATEGORY_BROWSABLE);

Uri uri = Uri.parse("content://it.mypackage/items/");

intent.setData(uri);

intent.setType("vnd.android.cursor.item/vnd.mytype");

startActivity(intent); ... }

<activity android:name="IntentActivity">

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.

LAUNCHER" />

<category android:name="it.mypackage.intent.

category.CAT_NAME" />

<data android:mimeType="vnd.android.cursor.item/

vnd.mytype" />

</intent-filter>

</activity>

Esempio

di file

manifest


Modello di Threading in Android

Ogni applicazione ha un thread singolo (a default) =>

semplice modello single-threaded (1 app: 1 thread)

1 applicazione: 1 thread di sistema “prestato” ad app: più activity

Possibilità di salvare stato in info bundle (non troppo dissimile da

modello di esecuzione stateful session bean in J2EE)

Ogni thread ha un Looper per la gestione di coda di messaggi


Modello di Threading in Android

Possibile sia 1) lanciare applicazioni diverse in unica Dalvik VM

(unico processo), sia 2) avere una Dalvik VM (processo) dedicata

per ogni singola applicazione

Default è la seconda opzione: ogni applicazione viene messa in VM

separata (processo separato), anche quando si effettua startActivity(intent) o startService(intent)

Come è possibile? Quali potenziali problemi?

Ad es. come realizzare restituzione di risposta da activity all’invocante?

startActivityForResult(Intent, int)

secondo parametro identifica chiamata

funzione di callback onActivityResult(int, int, Intent)

Se si desidera risparmiare in utilizzo risorse di sistema, occorre forzare

che differenti applicazioni condividano stesso userID

Android.sharedUserId=“PaoloBellavista” in file manifest

Quali potenziali problemi di sicurezza?


Android Scheduling

1. Foreground

2. Visible

3. Service

4. Background

Process level:

App A

App A

Foreground Thread Group

Background Thread Group

App B

App B

> 90%

< 10%

Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);


Asynchronous Techniques

Thread

Executor

HandlerThread

AsyncTask

Service (already partially discussed)

IntentService

AsyncQueryHandler

Loader


Android Threads

Act much like usual Java Threads

Cannot work directly on external User Interface objects (throw the Exception CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views”)

Cannot be stopped by executing destroy() nor stop(). Use instead interrupt() or join() (by case)

As usual, two main ways of having a Thread execute application code: Providing a new class that extends Thread and

overriding its run() method

Providing a new Thread instance with a Runnable object during its creation. In both cases, start() method must be explicitly called to actually execute the new Thread


Android Handler

Associated with a single thread and that thread's message queue

Bound to the thread/message queue of the thread that is creating it

Deliver messages and runnables to that message queue

Execute them as they come out of the message queue

Two main uses for a Handler:

To schedule messages and runnables to be executed as some point in the future

To add an action into a queue performed on a different thread


Handler Example


Android AsyncTask

Created on the UI thread and can be executed only once

Run on a background thread and result is published on the UI thread

The three parameters of an AsyncTask are: Params, the type of the parameters sent to the task upon

execution

Progress, the type of the progress units published during the background computation

Result, the type of the result of the background computation

Go through 4 steps: onPreExecute(): invoked on the UI thread immediately after task

is executed

doInBackground(Param ...): invoked on the background thread immediately after onPreExecute() finishes executing

onProgressUpdate(Progress...): invoked on the UI thread after a call to publishProgress(Progress...)

onPostExecute(Result): invoked on the UI thread after background computation finishes


AsyncTask Example


Violate the single thread model: the Android UI toolkit is not

thread-safe and must always be manipulated on the UI thread

In this piece of code, ImageView is manipulated on a worker

thread, which can cause really weird problems. Tracking down

and fixing such bugs can be difficult and time-consuming

To Summarize: Pay Attention…


Classes and methods also tend to make the code more complicated and more difficult to read

It becomes even worse when implementing complex operations that require frequent UI updates





Esempio: Sviluppo di un Launcher

Sostitutivo di Home

Una home custom si crea nel modo seguente:

1. Definizione di una nuova Activity

2. Dichiarazione nell’Intent Filter

dell’action MAIN di launcher

3. Ricerca app installate attraverso Package

Manager

4. Scelta delle sole app che presentano un

Intent Filter relativo a launch

5. Creazione di una View di selezione

(Button) per ogni app adatta

6. Definizione dell’evento di click: lancio di un

Intent

7. Associazione dell’evento alla View

Come già detto, home consente avvio di tutte le app, fungendo da launcher

Android piattaforma aperta – “All Apps are created equal” → possibile

personalizzare il sistema con la propria home


// Passo 1: definizione di nuova activity

public class CategoryTestActivity extends Activity {

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

LinearLayout activitiesList;

activitiesList = (LinearLayout)

findViewById(R.id.activitiesList);

// Passi 3 e 4: ricerca app e selezione su IntentFilter

Intent intent = new Intent();

intent.setAction(Intent.ACTION_MAIN);

intent.addCategory(Intent.CATEGORY_LAUNCHER);

PackageManager pkgManager = getPackageManager();

List<ResolveInfo> activities =

pkgManager.queryIntentActivities(intent, 0);

…


Sostitutivo di Home


…

for (ResolveInfo resolveInfo : activities) {

final ResolveInfo ri = resolveInfo;

Button button = new Button(this); //Passo5: un bottone per app

button.setText(resolveInfo.loadLabel(pkgManager));

// Passo 7: associazione evento-view

button.setOnClickListener(new OnClickListener() {

public void onClick(View v) {

Intent intent = new Intent(); //Passo6: lancio intent

ComponentName cn = new ComponentName(ri.

activityInfo.packageName, ri.activityInfo.name);

intent.setComponent(cn);

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

intent.addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK);

startActivity(intent);}});

activitiesList.addView(button);}}}


Sostitutivo di Home


<manifest xmlns:android=“...” package="it.mypackage">

<application android:label="@string/app_name">

<activity android:name=".HomeActivity"

android:label="@string/app_name">

<intent-filter> 

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />


HOME"> </category>


DEFAULT"></category>

</intent-filter>

</activity>

</application>

</manifest>


Sostitutivo di Home


Sicurezza in Android

(in una slide)

<manifest xmlns:android="http://schemas.android.com/apk/res/

android“ package="com.google.android.app.myapp" >

<uses-permission id="android.permission.RECEIVE_SMS" />

</manifest>

Classiche linee guida per sicurezza in Linux

A default ogni applicazione esegue in Dalvik VM dedicata e

con suo proprio processo separato. Quale PID/GID?

Identificatori di processo e gruppo assegnati da intervallo definito a

livello di sistema - FIRST_APPLICATION_UID, LAST_APPLICATION_UID

Permessi a livello di processo sono assegnati e controllati

in dipendenza da user ID & group ID assegnati ai

processi. Usualmente che cosa vi aspettate?

Permessi a grana più fine sono assegnabili (revocabili) anche per

singola operazione tramite file manifest


Esercitazione su Android

Realizzare una piccola Android App context-dependent (ad esempio, capace di fare playing di brani audio/video differenti a

seconda della locazione corrente dell’utente), sfruttando le API della libreria Media Framework (libreria nativa) e le API del Location Manager (Java-based, a livello di application framework)

Utilizzare, a propria scelta, strumenti di sviluppo come:

il semplice Android SDK - http://developer.android.com/sdk/index.html

oppure Android Development Tools (ADT) per Eclipse http://developer.android.com/sdk/eclipse-adt.html

Può essere anche il seme iniziale per una possibile attività progettuale…

Come ulteriore esempio di utilizzo di Android e di attività progettuale, si veda la pagina del sito Web del corso - http://lia.disi.unibo.it/Courses/sm1415-info/esercizi.html

http://developer.android.com/sdk/index.html

http://developer.android.com/sdk/eclipse-adt.html



http://lia.disi.unibo.it/Courses/sm1415-info/esercizi.html





Numerose Sorgenti Disponibili

per Info Addizionali Numerosi libri su Android:

E. Hellman, “Android Programming: Pushing the Limits”, Wiley,

Nov. 2013

Z. Mednieks, L. Dornin, “Programming Android: Java Programming

for the New Generation of Mobile Devices”, O’Reilly, Ott. 2012

R. Meier, “Professional Android 4 Application Dev.”, Wrox, 2012

F. Ableson, R. Sen, “Android in Action”, Manning, Feb. 2011

Android SDK ha una buona documentazione, ad es. di descrizione delle

API disponibili, di applicazioni di esempio, …


Altra documentazione è disponibile alla descrizione degli strumenti di

sviluppo

http://developer.android.com/guide/developing/projects/projects-

cmdline.html



http://developer.android.com/guide/developing/projects/projects-cmdline.html







iOS (o iPhoneOS):

una Velocissima Panoramica Approccio per molti versi simile ad Android in termini di

realizzazione di ampio ecosistema con modello di

sviluppo + API di supporto:

iOS utilizza una variante del kernel XNU alla base di MacOSX

Catena di strumenti per lo sviluppo è similmente basata su Xcode

SDK contiene API a vari livelli per supporto a:

SDK contiene anche iPhone Simulator, uno strumento per emulare look&feel

di iPhone su desktop sviluppatore. Non è un emulatore vero e proprio:

esegue codice generato per altro target (x86)

SDK richiede macchina con Mac OS X Leopard (o più recenti)

Eventi e controlli multi-touch

Accelerometro

Localization (i18n)

Fotocamera e media in generale (audio

mixing&recording, video playback, vari formati di

file immagine, OpenGL ES …)

Networking

Embedded SQLite database

Core Location (GPS, Skyhook WiFi, …)

Thread

Power management

File system

Security


iOS (o iPhoneOS):

Regole Regole Regole…

3.3.1 — Applications may only use Documented APIs in the manner

prescribed by Apple and must not use or call any private APIs.

Applications must be originally written in Objective-C, C, C++, or

JavaScript as executed by the iOS WebKit engine, and only code written in

C, C++, and Objective-C may compile and directly link against the

Documented APIs

3.3.2 — An Application may not itself install or launch other executable

code by any means, including without limitation through the use of a plug-in

architecture, calling other frameworks, other APIs or otherwise. No

interpreted code may be downloaded or used in an Application except for

code that is interpreted and run by Apple’s Documented APIs and built-in

interpreter(s)

Lo stesso SDK può essere scaricato gratuitamente ma richiede

iscrizione a iPhone Developer Program se si vuole rilasciare

software (pagamento + approvazione Apple)

Apple non ha annunciato nessun piano per piattaforma Java su iPhone;

parziale supporto invece per J2ME su iOS


iOS Multitasking

Multitasking Prima di iOSv4, multitasking limitato a un sottoinsieme di

applicazioni fornite dal produttore. Apple temeva eccessivo consumo di batteria dovuto a esecuzione simultanea di applicazioni third-party

A partire da iOSv4, multitasking supportato tramite 7 API per esecuzione background :

– Audio in background - Voice over IP

– Servizio di locazione in background - Notifiche push

– Notifiche locali - Terminazione task

– Switching veloce fra applicazioni

iOS come sistema aperto?

Open Source NO YES

Write anything you want NO YES

Device Homogeneity YES NO

iOS Android


Sviluppare per iOS:

Primi Passi

Per cominciare:

http://developer.apple.com/iphone/

Effettuare download di iOS SDK, che include :

Xcode

Strumento di emulazione iPhone

Strumenti di monitoraggio

Interface builder

Nota: applicazioni sono soggette all’approvazione di Apple (parte

integrante dell’accordo per SDK download) al fine di fare test di

affidabilità e altre analisi…

Applicazioni possono essere rifiutate se giudicate di "limited utility"




Alternative per Sviluppo su iOS

Strada primaria: utilizzo di Xcode e Objective C, come su

piattaforma MacOSX più tradizionale

Alternative:

Web application che utilizzano tecnologie AJAX/Javascript; possibilità di accesso tramite Safari

Utilizzo di Java

J2ME e AlcheMo per iPhone

Xmlvm

Installazione di Java su iPhone “unlocked” e “jailbroken”

By the way, sapete che cosa si intende in gergo per “unlocking” e “jailbreaking”?


Unlocking & Jailbreaking

Strettamente parlando, unlocking e jailbreaking sono processi diversi e distinti

Unlocking è il processo tramite cui dispositivo è reso compatibile con reti telefoniche per cui non era stato specificatamente licenziato (superamento locking con operatore dedicato)

Jailbreaking è il processo tramite cui si esce dalla propria “cella” in SO UNIX-like e/o si infrange il sistema di Digital Right Management (DRM). Forma specifica di crescita di privilegi di esecuzione

Per iOS, permette all’utente di eseguire codice e applicazioni arbitrarie, passando sopra al meccanismo usuale di distribuzione di codice di Apple (basato su iTunes App Store e iTunes Application)

Per chi si voglia divertire con proprio iPhone, strumenti:

PwnageTool, QuickPwn, Yellowsn0w http://blog.iphone-dev.org/

Pusher - http://ripdev.com/pusher/

Linux on iPhone - http://www.iphonelinux.org/index.php/Main_Page

ZIPhone - http://www.ziphone.org/

http://blog.iphone-dev.org/



http://ripdev.com/pusher/

http://www.iphonelinux.org/index.php/Main_Page

http://www.ziphone.org/


iOS:

AJAX & JavaScript

AJAX (“forse” Asynchronous JavaScript and XML): insieme di

tecniche interrelate per sviluppo di applicazioni Web altamente interattive (rich Internet application)

Possibilità di data retrieval asincrono in background, senza interferire con comportamento e visualizzazione pagina corrente

Per certi versi, applet come precursori di AJAX

Con browser Safari, possibilità di applicazioni Web fortemente interattive e “native looking”

Domanda: quali vantaggi nell’utilizzare applicazioni Web invece di applicazioni native?

AJAX plugin per Eclipse (anche in versione standalone): http://www.aptana.com/

http://www.aptana.com/

http://www.aptana.com/


Anche proposte che hanno avuto successo in termini di standardizzazione. Ad esempio:

Elemento canvas come estensione JavaScript third-party che permette rendering dinamico di immagini bitmap

Introdotto da Apple per utilizzo nel componente Webkit di MacOSX (alla base di browser Safari), poi adottato da Mozilla e Firefox

Standardizzato da WHATWG (vedi ultimo lucido) per le nuove proposte di specifica verso HTML5

Canvas è una regione “disegnabile” definita in codice HTML con attributi di altezza e larghezza. Codice JavaScript può usare un set ampio di funzioni di disegno, permettendo così grafica generata dinamicamente (grafici, animazione, composizione di immagini, …)

In competizione e concorrenza con Macromedia Flash/FlashLite. Vedi due esempi demo:

http://www.damonkohler.com/2008/12/javascript-painting-with-canvas.html

http://www.benjoffe.com/code/demos/canvascape/

iOS:

AJAX & JavaScript








http://www.benjoffe.com/code/demos/canvascape/


HTML5 in una Slide

Ancora, la questione fondamentale è vantaggi&svantaggi di

Applicazioni Web vs. applicazioni native

HTML5 Nulla di sconvolgente, riprende classico modello di applicazioni Web a

ricca interattività

HTML5 = HTML + CSS + JavaScript

W3C, tramite il suo Web Hypertext Application Technology Working Group (WHATWG) ha annunciato che standard sarà definitivo per 2014!

Più in dettaglio:

Nuovi tag per AJAX e DHTML

Nuovi tag per gestione embedded audio e video (ad es. <video> tag)

Quanto supportati al momento attuale?

Migliore gestione struttura documenti

Provate a guardare:

http://dev.w3.org/html5/spec/ (draft 23 Marzo 2015)

http://slides.html5rocks.com/

http://dev.w3.org/html5/spec/

http://slides.html5rocks.com/


J2ME su iPhone:

alcheMo Abbiamo già detto NO supporto ufficiale a Java

Comunque possibile eseguire applicazioni Java su iPhone, dopo

jailbreaking, installazioni varie, ...

Strumenti di conversione sorgente:

ad esempio, alcheMo è in grado di convertire automaticamente applicazioni JavaME per iPhone, utilizzando un ampio sottoinsieme di funzionalità J2ME CLDC1.1 e MIDP2.0 (incluso supporto per touch screen) – comunque non troppo di successo nella comunità

Supporta diverse JSR aggiuntive, inclusa la recente JSR-256 (Mobile Sensor API), ma anche JSR-135 MMAPI, JSR-179 LBS, JSR-75

File Connection & Personal Info Management, JSR-120 Wireless Messaging

Supporta API addizionali per multi-touch e look&feel nativo iPhone

Processo di traduzione automatica rapido, senza requisiti di skill specifici ed esperienza di sviluppo su iPhone

http://www.innaworks.com/alchemo-for-iphone-java-me-j2me-to-iphone-porting.html

http://www.innaworks.com/alcheMo-for-iPhone.html


















http://www.innaworks.com/alcheMo-for-iPhone.html

Documents

04 Piattaforme di Sviluppo (e non solo) Panoramica, …lia.deis.unibo.it › Courses › sm1415-info › lucidi › 04...Panoramica su Piattaforme di Sviluppo Prevalentemente a livello