Questa pagina è stata tradotta dall'API Cloud Translation.

Concetti

Prima di iniziare

Questa guida presuppone che tu abbia già familiarità con i concetti relativi ai programmazione nativa e nello sviluppo Android.

Introduzione

Questa sezione fornisce una spiegazione generale del funzionamento dell'NDK. Android NDK è un insieme che consentono di incorporare C o C++ ("codice nativo") nelle app per Android. Possibilità di utilizzare il codice nativo nelle app per Android può essere particolarmente utile per gli sviluppatori che vogliono eseguire una o più delle le seguenti:

Trasferire le app tra piattaforme.
Riutilizza le librerie esistenti o fornisci le proprie librerie per il riutilizzo.
Aumentare le prestazioni in alcuni casi, in particolare ad alta intensità di calcolo come i giochi.

Come funziona

Questa sezione introduce i componenti principali utilizzati per creare un per Android, oltre a descrivere il processo di creazione e pacchettizzazione.

Componenti principali

Durante la creazione dei tuoi annunci, dovresti aver compreso i seguenti componenti dell'app:

Librerie condivise native: NDK crea queste librerie, o file .so, da codice sorgente C/C++.
Librerie statiche native: NDK può anche creare librerie statiche oppure .a che puoi collegare ad altre librerie.
Java Native Interface (JNI): JNI è l'interfaccia attraverso la quale le interfacce Java e I componenti C++ comunicano tra loro. Questa guida presuppone la conoscenza di JNI; Per informazioni al riguardo, consulta la Specifica dell'interfaccia nativa Java.
Application Binary Interface (ABI): l'ABI definisce esattamente il modo in cui il codice della macchina deve interagire con il sistema in fase di runtime. NDK crea file .so in base a queste definizioni. ABI diverse corrispondono diverse architetture: NDK include il supporto ABI per ARM a 32 bit, AArch64, x86 e x86-64. Per ulteriori informazioni, vedi Android ABI.
Manifest: se stai scrivendo un'app senza componenti Java, devi dichiarare la classe NativeActivity nel manifest. Consulta la sezione Utilizzare il l'interfaccia native_activity.h per ulteriori dettagli su come fare.

Flusso

Il flusso generale per lo sviluppo di un'app nativa per Android è il seguente:

Progetta la tua app, decidendo quali parti implementare in Java e quali da implementare come codice nativo.

Nota: sebbene sia possibile evitare del tutto Java, è probabile che si verifichino il framework Java di Android, utile per varie attività, tra cui il controllo della visualizzazione e UI.
Crea un progetto di app Android come faresti per qualsiasi altro progetto Android.
Se stai scrivendo un'app solo nativa, dichiara la classe nativeActivity in AndroidManifest.xml. Per ulteriori informazioni, consulta la sezione Attività native e applicazioni.
Crea un file Android.mk che descriva la libreria nativa, inclusi nome, tramite flag, librerie collegate e file sorgente da compilare nel file .
Se vuoi, puoi creare un file Application.mk configurando il target ABI, toolchain, modalità di rilascio/debug e STL. Per qualsiasi attività che non viene specificato, vengono utilizzati, rispettivamente, i seguenti valori predefiniti:
- ABI: tutte le ABI non deprecate
- Modalità: pubblicazione
- STL: sistema
Inserisci l'origine nativa nella directory jni del progetto.
Utilizza ndk-build per compilare le librerie native (.so, .a).
Crea il componente Java, producendo il file eseguibile .dex.
Pacchettizza tutto in un file APK, contenente .so, .dex e altri necessari per l'esecuzione dell'app.

Attività e applicazioni native

L'SDK Android fornisce una classe helper, nativeActivity, che ti consente di: scrivere un'attività completamente nativa. nativeActivity gestisce la comunicazione tra il framework Android e il codice nativo, o chiamarne i metodi. Devi solo dichiarare la tua richiesta in modo che sia nativo nel file AndroidManifest.xml e iniziare a creare un'applicazione.

Un'app Android che utilizza nativeActivity viene ancora eseguita nel proprio sandbox da altre applicazioni. Pertanto, puoi continuare ad accedere API framework Android tramite JNI. In alcuni casi, ad esempio per i sensori, eventi di input e asset, l'NDK fornisce interfacce native che puoi utilizzare invece di dover chiamare attraverso la JNI. Per ulteriori informazioni su vedi API native.

Che tu stia sviluppando o meno un'attività nativa, di creare progetti con gli strumenti di build Android tradizionali. In questo modo aiuta a garantire lo sviluppo e la pacchettizzazione delle app Android con il corretto alla struttura del centro di costo.

L'NDK di Android offre due opzioni per implementare l'attività nativa:

L'intestazione native_activity.h. definisce la versione nativa della classe NativeActivity. Contiene i parametri l'interfaccia di callback e le strutture di dati necessarie per creare il tuo attività. Poiché il thread principale dell'applicazione gestisce i callback, le implementazioni dei callback non devono bloccare. Se vengono bloccati, ricevono errori ANR (L'applicazione non risponde) perché il thread principale è non risponde finché non viene restituito il callback.
Il file android_native_app_glue.h definisce una libreria helper statica basata su in alto nell'interfaccia native_activity.h. Genera un altro filo, che gestisce elementi come i callback o gli eventi di input in un loop di eventi. In movimento a questi eventi in un thread separato, impedisce ai callback di bloccare thread principale.

<ndk_root>/sources/android/native_app_glue/android_native_app_glue.c è disponibile anche un codice sorgente, che consente di modificare l'implementazione.

Per ulteriori informazioni su come utilizzare questa libreria statica, esamina le un'applicazione di esempio di attività nativa e la relativa documentazione. Per approfondire l'argomento disponibile anche nei commenti nella <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h .

Usa l'interfaccia native_activity.h

Per implementare un'attività nativa con l'interfaccia native_activity.h:

Crea una directory jni/ nella directory root del progetto. Questa directory memorizza tutto il tuo codice nativo.

Dichiara la tua attività nativa nel file AndroidManifest.xml.

Poiché l'applicazione non ha codice Java, imposta android:hasCode su false.

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

Devi impostare l'attributo android:name del tag attività su NativeActivity.

<activity android:name="android.app.NativeActivity"
          android:label="@string/app_name">

L'attributo android:value del tag meta-data specifica il nome di la libreria condivisa contenente il punto di accesso all'applicazione (come C/C++ main), omettendo il prefisso lib e il suffisso .so dalla raccolta nome.

<manifest>
  <application>
    <activity>
      <meta-data android:name="android.app.lib_name"
                 android:value="native-activity" />
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
  </application>
</manifest>

Crea un file per l'attività nativa e implementa la funzione denominata in la variabile A NativeActivity_onCreate. L'app chiama questa funzione quando l'attività nativa. Questa funzione, analoga a main in C/C++, riceve Un puntatore a una struttura A NativeActivity, che contiene puntatori di funzione alle varie implementazioni di callback che devi scrivere. Imposta il parametro puntatori delle funzioni di callback applicabili in ANativeActivity->callbacks a le implementazioni dei callback.
Imposta il campo ANativeActivity->instance sull'indirizzo di qualsiasi istanza di i dati specifici che vuoi utilizzare.
Implementa qualsiasi altra cosa che vuoi venga eseguita dalla tua attività all'avvio.
Implementa gli altri callback impostati in ANativeActivity->callbacks. Per ulteriori informazioni su quando i callback vengono consulta la sezione Gestione del ciclo di vita delle attività.
Sviluppa il resto dell'applicazione.
Crea un Android.mk file nella directory jni/ del tuo progetto per per descrivere il modulo nativo al sistema di compilazione. Per ulteriori informazioni, vedi Android.mk.
Una volta creato il file Android.mk, compila il codice nativo utilizzando Comando ndk-build.
```
cd <path>/<to>/<project>
$NDK/ndk-build
```
Crea e installa il tuo progetto Android come di consueto. Se il codice nativo è in nella directory jni/, lo script di build pacchettizza automaticamente .so integrati nell'APK.

Codice campione aggiuntivo

Per scaricare i campioni NDK, consulta la sezione Campioni NDK.