Come impostare le librerie FMOD*, Cocos2D-x*, e OpenAL* per Android* su architettura Intel®

Scarica documento

In precedenza, abbiamo visto le istruzioni su come compilare una libreria FFmpeg su architettura x86. La guida passo dopo passo spiega il processo di configurazione e compilazione di librerie diverse che sono utilizzate in giochi e file multimediali specificatamente per piattaforme x86. Vedremo la configura di FMOD*, Cocos2D-x*, and OpenAL*.

Configurazione e prerequisiti:

Prima di iniziare, ci occorre soddisfare alcuni prerequisiti di download.

Scarica Android ADT Bundle
Scarica NDK
Scarica e installa Cygwin*: Quando vengono richiesti i pacchetti selezionati, cercare i seguenti pacchetti e installarli:
Autoconf, Automake, binutils, gcc-core, gcc-g++, gcc4-core, gcc4-g++, gdb, pcre, pcre-devel,
gawk, make, python
NOTA: Selezionare anche la versione dell’interfaccia grafica utente di make, o non sarà possibile realizzare il progetto tramite NDK.
Scarica JDK
Scaricare Apache Ant

Ora occorre modificare alcune variabili ambientali.

Impostare JAVA_HOME = il percorso in cui è installato il JDK Java*, per me è: C:\Program Files\Java\jdk1.7.0_45
Impostare ANDROID_SDK_ROOT = il percorso completo della cartella SDK. Ad esempio: nel mio caso, ho scaricato ed estratto il bundle ADT in D:\android\, quindi il mio percorso è: D:\android\adt-bundle-windows-x86-20131030\sdk
Impostare NDK_ROOT = il percorso completo della cartella NDK, il mio percorso è: D:\android\android-ndk-r9b
Impostare NDK_ROOT = il percorso completo della cartella NDK, il mio percorso è: D:\android\android-ndk-r9b
Aggiornare la variabile Path per contenere il seguente path = nella cartella JDK, NDK, cartella JDK bin, cartella Cygwin bin, cartella ANT bin, cartella strumenti SDK e cartella piattaforma-strumenti SDK, ciascuna separata da un punto e virgola (;). Ad esempio, nel mio caso, aggiungerò quanto segue:
D:\cygwin64\bin;C:\Program Files\Java\jdk1.7.0_40\bin;D:\android\adt-bundle-windows-x86_64-20131030\sdk\tools;D:\android\adt-bundle-windows-x86_64-20131030\sdk\platform-tools;%JAVA_HOME%\bin;%ANT_HOME%\bin

NOTA: Non terminare le variabili con \ oppure ` oppure altri caratteri speciali.

FMOD

FMOD è una libreria commerciale per gestire l’audio. FMOD comprende un set di strumenti per la creazione di contenuti audio che riproduce file musicali di diversi formati su molti sistemi operativi diversi usati in giochi e applicazioni software per fornire funzionalità audio. Di seguito è presente una guida passo dopo passo per integrare la libreria FMOD in un’applicazione Andoid con l’aiuto dell’IDE Eclipse* specificatamente per una piattaforma x86.

Scarica FMOD. Scaricare la versione Android dell’API di FMOD Ex Programmer, come mostrato di seguito:

Per installare FMOD, estrarre «fmodapi44429android.tar.gz» tramite strumenti quali 7-zip in una cartella a scelta.

Costruzione tramite Android NDK:

Per implementare il sonoro tramite l’API FMOD Ex, occorre includerlo come programma C/C++ nel codice e referenziarlo attraverso jni nell’applicazione Android.

FMOD è dotato di librerie C/C++ richiamabili via JNI o linkabili al componente C/C++ dell’applicazione:

libfmodex.so per sviluppo generico.
libfmodexL.so per la stessa libreria, ma con debug logging che può consentire di determinare qualsiasi problema se necessario.

Le librerie FMOD sono attualmente fornite per la built armeabi e armeabi-v7a ABI per android-3 e la built ABI x86 per android-9.

{$FMOD INSTALLED PATH}\api\lib\$(ABI)

L’interfaccia audio completamente nativa OpenSL è il metodo di riproduzione predefinito per i dispositivi che lo supportano (android-9) e non necessita di file aggiuntivi. Per i dispositivi senza supporto OpenSL occorre utilizzare la modalità di uscita Audio Track, che necessita di un file jar FMOD. Questo file jar deve essere aggiunto all’applicazione Java per inizializzare e far funzionare l’uscita audio FMOD:

fmodex.jar

Ciò verrà discusso nel prossimo argomento.

NOTA: Dato che l’applicazione di esempio usata qui fa parte della libreria, non abbiamo incluso il codice per l’esempio; invece nel documento sono indicate solo le modifiche necessarie.

Inizializzazione Java

Per attivare l’uscita audio attraverso la modalità di uscita Audio Track occorre includere e inizializzare il driver audio Java FMOD nell’applicazione (non necessario se si usa la modalità di uscita OpenSL). Per fare ciò occorre garantire che fmodex.jar sia referenziato nel progetto Java e che si abbia importato il pacchetto org.fmod.FMODAudioDevice. Il driver audio Java FMOD richiede inoltre che l’applicazione carichi la libreria fmodex.

La classe FMODAudioDeviceè dotata di due funzioni che occorre richiamare per riprodurre l’audio. Sono richiamabili in qualsiasi momento, ma consigliamo di inserire le chiamate di funzione start() e stop() negli override onStart() e onStop() di Activity.

Costruzione di un programma di esempio per Android sulla piattaforma x86

Il processo di compilazione di un programma è lo stesso di quello tramite NDK. Diamo uno sguardo ad un esempio per dimostrarlo. Per questo esempio, useremo il programma di esempio situato nella cartella:

{$FMOD INSTALLED PATH}\examples\playsound

Lo chiameremo {$PROJECT DIRECTORY}. Ma prima di svilupparlo tramite NDK, occorre eseguire alcune modifiche:

Accedere alla cartella {$PROJECT DIRECTORY}\jni e aprire il file Application.mk.
Modificare il seguente codice:
APP_ABI := armeabi armeabi-v7a
to
APP_ABI := x86

Poi aprire Cygwin ed eseguire le seguenti attività per realizzare l’applicazione:

ndk-build

Aggiornare la variabile PATH in cygwin come segue:
export PATH=.:/cygdrive/{$PATH TO NDK}:$PATH
cambiare cartella al percorso del progetto:
cd /cygdrive/{$PROJECT DIRECTORY}
Eseguire il comando:
Questo realizzerà il progetto e lo renderà pronto all’implementazione.

NOTA: In questo caso sotitutuire tutti i caratteri «\» dal formato di percorso Windows* al carattere «/» per il formato di percorso basato su GNU.

Alla fine di una build corretta, vedrete il seguente messaggio in Cygwin:

`[x86] Prebuilt`	`: libfmodex.so <= jni/../../../api/lib/x86/`
`[x86] Install`	`: libfmodex.so => libs/x86/libfmodex.so`
`[x86] Cygwin`	`: Generating dependency file converter script`
`[x86] Compile`	`: main <= main.c`
`[x86] SharedLibrary`	`: libmain.so`
`[x86] Install`	`: libmain.so => libs/x86/libmain.so`

Ora che il progetto è realizzato è eseguibile tramite l’IDE Eclipse.

Esecuzione dell’applicazione tramite IDE Eclipse

Per avviare l’applicazione da IDE Eclipse, seguire questi passaggi:

Avviare Eclipse e fare clic su File > Import:
Scegliere l’opzione Existing Android... e fare clic su Next:
Sfogliare la directory principale del progetto, es. {$PROJECT DIRECTORY}, quindi accertarsi che l’opzione Copy projects... sia deselezionata e fare clic su Finish:
Comparirà un segno esclamativo rosso sul progetto importato nella scheda package explore come mostrato di seguito:
Per risolvere, fare clic su Window > Preferences come mostrato nella pagina precedente e comparirà la seguente finestra:
Fare clic sull’opzone New... e comparirà quanto segue:
Al posto del campo «Name», digitare:
FMOD_LIB
Quindi fare clic su File e sfogliare per trovare il seguente file:
{$FMOD INSTALLED PATH}/api/lib/fmodex.jar
Fare clic su OK.
Quindi fare di nuovo clic su OK e comparirà la seguente finestra; fare clic su Sì:
Verrà risolto l’errore relativo al punto esclamativo rosso.
Quindi fare clic su Project > Properties.
Poi selezionare C/C++ Build > Environment > Add:
Digitare ANDROID_NDK_ROOT nel campo Name e il percorso completo alla cartella installata nel campo Value. Fare clic su OK:
Quindi fare clic su Apply e poi OK:

Ora se si vuole avviare l’applicazione ma solo dopo aver copiato tutti i file dai due set di multimedia di esempio:

{$FMOD INSTALLED PATH}\examples\media\* and
{$FMOD INSTALLED PATH}\fmoddesignerapi\examples\media\*

Su una cartella chiamata fmod nella root della scheda SD.

NOTA: L’applicazione potrebbe non avviarsi nel simulatore.

Impostazioni specifiche per piattaforma x86

È essenziale quando si realizza un’applicazione specifica per piattaforma x86 che si eseguano le seguenti modifiche: (Queste modifiche erano state incorporate come parte della procedura della realizzazione del progetto.)

Accedere alla cartella {$PROJECT DIRECTORY}\jni e aprire il file Application.mk (crearne uno se non presente).
Modificare il seguente codice:
APP_ABI := armeabi armeabi-v7a
to
APP_ABI := x86

Output della build

L’output della build sarà situato in {$PROJECT DIRECTORY} nel modo seguente:

Le librerie generate, libmain.so e libfmodex.so, saranno presenti nella cartella {$PROJECT DIRECTORY}\libs\x86.

Gli oggetti generati saranno nella cartella {$PROJECT DIRECTORY}\obj.

Errori e problemi noti

Sono presenti errori durante la realizzazione tramite NDK, quindi impostare i permessi di accesso a «Controllo completo» per «Tutti».

Inoltre tenere a mente che l’applicazione potrebbe non avviarsi nell’emulatore e che sarà possibile avviarla sul dispositivo solo dopo aver copiato tutti i file dai due set di file multimediali di esempio:

{$FMOD INSTALLED PATH}\examples\media\* and
{$FMOD INSTALLED PATH}\fmoddesignerapi\examples\media\*

Su una cartella chiamata fmod nella root della scheda SD.

Cocos2D-x:

Allora adesso vediamo il processo di realizzazione di un’applicazione Android multipiattaforma con l’aiuto del motore di gioco Cocos2d-x specifico per la piattaforma x86.

Il programma di esempio utilizzato in questo documento per spiegare il processo fa parte del Cocos2d-x Game Engine e si trova nella cartella \samples\Cpp\ dentro la cartella cocos2d-x-2.1.1.

Cocos2d-Xè una porta multipiattaforma scritta in C++ utilizzabile con iOS*, Android, Windows, Marmalade, Linux*, Bada, e BlackBerry* 10. Questa porta è dotata di Lua* e JavaScript* come script binding. È possibile leggere la documentazione di supporto di Cocos2d-X sul loro sito.

Prima di utilizzare Cocos2d-x, accertarsi di soddisfare i prerequisiti come dettagliato in precddenza nella sezione Prerequisiti.

Scaricare Cocos2d-x:

Scaricare Cocos2d-x e scegliere la versione più recente. Inoltre ricordarsi di scegliere l’opzione Cocos2d-x semplice e non l’opzione -html5.

Passaggi per installare e configurare Cocos2d-x:

Estrarre il file zip scaricato nel passaggio precedente sull’unità C:\ Drive. Ho estrtto il mio su D:\Cocos2d-x.
Devono essere presenti due cartelle nella cartella Cocos2d-x. Per me sono: D:\Cocos2d-x\__MACOSX e D:\Cocos2d-x\cocos2d-x-2.2.1.
Impostare le variabili ambientali per Cocos2d-x come mostrato di seguito:
COCOS2DX_ROOT = il percorso completo nella cartella cocos2d-x-2.2.1, nel mio caso è: D:\Cocos2d-x\cocos2d-x-2.2.1

Prima di cominciare, rendere note alcune variabili in quanto saranno usate in modo estensivo attraverso:

{$ADT PATH} = il percorso completo nel bundle ADT Android, nel mio caso è: D:\android\adt-bundle-windows-x86_64-20131030
{$ECLIPSE PATH} = il percorso completo a eclipse fornito con il bundle ADT, per me è: {$ADT PATH}\eclipse
{$COCOS2D-X PATH} = il percorso completo alla cartella cocos2d-x-2.2.1, nel mio caso è: D:\Cocos2d-x\cocos2d-x-2.2.1
{$WORKSPACE PATH} = il percorso completo allo spazio di lavoro Android Eclipse, nel mio caso è: D:\and_proj_coco

Configurazione di un progetto Cocos2d-x in IDE Eclipse:

Eseguire Eclipse dal seguente percorso: {$ECLIPSE PATH}\eclipse.exe
Creare il workspace quando richiesto. Ho creato il mio in {$WORKSPACE PATH}, come mostrato sotto:
Fare clic su File > Import come mostrato di seguito:
Comparirà una finestra come quella mostrata di seguito:
Espandere la sezione Android. Quindi fare clic sull’opzione Existing Android Code Into Workspace e fare clic su Avanti, come mostrato sopra.
Fare clic su Browse... come mostrato sotto:
Andare a {$COCOS2D-X PATH}\samples\Cpp\HelloCpp\proj.android come mostrato di seguito e fare clic su OK: :
Per questo progetto di esempio, prima di fare clic su Fine, accertarsi di NON SELEZIONARE i progetti Copy nell’opzione workspace:
Dopo aver importato, Eclipse potrebbe visualizzare alcuni errori. Per ora ignorarli e procedere ai seguenti passaggi.

NOTA: In futuro, se non si vuole utilizzare il codice di progetto originale e si è sicuri che importare il codice di progetto nel workspace non influirà sull’esecuzione del codice, allora selezionare l’opzione cerchiata sopra
Poi ripetere i passaggi c – h con la differenza che invece di importare {$COCOS2D-X PATH}\samples\Cpp\HelloCpp\proj.android, verrà importato: {$COCOS2D-X PATH}\cocos2dx\platform\android come mostrato più sotto, è possibile selezionare il progetto Copy nell’opzione workspace se si desidera:
Se gli errori trovati al passaggio h non sono risolti a questo punto, procedere al seguente passaggio come segue.
Ora, nella scheda Package Explorer a sinistra, fare clic destro su libcocos2dx e fare clic su Properties, come mostrato di seguito:
Nella finestra che apparirà, fare clic sull’opzione Android nella scheda a sinistra e accertarsi che l’opzione Is Library sia selezionata, come mostrato sotto, quindi fare clic su Apply e finalmente su OK.
Analogamente, aprire la finestra Properties per il progetto HelloCpp seguendo i passaggi j – k per il profetto HelloCpp. Apparirà la finestra come mostrato di seguito:
Rimuovere qualsiasi cosa dalla sezione Library contrassegnata con una croce rossa e fare clic su Add.
Scegliere libcocos2dx e fare clic su OK come mostrato di seguito:
Ora è possibile vedere che la sezione Library è popolata da un contrassegno di spunta verde come mostrato sotto, quindi fare clic su Apply e OK:
A questo punto, Eclipse ricostruirà il progetto. Se tutti gli errori sono risolti allora ignorare questo passaggio. In caso contrario, allora eliminare il progetto HelloCpp esistente dalla scheda Package Explorer e accertarsi che mentre si elimina NON si scelga di rimuovere dal disco, in quanto NON È POSSIBILE ANNULLARE L’OPERAZIONE, ed eseguire di nuovo i passaggi c – h e i passaggi m – p:
Ora, il progetto dovrebbe risultare come questo:

Congratulazioni! Avete aperto correttamente il vostro progetto in IDE Eclipse. Ora continuiamo costruendo il vostro progetto.

Costruzione di un progetto Cocos2d-x in IDE Eclipse:

Dalla scheda Package Explorer, accedere a HelloCpp > jni > Application.mk come mostrato di seguito:
Aggiungere la seguente stringa alla build per la piattaforma x86:
APP_ABI := x86
Ora, dalla scheda Project nella barra menu superiore, prima fare clic su Clean, quindi Build Project, come mostrato di seguito:

Apertura e costruzione di un progetto Cocos2d-x tramite Cygwin:

Eseguire Cygwin e accedere alla cartella del progetto di esempio HelloCpp tramite il seguente comando:
cd /cygdrive/d/Cocos2d-x/cocos2d-x-2.2.1/samples/Cpp/HelloCpp/proj.android
Il percorso dipende da {$COCOS2D-X PATH}.
Accertarsi che la seguente stringa sia aggiunta al file Application.mk presente nella cartella /jni:
APP_ABI := x86
Per costruire il progetto, mentre si è nella cartella /proj.android, inserire il comando:
./build_native.sh

NOTA: Se si verifica un errore, accertarsi che:

I pacchetti necessari per Cygwin siano stati scaricati correttamente.
La variabile PATH di Cigwin contenga i percorsi alle cartelle Android NDK, SDK, JDK, e COCOS2D-X come menzionato nella sezione Prerequisiti.

Una volta che si segue e completa la procedura di costruzione, i binari sono generati nella seguente cartella:

proj.android\obj\local\x86

Ad esempio:

proj.android\obj\local\x86\libhellocpp.so
proj.android\obj\local\x86\libcocos2d.a

OpenAL (Open Audio Library)

OpenAL (Open Audio Library) è un’interfaccia di programmazione di applicazioni audio multipiattaforma (API). È progettata per un efficace rendering di multicanali e audio posizionale tridimensionale. Il suo stile e convenzione API assomigliano deliberatamente a quelli di OpenGL. Fin dalla versione 1.1, Creative ha fatto la sua implementazione proprietaria. Tuttavia, OpenAL-Softè ampiamente utilizzato come alternativa open source. Utilizzeremo una versione di OpenAL-Soft adottata soprattutto per Android.

Prima di iniziare a lavorare su OpenAL, scaricare quanto richiesto dalla sezione Prerequisiti.

Scaricare una sorgente aggiornata all’ultima versione di patch di OpenAL:

Per lavorare con OpenAL, occorre una sorgente aggiornata all’ultima versione di patch adattata specialmente per Android.

Grazie a Martins Mozeiko e Chris Robinson esiste una versione di OpenAL che è stata adattata alla piattaforma Android. Scaricare la versione più recente del codice sorgente OpenAL aggiornato all’ultima versione di patch.

Alternativamente, è possibile scaricare questa sorgente tramite il terminale Cygwin:

Eseguire Cygwin e inserire il seguente comando:
git clone http://repo.or.cz/r/openal-soft/android.git OpenAL
La repository sarà clonata in una cartella chiamata OpenAL in pwd, per me è: /home/user001 or ~.

NOTA: Nel caso della versione Windows di Cygwin, la cartella /home si trova nella directory dove è installato Cygwin. Nel mio caso è: D:\cygwin64

Come configurare la piattaforma x86:

Prima di iniziare a costruire, creare un normale progetto Android OpenAL Hello. Lasciare il percorso per la cartella del progetto {$PROJECT_DIR}, come: D:\openal_proj\HelloOpenAL.

Per compilare tramite OpenAL per Android, seguire questi passaggi:

Per compilare OpenAL occorre un file chiamato config.h. Copiarlo da
{$OPENAL_DIR}/android/jni
To
{$OPENAL_DIR}/include
NOTA: Qui, {$OPENAL_DIR}è il percorso completo per la directory OpenAL scaricata nel passaggio precedente. Per me è: ~/openal
Dopo aver effettuato la modifica, copiare questa cartella OpenAL nella cartella del progetto {$PROJECT_DIR}.
Aggiungere l’interfaccia nativa al progetto nei passaggi seguenti.
Ho usato il file org_pielot_helloopenal_HelloOpenAL.c per implementare i metodi di riproduzione audio dall’interfaccia nativa.
Quindi occorre creare due file make, Android.mk e Application.mk e inserirli nella cartella jni insieme con la cartella .c e il suo file intestazione personalizzato .h.
NOTA: Il dettaglio di questi file e la loro sistemazione vengono forniti al termine del documento.

Per configurare il progetto specificatamente per x86, accertarsi che i seguenti file siano modificati per contenere i rispettivi valori dati:

Application.mk

APP_OPTIM := release
APP_ABI := x86

Come realizzare il progetto:

Aprire Cygwin e accedere a {$PROJECT_DIR}:
cd /cygdrive/{$PROJECT_DIR}
dove {$PROJECT_DIR}è il percorso completo alla directory del profetto. Nel mio caso è:
cd /cygdrive/d/openal_proj
Esegire il seguente comando per includere il percorso nella cartella NDK nella variabile ambientale PATH di Cygwin:
export PATH=.:/cygdrive/{$PATH TO NDK}:$PATH
Ad esempio, nel mio caso:
export PATH=.:/cygdrive/d/android/android-ndk-r9b:$PATH
Eseguire il comando:
ndk-build
Questo costruirà il progetto OpenAL per l’architettura x86.

Output della build:

L’output della build sarà situato in {$PROJECT_DIR}:

Le librerie generate, libopenal.so e libopenaltest.so, saranno presenti nella cartella {$PROJECT _DIR}\libs\x86.

Gli oggetti generati saranno nella cartella {$PROJECT_DIR}\obj.

Librerie OpenSSL*:

Il seguente processo descrive come realizzare le librerie OpenSSL per Android su x86.

Prerequisiti

Un PC host con Windows 7 o successivo.
Dato che le librerie OpenSSL sono state sviluppate in linguaggio C nativo, il requisito primario per la compilazione è Android NDK, che ha il supporto integrato per compilare librerie per più piattaforme per specifiche architetture (ARM, x86, ecc.).

La sorgente OpenSSL Android è scaricabile sia da eighthave project che da guardian project su github.

Costruzione per x86:

Le impostazioni multipiattaforma sono realizzabili come per ogni altra applicazione Android tramite le impostazioni Application Binary Interface.

La seguente stringa deve essere aggiunta al file jni/Application.mk per realizzare le librerie per l’architettura x86.

APP_ABI := x86

Una volta installato NDK e scaricato OpenSSL Android e scompattato in un disco locale (ad esempio C:\openssl-android-master), seguire le istruzioni di seguito per realizzare le librerie per x86:

Aprire il prompt dei comandi (Start->All Programs->Accessories->Command Prompt).
Spostarsi nella cartella Android OpenSSL scaricata e scompattata, ad esempio,
>cd C:\openssl-android-master.
Assicurarsi di impostare le impostazioni di configurazione necessarie per x86, ad esempio APP_ABI := x86.
Dare il comando NDK build, ad esempio C:\openssl-android-master > ndk-build.
Ciò costruirà le librerie libssl, libcrypto, openssl.
Le librerie generate si trovano nella seguente posizione:
C:\openssl-android-master\libs\x86\libcrypto.so
C:\openssl-android-master\libs\x86\libssl.so

Informazioni sull’autore

Praveen Kundurthy lavora presso Intel® Software and Services Group. Ha un master in Ingegneria informatica. I suoi interessi principali riguardano le tecnologie mobili, Windows e lo sviluppo di giochi.