Autore Topic: Primo (tentativo pietoso :) ) di un tutorial su NDK.  (Letto 6753 volte)

Offline vicvondoom

  • Utente junior
  • **
  • Post: 71
  • Respect: +4
    • Mostra profilo
    • vicvondoom
  • Dispositivo Android:
    Sony XPeria U
  • Play Store ID:
    Orlando Davide
  • Sistema operativo:
    Windows 8
Primo (tentativo pietoso :) ) di un tutorial su NDK.
« il: 20 Agosto 2010, 18:08:14 CEST »
+1
Tradotto (alla c***o :) ) da http://mobile.tutsplus.com/tutorials/android/ndk-tutorial/

Advanced Android!
Primo tutorial sull'uso dell'NDK (Native Development Kit, ovvero l'arte di programmare in C/C++ su Android ;) )

Prerequisiti.

Prima di iniziare, c'è bisogno di discutere un attimo sul livello di questo tutorial. E' un tutorial avanzato.
La ragione di questo è che gli autori assumono che tu abbia i seguenti prerequisiti:

1. Esperienza con Java e C.
2. Saper usare la linea di comando.
3. Conoscere e saper maneggiare le versioni di Cygwin, awk, e altri tools.
4. Essere a tuo agio con lo sviluppo sotto Android.
5. Avere un ambiente Android di sviluppo funzionante (gli autori usano Android 2.2).
6. Saper usare l'ambiente di Eclipse e capire le istruzioni d'uso.

Se non sei a tuo agio con i precedenti prerequisiti, sei comunque i benvenuto, ma potresti avere difficoltà su certi
passi che sarebbero facili da risolvere conoscendo un pò i prerequisiti.
Questo significa che l'uso dell'NDK è un processo che è incline a problemi e questioni anche per chi si considera un
programmatore veterano. Siate consapevoli che potrebbe essere necessario risolvere dei problemi prima di arrivare a
che tutto funzioni regolarmente sul proprio sistema di sviluppo.
Il progetto completo di esempio per questo tutorial può essere scaricato qui http://code.google.com/p/android-
ndk-tutorial-code/source/browse/#svn/trunk/jni



Fase 0: Scaricare i tools.

Bene, cominciamo. È necessario scaricare l'NDK. Fare questo in primo luogo e mentre scaricate potete controllare di
avere le versioni giuste del resto degli strumenti di cui si ha bisogno.
Scarica l'NDK per il tuo sistema operativo da http://developer.android.com/sdk/ndk/index.html

Ora, controlla le versioni dei tuoi strumenti con questi:

1. Se su Windows, Cygwin 1.7 o successiva.
2. Update di awk alla versione più recente (Stiamo utilizzando 20.070.501).
3. GNU 3.81 o successivo (Stiamo usando la 3.81).
Se una qualsiasi di queste versioni sono troppo vecchie, si prega di aggiornare prima di continuare.


Fase 1: Installazione dell'NDK.

Ora che il NDK è stato scaricato (giusto?), è necessario decomprimerlo. Fatelo e scompatattelo in una directory
appropriata. Abbiamo il nostro posto nella stessa directory che abbiamo messo l'SDK di Android. Ricordate dove
l'avete messo.
A questo punto, è possibile aggiungere gli strumenti NDK al percorso. Se sei su Mac o Linux, si può fare questo con
il vostro percorso di impostazione nativa. Se sei su Windows con Cygwin, è necessario configurare la path di Cygwin.


Fase 2: Creazione del progetto.

Creare un progetto regolare Android. Per evitare problemi in seguito, il progetto deve risiedere in un percorso che
non contenga spazi. Il nostro progetto ha un nome del pacchetto "com.mamlambo.sample.ndk1" con un nome predefinito di
attività di "AndroidNDK1SampleActivity" - vedrete che queste appariranno di nuovo.
Al livello superiore di questo progetto, creare una directory chiamata "JNI" - questo è dove mettere il codice
nativo. Se si ha familiarità con JNI, l'Android NDK è fortemente basata su concetti JNI - è, in sostanza, JNI con un
limitato numero di intestazioni per la compilazione C.


Passo 3: Aggiunta di un codice C.

Ora, all'interno della cartella JNI, creare un file chiamato native.c. Inserire il seguente codice C in questo file
per cominciare, poi aggiungeremo un'altra funzione più tardi:
Codice: [Seleziona]
#include <jni.h>
#include <string.h>
#include <android/log.h>

#define DEBUG_TAG "NDK_AndroidNDK1SampleActivity"

void Java_com_mamlambo_sample_ndk1_AndroidNDK1SampleActivity_helloLog
(JNIEnv * env, jobject this, jstring logThis)
{
    jboolean isCopy;
    const char * szLogThis = (*env)->GetStringUTFChars(env, logThis, &isCopy);

    __android_log_print(ANDROID_LOG_DEBUG, DEBUG_TAG, "NDK:LC: [%s]", szLogThis);

    (*env)->ReleaseStringUTFChars(env, logThis, szLogThis);
}

Questa funzione è in realtà abbastanza semplice. Prende come parametro un Java String object, lo converte in una
stringa C, e poi lo scrive nel LogCat.
Il nome della funzione, però, è importante. Essa segue il modello specifico di "Java", seguito dal nome del
pacchetto, seguito dal nome della classe, seguito dal nome del metodo, come definito in Java. Ogni pezzo è separato
da un trattino invece di un punto.
I primi due parametri della funzione sono critichi. Il primo parametro è l'ambiente JNI, spesso utilizzato con
funzioni di supporto. Il secondo parametro è l'oggetto Java di cui questa funzione è parte.


Fase 4: Chiamate native di Java.

Ora che avete scritto il codice nativo, torniamo verso Java. Per l'attività di default, creiamo un pulsante e
aggiungiamolo a un gestore pulsante dove si preferisce. Dal tuo gestore di pulsante, effettuare la chiamata a
helloLog:

Codice: [Seleziona]
helloLog("This will log to LogCat via the native call.");

Poi si deve aggiungere la dichiarazione di funzione sul lato Java. Aggiungere la seguente dichiarazione alla classe
di attività:

Codice: [Seleziona]
private native void helloLog(String logThis);

Questo dice al compilatore e al linker che l'attuazione di questo metodo sarà dal codice nativo.
Infine, è necessario caricare la libreria che contiene codice nativo. Aggiungere il seguente inizializzatore statico
per la classe di attività per caricare la libreria per nome (il nome della libreria è a tua scelta, e sarà di nuovo
riferimento nella fase successiva):

Codice: [Seleziona]
static {   
    System.loadLibrary("ndk1");   
}


Fase 6: Compilare il codice nativo.

Ora che il codice nativo è scritto e il vostro makefile è a posto, è il momento di compilare il codice nativo. Dalla
riga di comando (per gli utenti Windows consigliamo di farlo entro Cygwin), sarà necessario eseguire il comando NDK-
build dalla directory principale del progetto. Lo strumento NDK-build si trova all'interno della directory NDK tools.
E' meglio aggiungere questo tool al tuo path.
Su una successiva compilazione, è possibile assicurarsi che tutto sia ricompilato se si utilizza il "NDK-build clean".


Punto 7: l'esecuzione del codice.

Ora è tutto pronto per eseguire il codice. Caricate il progetto sul vostro emulatore preferito o device fisico,
controllate LogCat, e premere il pulsante.
Può essere successa una delle due seguenti cose. In primo luogo, può aver funzionato. Se è così, complimenti! Ma
meglio andare avanti ugualmente. Probabilmente ho un errore LogCat che dice qualcosa del tipo: "Could not execute
method of activity." Questo è buono. Significa solo che ti sei perso un passo. Questo è facile da fare in Eclipse. Di
solito, Eclipse è configurato per ricompilare automaticamente. Quindi, forzare Eclipse a ricompilare da "cleaning"
del progetto (Project-> Clean from the Eclipse toolbar).


Fase 8: Aggiunta un'altra funzione nativa.

Questa funzione prossimo dimostrerà di non ritornare solo valori, ma di restituire un oggetto, come uno String.
Aggiungere la seguente funzione di native.c

Codice: [Seleziona]
jstring Java_com_mamlambo_sample_ndk1_AndroidNDK1SampleActivity_getString(JNIEnv * env, jobject this, jint value1,

jint value2)
{
    char *szFormat = "The sum of the two numbers is: %i";
    char *szResult;

    // add the two values
    jlong sum = value1+value2;

    // malloc room for the resulting string
    szResult = malloc(sizeof(szFormat) + 20);

    // standard sprintf
    sprintf(szResult, szFormat, sum);

    // get an object string
    jstring result = (*env)->NewStringUTF(env, szResult);

    // cleanup
    free(szResult);

    return result;
}

Per la compilazione, ti consigliamo di aggiungere una istruzione include pure per stdio.h. E per la corrispondenza a
questa nuova funzione nativa, aggiungere la seguente dichiarazione in classe Activity Java:

Codice: [Seleziona]
private native String getString(int value1, int value2);

È ora possibile cablare le funzionalità nel modo che preferisci. Abbiamo utilizzato le seguenti due chiamate e
uscite:

Codice: [Seleziona]
String result = getString(5,2);
Log.v(DEBUG_TAG, "Result: "+result);
result = getString(105, 1232);
Log.v(DEBUG_TAG, "Result2: "+result);

Tornando alla funzione C, noterete che abbiamo fatto un paio di cose. In primo luogo, abbiamo bisogno di creare un
buffer di scrittura per la sprintf() chiamata utilizzando la funzione malloc(). Questo è ragionevole finché non ci si
dimentica di liberare i risultati quando hai finito di utilizzare la funzione free(). Poi, per passare il risultato
di nuovo, è possibile utilizzare una funzione JNI di supporto, chiamata NewStringUTF(). Questa funzione
sostanzialmente prende la stringa C e fa un nuovo oggetto Java. Questo nuovo oggetto String può quindi essere
restituito come risultato e sarete in grado di utilizzarlo come un normale oggetto Java String dalla classe Java.


Set di istruzioni, Compatibilità, Etc.

L'Android NDK richiede Android SDK 1.5 o versione successiva. Nelle versioni successive del NDK, nuove intestazioni
sono state rese disponibili per l'accesso esteso ad alcune API-in particolare, le librerie OpenGL ES.
Tuttavia, questo non è il grado di compatibilità di cui stiamo parlando. Si tratta di codice nativo, compilato per
l'architettura del processore in uso. Quindi, una domanda potrebbe essere che architettura di processore è
supportata? Nel NDK corrente (al momento della stesura) solo i set di istruzioni ARMv5TE e ARMv7-A sono supportati.
Per impostazione predefinita, l'obiettivo è impostato su ARMv5TE, che funziona su tutti i dispositivi Android con
chip ARM.

Ci sono piani per i set di istruzioni aggiuntivi (x86 è stato menzionato). Questa è un interessante implicazione: una
soluzione NDK non funziona su tutti i dispositivi. Per esempio, ci sono tablets Android là fuori che utilizzano il
processore Intel Atom, che ha un set di istruzioni x86.
Allora, come funziona il NDK sul emulatore? L'emulatore in esecuzione è una vera e propria macchina virtuale. E sì,
significa che durante l'esecuzione di Java all'interno della emulatore è in esecuzione una macchina virtuale
all'interno di una VM.




Sorry per la traduzione (grazie google :) ), spero funzioni a tutti!

Davide.

« Ultima modifica: 21 Agosto 2010, 22:43:37 CEST da vicvondoom »
"Non c'è cattivo più cattivo di un buono quando diventa cattivo!" Bud Spencer in 'Chi trova un amico trova un tesoro'.

Offline areo

  • Nuovo arrivato
  • *
  • Post: 19
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    nexus one
Re:Primo (tentativo pietoso :) ) di un tutorial su NDK.
« Risposta #1 il: 15 Novembre 2010, 19:56:17 CET »
0
grazie per il lavoro!!!

Offline vicvondoom

  • Utente junior
  • **
  • Post: 71
  • Respect: +4
    • Mostra profilo
    • vicvondoom
  • Dispositivo Android:
    Sony XPeria U
  • Play Store ID:
    Orlando Davide
  • Sistema operativo:
    Windows 8
Re:Primo (tentativo pietoso :) ) di un tutorial su NDK.
« Risposta #2 il: 16 Novembre 2010, 17:12:44 CET »
0
Spetta guarda qua che ho cercato di fare un pò meglio:
Tutorial per prima app con Android NDK. - Android Developers Italia

:)
"Non c'è cattivo più cattivo di un buono quando diventa cattivo!" Bud Spencer in 'Chi trova un amico trova un tesoro'.

Offline fabio80s

  • Utente junior
  • **
  • Post: 58
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Google Nexus 7, Samsung Galaxy S2
  • Play Store ID:
    FABIO+SARACINO
  • Sistema operativo:
    Windows 7
Re:Primo (tentativo pietoso :) ) di un tutorial su NDK.
« Risposta #3 il: 13 Gennaio 2013, 22:12:30 CET »
0
Grande tutorial, grazie