¿Cómo usar la actividad nativa? ¿Se puede combinar con la actividad tradicional?

Question

Tengo dos bibliotecas (.so), que cargo en código java.

Sin embargo, hay algunas operaciones específicas que requieren Java (Actividad) < -> C++ (. So archivos) llamadas.

¿Puedo utilizar Native Activity para implementar parte de esas funcionalidades? ¿La actividad nativa es algo que es adicional a la actividad tradicional o tengo que elegir qué tipo de actividad usaré?

[EDIT]

hay un conjunto de eventos que puede ser manejado en código nativo por native activity

android-NDK/fuentes/android/native_app_glue/android_native_app_glue.h

enum { 
    /** 
    * Command from main thread: the AInputQueue has changed. Upon processing 
    * this command, android_app->inputQueue will be updated to the new queue 
    * (or NULL). 
    */ 
    APP_CMD_INPUT_CHANGED, 

    /** 
    * Command from main thread: a new ANativeWindow is ready for use. Upon 
    * receiving this command, android_app->window will contain the new window 
    * surface. 
    */ 
    APP_CMD_INIT_WINDOW, 

    /** 
    * Command from main thread: the existing ANativeWindow needs to be 
    * terminated. Upon receiving this command, android_app->window still 
    * contains the existing window; after calling android_app_exec_cmd 
    * it will be set to NULL. 
    */ 
    APP_CMD_TERM_WINDOW, 

    /** 
    * Command from main thread: the current ANativeWindow has been resized. 
    * Please redraw with its new size. 
    */ 
    APP_CMD_WINDOW_RESIZED, 

    /** 
    * Command from main thread: the system needs that the current ANativeWindow 
    * be redrawn. You should redraw the window before handing this to 
    * android_app_exec_cmd() in order to avoid transient drawing glitches. 
    */ 
    APP_CMD_WINDOW_REDRAW_NEEDED, 

    /** 
    * Command from main thread: the content area of the window has changed, 
    * such as from the soft input window being shown or hidden. You can 
    * find the new content rect in android_app::contentRect. 
    */ 
    APP_CMD_CONTENT_RECT_CHANGED, 

    /** 
    * Command from main thread: the app's activity window has gained 
    * input focus. 
    */ 
    APP_CMD_GAINED_FOCUS, 

    /** 
    * Command from main thread: the app's activity window has lost 
    * input focus. 
    */ 
    APP_CMD_LOST_FOCUS, 

    /** 
    * Command from main thread: the current device configuration has changed. 
    */ 
    APP_CMD_CONFIG_CHANGED, 

    /** 
    * Command from main thread: the system is running low on memory. 
    * Try to reduce your memory use. 
    */ 
    APP_CMD_LOW_MEMORY, 

    /** 
    * Command from main thread: the app's activity has been started. 
    */ 
    APP_CMD_START, 

    /** 
    * Command from main thread: the app's activity has been resumed. 
    */ 
    APP_CMD_RESUME, 

    /** 
    * Command from main thread: the app should generate a new saved state 
    * for itself, to restore from later if needed. If you have saved state, 
    * allocate it with malloc and place it in android_app.savedState with 
    * the size in android_app.savedStateSize. The will be freed for you 
    * later. 
    */ 
    APP_CMD_SAVE_STATE, 

    /** 
    * Command from main thread: the app's activity has been paused. 
    */ 
    APP_CMD_PAUSE, 

    /** 
    * Command from main thread: the app's activity has been stopped. 
    */ 
    APP_CMD_STOP, 

    /** 
    * Command from main thread: the app's activity is being destroyed, 
    * and waiting for the app thread to clean up and exit before proceeding. 
    */ 
    APP_CMD_DESTROY, 
}; 

ya que sé que parte de mi código (que debería llamarse después de un evento específico) está escrito en C++, creo que será mejor para manejar esto en C++ a través de la actividad nativa. Sin embargo, también tengo un código que debe llamarse después de manejar eventos en Java.

pregunta es ... ¿puedo tener una versión nativa (interfaz nativa) de mi actividad, que me ayudará con algunos eventos, y la interfaz tradicional de Java para esta misma actividad en este mismo momento?

Answer 1

Me gustaría responder que no puede tener dos versiones del código de una actividad.

• ¿Cómo se especifica eso en su manifiesto?

• En el ejemplo proporcionado por Google, el comentario de la principal es bastante explícito:

Se ejecuta en su propio hilo, con su propio ciclo de eventos para recibir eventos de entrada y hacer otras cosas

La actividad nativa manejaría todos los eventos en el bucle while(1) {...}. La mezcla de Java y el evento nativo no será posible.

En mi humilde opinión, la razón principal para utilizar una actividad nativa es la interfaz de usuario. Si ya tiene una IU totalmente funcional en C++, entonces es más fácil para usted y más portátil usar una actividad nativa. Todavía puede personalizar su aplicación para Android agregue otra actividad java (¡no olvide poner android:hasCode="TRUE" en su manifiesto!). En el otro caso, el uso de una actividad Java le permite utilizar completamente la interfaz de usuario de Google y llamar a su biblioteca nativa cuando sea necesario.

Sobre usted pregunta de desempeño, cuando se dice:

Creo que va a ser mejor para manejar esto en C++ a través de la actividad nativa

echar un vistazo a esto: http://developer.android.com/guide/practices/design/performance.html#native_methods

¡Espero que esto ayude!