Android obtiene tamaño de pantalla a través de C

Quiero obtener el tamaño de la pantalla a través de c. Sé que el soporte de jni llamando a Java desde c. pero, ¿hay alguna persona que conozca otro método? me refiero a obtener el tamaño de pantalla de los módulos de bajo nivel sin llamar a Java.

import android.app.Activity; import android.os.Bundle; import android.util.Log; import android.view.Menu; public class MainActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.v("getWidth", Integer.toString(getWindowManager().getDefaultDisplay().getWidth())); Log.v("getHeight", Integer.toString(getWindowManager().getDefaultDisplay().getHeight())); } } 

Creo que / dev / graphics está relacionado con mis preguntas

Sí, puede obtener la resolución de la pantalla en / dev / graphics / fb0, pero (al menos en mi teléfono), el acceso de lectura está restringido a la raíz y a los usuarios del grupo de “gráficos”. En cualquier caso, puede hacer algo como esto (comprobación de errores eliminada para mayor claridad):

 // ... other standard includes ... #include  #include  //... struct fb_var_screeninfo fb_var; int fd = open("/dev/graphics/fb0", O_RDONLY); ioctl(fd, FBIOGET_VSCREENINFO, &fb_var); close(fd); // screen size will be in fb_var.xres and fb_var.yres 

No estoy seguro de si estas se consideran interfaces NDK “públicas”, ya que no sé si Google considera que “Android se ejecuta en Linux y utiliza la interfaz Framebuffer de Linux” como parte de la API pública, pero parece que trabajo.

Si desea asegurarse de que sea portátil, probablemente debería tener un respaldo JNI que llame a la API de Java WindowManager.

No necesita el búfer pero podría usar la clase ANativeWindow si pasa una Surface desde java.

 void Java_com_justinbuser_nativecore_NativeMethods_setSurface(JNIEnv * env, jobject this, jobject surface){ ANativeWindow nativeWindow = ANativeWindow_fromSurface(env, surface); int width = ANativeWindow_getWidth(renderEngine->nativeWindow); int height = ANativeWindow_getHeight(renderEngine->nativeWindow); } 

Para obtener la resolución de la pantalla tienes que usar la estructura ANativeWindow_Buffer :

 typedef struct ANativeWindow_Buffer { // The number of pixels that are show horizontally. int32_t width; // The number of pixels that are shown vertically. int32_t height; // The number of *pixels* that a line in the buffer takes in // memory. This may be >= width. int32_t stride; // The format of the buffer. One of WINDOW_FORMAT_* int32_t format; // The actual bits. void* bits; // Do not touch. uint32_t reserved[6]; } ANativeWindow_Buffer; 

Para obtenerlo use la función ANativeWindow_lock :

 /** * Lock the window's next drawing surface for writing. */ int32_t ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds); 

Aquí hay documentos .

Si está buscando el uso de esta función, eche un vistazo a la muestra de android-ndk llamada native-plasma .

También puede obtener el tamaño de la ventana mientras procesa el “comando de aplicación” APP_CMD_INIT_WINDOW como este en su actividad nativa:

 static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_INIT_WINDOW: if (engine->app->window != NULL) { int width = ANativeWindow_getWidth(engine->app->window); int height = ANativeWindow_getHeight(engine->app->window); } 

Consulte main.c en el proyecto NDK de muestra de native-activity si desea saber cómo configurar la estructura del engine y la callback engine_handle_cmd .

Esto funciona para mí:

 DisplayMetrics displaymetrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(displaymetrics); int height = displaymetrics.heightPixels; int width = displaymetrics.widthPixels;