Obiettivo
Quest'articolo è un'introduzione per principianti sulla creazione di applicazioni native Android* (basate su NDK) per i dispositivi basati sull'architettura Intel®. Tratta anche del porting verso i dispositivi basati sull'architettura Intel di applicazioni NDK Android originariamente create per dispositivi basati su altre architetture. Analizzeremo due scenari, uno per mostrare il processo completo di creazione di una semplice applicazione Android* basata su NDK e l'altro per dimostrare un semplice processo di porting di un'applicazione Android basata su NDK affinché sia utilizzabile su dispositivi basati sull'architettura Intel.
Indice
a. Creare un progetto Android predefinito
b. Richiamare il codice nativo dai file sorgente Java
c. Usare javah per generare gli stub dell'header JNI per il codice nativo
d. Compilare il codice nativo con l'NDK per l'architettura Intel
e. Ricompilare, installare ed eseguire l'applicazione Android NDK per l'architettura Intel
Introduzione
È possibile incorporare codice nativo nelle applicazioni Android usando gli strumenti del Native Development Kit (NDK). Questo permette agli sviluppatori di riusare il codice legacy, codificare per l'hardware di basso livello o differenziare le applicazioni sfruttando funzioni che altrimenti non sarebbero ottimali o disponibili.
Questo articolo è un'introduzione elementare su come creare, dall'inizio alla fine, applicazioni basate su NDK per l'architettura Intel e include anche dei semplici casi di utilizzo per eseguire il porting di applicazioni esistenti basate su NDK verso dispositivi basati sull'architettura Intel. Sarà descritto dettagliatamente un semplice scenario di sviluppo di un'applicazione per dimostrare il processo.
Si presume che l'ambiente di sviluppo Android sia già installato, compresi l'Android SDK, l'Android NDK e l'emulatore x86 configurato per testare le applicazioni. Per ulteriori informazioni, si prega di fare riferimento alla sezione della comunità Android nel sito Web di Intel. Per mantenere un ambiente di sviluppo semplice, nella maggior parte dei casi si useranno strumenti della riga di comando Linux*.
Creazione di un'applicazione Android basata su NDK per dispositivi basati sull'architettura Intel - Procedura dettagliata di una semplice applicazione
Si presuma di avere del codice legacy che usa C e il linguaggio assembly per analizzare l'istruzione CPUID (per maggiori informazioni su CPUID, consultare http://en.wikipedia.org/wiki/CPUID*). Qui di seguito è il listato del file sorgente del nostro codice C “legacy” di esempio cpuid.c (che è solo a scopo dimostrativo).
Desideriamo richiamare cpuid_parse dalla nostra applicazione Android (solo a scopo dimostrativo; la funzione cpuid_parse prevede un buffer preallocato) e visualizzare l'output all'interno dell'applicazione.
Qui di seguito è descritta la procedura dettagliata per creare l'applicazione Android dall'inizio alla fine e usare il codice nativo legacy visto in precedenza.
1. Creare un progetto Android predefinito
Android SDK ha strumenti della riga di comando che consentono di generare una struttura di progetto predefinita per un'applicazione hello world tipica. Creeremo innanzitutto un progetto predefinito, quindi modificheremo i file sorgente Java in modo da poter aggiungere chiamate JNI e codice nativo.
Nella schermata precedente, abbiamo prima creato una directory chiamata labs/lab2 e usato lo strumento della riga di comando “android” per generare il progetto predefinito. Abbiamo specificato android-15 come livello di API e chiamato la nostra applicazione “CPUIdApp” con package com.example.cpuid.
Abbiamo quindi usato lo strumento della riga di comando “ant” per creare il progetto in modalità di debug e installare usando “adb” (o reinstallare se già esistente nell'emulatore e nella destinazione). Si presume che abbiate già un emulatore o un dispositivo collegato e che sia l'unico dispositivo che viene elencato nell'output del comando “adb devices”.
La schermata seguente mostra l'emulatore Android x86 con ICS dopo avere completato il processo precedente.
Facendo clic sull'applicazione, viene visualizzato l'output predefinito hello world dell'applicazione. Modificheremo ora l'applicazione per l'uso del codice nativo.
2. Richiamare il codice nativo dai file sorgente Java
Il progetto Android predefinito genera i file sorgente Java per un progetto hello world tipico con lo spazio dei nomi del pacchetto dato (es. com.example.cpuid). La schermata seguente mostra il codice sorgente generato per il file sorgente Java principale.
Per usare il codice nativo C/C++ nel nostro file sorgente Java, dobbiamo prima dichiarare la chiamata JNI e caricare la libreria nativa, come evidenziato nel riquadro giallo della schermata seguente.
Come mostra la dichiarazione, la chiamata nativa restituisce una stringa Java che possiamo usare ovunque nel nostro file sorgente Java. Come illustrato nella schermata precedente, abbiamo modificato TextView in modo che visualizzi la stringa ottenuta dalla chiamata nativa. Questa operazione è evidenziata nel riquadro rosso.
Questo è un caso molto semplice per dichiarare e usare le chiamate JNI native nei file sorgente Java delle applicazioni Android. Useremo quindi lo strumento “javah” per generare gli stub dell'header JNI per il codice nativo e aggiungere o modificare il codice nativo in modo che sia conforme con le header JNI native.
3. Usare “javah” per generare gli stub dell'header JNI per il codice nativo
Dobbiamo ora modificare il nostro codice nativo in modo che sia conforme alla specifica della chiamata JNI. Anche “javah” ci aiuta a generare automaticamente gli stub appropriati dell'header JNI in base ai file sorgente Java. Per generare le header lo strumento “javah” richiede file di classe Java compilati. Usiamo così lo strumento “ant” per generare rapidamente file di classe Java, come mostrato nella schermata sottostante (“ant debug”).
Usare “javah” per generare l'header jni come mostrato nella schermata (secondo riquadro giallo). Questa operazione creerà la directory “jni” e lo stub dell'header in base alla classe Java. La schermata seguente mostra lo stub dell'header nativa JNI generato.
Creare il corrispondente file sorgente C (“com_example_cpuid_CPUIdApp.c”) per l'header precedentemente generata. Qui di seguito è mostrato il listato del file sorgente:
Chiamiamo il codice nativo cpuid_parse e restituiamo il buffer analizzato come stringa JNI. Siamo ora pronti a compilare il codice nativo usando gli strumenti dell'NDK x86.
4. Compilare il codice nativo con l'NDK per x86
Per ulteriori informazioni sull'installazione e l'utilizzo dell'NDK per l'architettura Intel, si prega di fare riferimento alla sezione della comunità Android (/it-it/articles/ndk-for-ia) nel sito Web di Intel.
Gli strumenti dell'Android NDK usano un sistema di compilazione che, per compilare il codice nativo, richiede che nella cartella “jni” del progetto sia presente uno specifico file make Android personalizzato, “Android.mk”. Android.mk specifica tutti i file sorgente C/C++ nativi che devono essere compilati, le header e il tipo di compilazione (es. shared_library).
Qui di seguito è mostrato il listato make Android del nostro progetto (“jni/Android.mk”)
Questo è un semplice scenario con due file sorgente C in cui si specifica di compilare una libreria condivisa.
Possiamo ora inviare l'istruzione “ndk-build APP_ABI=x86” per compilare il codice nativo e generare la libreria condivisa. Il sistema di compilazione Android offre un file make supplementare, “Application.mk”, che possiamo usare per specificare ulteriori opzioni di configurazione. Se ad esempio specifichiamo nel file Application.mk tutte le architetture ABI supportate, ndk-build genererà le librerie condivise native destinate a tutte le architetture.
La schermata precedente mostra la compilazione riuscita del codice nativo per x86 e mostra anche la libreria condivisa che viene generata e installata. Siamo ora pronti a ricompilare la nostra applicazione Android da installare/eseguire sull'emulatore x86 o sul dispositivo di destinazione.
5. Ricompilare, installare ed eseguire l'applicazione Android NDK per l'architettura Intel
Possiamo usare “ant debug clean” per rimuovere i vecchi file di compilazione e inviare di nuovo il comando “ant debug” per avviare la compilazione completa del progetto Android. Usare “adb” per reinstallare l'applicazione sul dispositivo di destinazione o nell'emulatore x86, come mostrato nella schermata seguente.
La schermata seguente mostra l'icona dell'applicazione dentro l'emulatore x86 e il risultato dell'esecuzione dell'applicazione nell'emulatore x86.
Abbiamo creato correttamente, dall'inizio alla fine, un'applicazione Android basata su NDK.
Uso degli strumenti dell'NDK x86 per eseguire il porting verso dispositivi basati sull'architettura Intel di applicazioni NDK esistenti
Le applicazioni Android con codice nativo hanno in genere una struttura di progetto standard, con la cartella “jni” che contiene i file sorgente nativi e i corrispondenti file di compilazione Android.mk/Application.mk. Nella sezione precedente abbiamo visto un semplice esempio con codice sorgente nativo e il corrispondente file Android.mk.
Gli strumenti dell'Android NDK ci permettono di specificare in una volta sola tutte le architetture ABI di destinazione nel file Application.mk e generare automaticamente le librerie condivise native per tutte le destinazioni. Il sistema di compilazione Android inserirà automaticamente tutte le librerie native di destinazione all'interno del pacchetto APK e, al momento dell'installazione, il gestore dei pacchetti Android installerà solo la libreria nativa appropriata per l'architettura di destinazione.
Si può richiamare “ndk-build” oppure nel file Application.mk specificare
APP_ABI := all OPPURE APP_ABI := armeabi armeabi-v7a x86 |
Per ulteriori informazioni, fare riferimento a http://developer.android.com/sdk/ndk/index.html.
Per quanto riguarda il porting di un'applicazione Android esistente con codice nativo e che attualmente non è destinata all'architettura x86, il processo per modificare l'applicazione affinché supporti l'architettura Intel è semplice nella maggior parte dei casi (come descritto in precedenza), a meno che l'applicazione non usi costrutti o un linguaggio assembly specifici dell'architettura. Potrebbero anche incidere altri fattori, come l'allineamento della memoria o l'utilizzo di istruzioni specifiche della piattaforma. Per maggiori informazioni, fare riferimento a /it-it/articles/ndk-android-application-porting-methodologies.
Riepilogo
Questo articolo tratta della creazione e del porting di applicazioni Android basate su NDK per destinarle all'architettura Intel. Con una descrizione dettagliata della procedura abbiamo dimostrato il processo per creare dall'inizio alla fine un'applicazione basata sull'NDK che usi l'architettura Intel. Abbiamo anche descritto un semplice processo, reso disponibile dagli strumenti dell'NDK, per eseguire il porting di applicazioni Android basate su NDK esistenti per destinarle all'architettura Intel.
Avvisi
Intel è un marchio di Intel Corporation registrato negli Stati Uniti e in altri paesi
LE INFORMAZIONI CONTENUTE IN QUESTO DOCUMENTO SONO FORNITE IN ABBINAMENTO AI PRODOTTI INTEL. QUESTO DOCUMENTO NON CONCEDE ALCUNA LICENZA, IMPLICITA O ESPLICITA, MEDIANTE PRECLUSIONE O ALTRO, PER QUANTO RIGUARDA I DIRITTI DI PROPRIETÀ INTELLETTUALE. AD ECCEZIONE DI QUANTO STABILITO DAI TERMINI E DALLE CONDIZIONI DI VENDITA INTEL PER I PRODOTTI IN QUESTIONE, INTEL NON SI ASSUME ALCUNA RESPONSABILITÀ E DISCONOSCE QUALSIASI GARANZIA ESPRESSA O IMPLICITA RELATIVA ALLA VENDITA E/O ALL'UTILIZZO DI PRODOTTI INTEL, INCLUSA LA RESPONSABILITÀ O L'IDONEITÀ AD UNO SCOPO PARTICOLARE, LA COMMERCIABILITÀ O LA VIOLAZIONE DI BREVETTI, COPYRIGHT O ALTRI DIRITTI DI PROPRIETÀ INTELLETTUALE.
Una "Applicazione mission critical"è qualsiasi applicazione in cui i difetti del prodotto Intel potrebbero causare, direttamente o indirettamente, lesioni personali o decesso. QUALORA SI ACQUISTASSERO O UTILIZZASSERO PRODOTTI INTEL PER QUALSIASI APPLICAZIONE MISSION CRITICAL, È NECESSARIO INDENNIZZARE E SOLLEVARE INTEL E LE SUE SOCIETÀ CONTROLLATE, SUBAPPALTATORI E AFFILIATI E I RESPONSABILI, FUNZIONARI E DIPENDENTI DI CIASCUNA DI QUESTE ENTITÀ, DA QUALSIASI RESPONSABILITÀ PER EVENTUALI COSTI PER RECLAMI, DANNI, SPESE E SPESE LEGALI RAGIONEVOLI DERIVANTI, DIRETTAMENTE O INDIRETTAMENTE, DA QUALSIASI RESPONSABILITÀ DEL PRODOTTO, LESIONE PERSONALE O DECESSO CAUSATI IN QUALSIASI MODO DA TALE APPLICAZIONE MISSION CRITICAL, INDIPENDENTEMENTE DAL FATTO CHE INTEL O IL PROPRIO SUBAPPALTATORE ABBIA AGITO IN MODO NEGLIGENTE NELLA PROGETTAZIONE, FABBRICAZIONE O AVVERTENZE DEL PRODOTTO INTEL O DI QUALSIASI SUO COMPONENTE.
Intel può apportare modifiche alle specifiche e alle descrizioni dei prodotti in qualsiasi momento e senza preavviso. I progettisti non devono fare affidamento sull'assenza o sulle caratteristiche di qualunque funzione o sulle istruzioni contrassegnate come "riservate" o "non definite". Intel si riserva di definirle in futuro e non accetta alcuna responsabilità in caso di conflitti o incompatibilità derivanti da ogni loro modifica futura. Le informazioni sono soggette a modifica senza preavviso. Non finalizzare un progetto con queste informazioni.
I prodotti descritti in questo documento possono contenere errori o difetti di progettazione noti come "errata" che possono determinare l'errato funzionamento del prodotto, a differenza di quanto stabilito nelle relative specifiche pubblicate. Gli "errata" attualmente riconosciuti sono disponibili su richiesta.
Per ottenere le specifiche più recenti e prima di inoltrare l'ordine di prodotti, contattare l'ufficio vendite Intel di zona oppure il distributore di fiducia.
Le copie dei documenti con numero d'ordine citati in questo documento, o altra letteratura Intel, possono essere richieste telefonando al numero (USA) 1-800-548-4725 oppure visitando il sito: http://www.intel.com/design/literature.htm * Altri marchi e denominazioni potrebbero essere proprietà di terzi.
Copyright© 2012 Intel Corporation. Tutti i diritti riservati