android - samsung - como hacer una captura de pantalla en el celular

Cómo capturar el contenido de la pantalla del dispositivo Android?

Question

Posible duplicado:
¿Cómo hacer una captura de pantalla programaticamente en Android?

¿Cómo capturar el contenido de la pantalla del dispositivo Android y crear un archivo de imagen utilizando los datos de la instantánea? ¿Qué API debería usar o dónde podría encontrar recursos relacionados?

Por cierto: no instantánea de la cámara, pero pantalla del dispositivo

Answer 1

AFAIK, todos los métodos actualmente para capturar una captura de pantalla de Android usan el / dev / graphics / fb0 framebuffer. Esto incluye ddms. Requiere que root lea de esta secuencia. ddms usa adbd para solicitar la información, por lo que no se requiere root, ya que adb tiene los permisos necesarios para solicitar los datos de / dev / graphics / fb0.

El framebuffer contiene 2+ "marcos" de imágenes RGB565. Si puede leer los datos, debe conocer la resolución de la pantalla para saber cuántos bytes se necesitan para obtener la imagen. cada píxel tiene 2 bytes, por lo que si la resolución de la pantalla fuera de 480x800, tendría que leer 768,000 bytes para la imagen, ya que una imagen de 480x800 RGB565 tiene 384,000 píxeles.

Answer 2

De acuerdo con este enlace , es posible usar ddms en el directorio de herramientas del sdk de Android para tomar capturas de pantalla.

Para hacer esto dentro de una aplicación (y no durante el desarrollo), también hay aplicaciones para hacerlo. Pero como @ zed_0xff señala, ciertamente requiere root.

Answer 3

Framebuffer parece el camino a seguir, no siempre contendrá más de 2 cuadros como lo menciona Ryan Conrad. En mi caso, contenía solo uno. Supongo que depende del tamaño del marco / pantalla.

Traté de leer el framebuffer de forma continua, pero parece regresar por una cantidad fija de bytes leídos. En mi caso, eso es (3 410 432) bytes, que es suficiente para almacenar un marco de visualización de 854 * 480 RGBA (3 279 360 bytes). Sí, el fotograma en binario superado de fb0 es RGBA en mi dispositivo . Es muy probable que esto dependa de un dispositivo a otro . Esto será importante para decodificarlo =)

En mi dispositivo, los permisos / dev / graphics / fb0 son para que solo el usuario root y los usuarios de los gráficos grupales puedan leer el archivo fb0. graphics es un grupo restringido, por lo que probablemente solo accedas a fb0 con un teléfono rooteado usando su comando.

Las aplicaciones de Android tienen la aplicación id de usuario (uid) _ ## y la aplicación id de grupo (guid) _ ## .

adb shell tiene uid shell y guid shell , que tiene muchos más permisos que una aplicación. Puede verificar esos permisos en /system/permissions/platform.xml

Esto significa que podrá leer fb0 en el shell adb sin root pero no lo leerá dentro de la aplicación sin root.

Además, otorgar permisos a READ_FRAME_BUFFER y / o ACCESS_SURFACE_FLINGER en AndroidManifest.xml no hará nada para una aplicación normal, ya que solo funcionarán para las aplicaciones de ''firma''.

Answer 4

Para las plataformas Android más recientes, se puede ejecutar una utilidad de screencap /system/bin en /system/bin para obtener la captura de pantalla sin permiso de root. Puede probar /system/bin/screencap -h para ver cómo usarlo bajo adb o cualquier shell.

Por cierto, creo que este método solo es bueno para una sola instantánea. Si queremos capturar múltiples marcos para la reproducción de pantalla, será demasiado lento. No sé si existe otro enfoque para una captura de pantalla más rápida.

Answer 5

Puede probar la siguiente biblioteca: Android Screenshot Library (ASL) permite capturar capturas de pantalla desde dispositivos Android sin necesidad de privilegios de acceso a la raíz. En cambio, ASL utiliza un servicio nativo que se ejecuta en segundo plano, iniciado a través del Android Debug Bridge (ADB) una vez por cada inicio del dispositivo.

Answer 6

Usa el siguiente código:

Bitmap bitmap;
View v1 = MyView.getRootView();
v1.setDrawingCacheEnabled(true);
bitmap = Bitmap.createBitmap(v1.getDrawingCache());
v1.setDrawingCacheEnabled(false);

Aquí MyView es la View través de la cual necesitamos incluir en la pantalla. También puede obtener DrawingCache desde cualquier View esta manera (sin getRootView() ).

También hay otra manera ..
Si tenemos ScrollView como vista raíz, entonces es mejor usar el siguiente código,

LayoutInflater inflater = (LayoutInflater) this.getSystemService(LAYOUT_INFLATER_SERVICE);
FrameLayout root = (FrameLayout) inflater.inflate(R.layout.activity_main, null); // activity_main is UI(xml) file we used in our Activity class. FrameLayout is root view of my UI(xml) file.
root.setDrawingCacheEnabled(true);
Bitmap bitmap = getBitmapFromView(this.getWindow().findViewById(R.id.frameLayout)); // here give id of our root layout (here its my FrameLayout''s id)
root.setDrawingCacheEnabled(false);

Aquí está el método getBitmapFromView()

public static Bitmap getBitmapFromView(View view) {
        //Define a bitmap with the same size as the view
        Bitmap returnedBitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(),Bitmap.Config.ARGB_8888);
        //Bind a canvas to it
        Canvas canvas = new Canvas(returnedBitmap);
        //Get the view''s background
        Drawable bgDrawable =view.getBackground();
        if (bgDrawable!=null) 
            //has background drawable, then draw it on the canvas
            bgDrawable.draw(canvas);
        else 
            //does not have background drawable, then draw white background on the canvas
            canvas.drawColor(Color.WHITE);
        // draw the view on the canvas
        view.draw(canvas);
        //return the bitmap
        return returnedBitmap;
    }

Mostrará toda la pantalla, incluido el contenido oculto en su ScrollView


ACTUALIZADO EL 20-04-2016

Hay otra forma mejor de tomar una captura de pantalla.
Aquí tomé una captura de pantalla de WebView .

WebView w = new WebView(this);
    w.setWebViewClient(new WebViewClient()
    {
        public void onPageFinished(final WebView webView, String url) {

            new Handler().postDelayed(new Runnable(){
                @Override
                public void run() {
                    webView.measure(View.MeasureSpec.makeMeasureSpec(
                                    View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED),
                            View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
                    webView.layout(0, 0, webView.getMeasuredWidth(),
                            webView.getMeasuredHeight());
                    webView.setDrawingCacheEnabled(true);
                    webView.buildDrawingCache();
                    Bitmap bitmap = Bitmap.createBitmap(webView.getMeasuredWidth(),
                            webView.getMeasuredHeight(), Bitmap.Config.ARGB_8888);

                    Canvas canvas = new Canvas(bitmap);
                    Paint paint = new Paint();
                    int height = bitmap.getHeight();
                    canvas.drawBitmap(bitmap, 0, height, paint);
                    webView.draw(canvas);

                    if (bitmap != null) {
                        try {
                            String filePath = Environment.getExternalStorageDirectory()
                                    .toString();
                            OutputStream out = null;
                            File file = new File(filePath, "/webviewScreenShot.png");
                            out = new FileOutputStream(file);

                            bitmap.compress(Bitmap.CompressFormat.PNG, 50, out);
                            out.flush();
                            out.close();
                            bitmap.recycle();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, 1000);
        }
    });

Espero que esto ayude..!

Answer 7

[Basado en el código fuente de Android:]

En el lado de C ++, SurfaceFlinger implementa la API captureScreen. Esto se expone a través de la interfaz del IPC del enlazador, y devuelve cada vez un área nueva de ashmem que contiene los píxeles brutos de la pantalla. La captura de pantalla real se realiza a través de OpenGL.

Para los clientes del sistema C ++, la interfaz se expone a través de la clase ScreenshotClient, definida en <surfaceflinger_client/SurfaceComposerClient.h> para Android <4.1; para Android> 4.1 use <gui/SurfaceComposerClient.h>

Antes de JB, para tomar una captura de pantalla en un programa de C ++, esto era suficiente:

ScreenshotClient ssc;
ssc.update();

Con JB y pantallas múltiples, se vuelve un poco más complicado:

ssc.update(
    android::SurfaceComposerClient::getBuiltInDisplay(
        android::ISurfaceComposer::eDisplayIdMain));

Entonces puedes acceder a él:

do_something_with_raw_bits(ssc.getPixels(), ssc.getSize(), ...);

Usando el código fuente de Android, puede compilar su propia biblioteca compartida para acceder a esa API, y luego exponerla a través de JNI a Java. Para crear una captura de pantalla desde su aplicación, la aplicación debe tener el permiso READ_FRAME_BUFFER . Pero incluso entonces, aparentemente puede crear capturas de pantalla solo desde aplicaciones del sistema, es decir, aquellas que están firmadas con la misma clave que el sistema. (Esta parte todavía no entiendo del todo, ya que no estoy lo suficientemente familiarizado con el sistema de permisos de Android).

Aquí hay un fragmento de código, para JB 4.1 / 4.2:

#include <utils/RefBase.h>
#include <binder/IBinder.h>
#include <binder/MemoryHeapBase.h>
#include <gui/ISurfaceComposer.h>
#include <gui/SurfaceComposerClient.h>

static void do_save(const char *filename, const void *buf, size_t size) {
    int out = open(filename, O_RDWR|O_CREAT, 0666);
    int len = write(out, buf, size);
    printf("Wrote %d bytes to out./n", len);
    close(out);
}

int main(int ac, char **av) {
    android::ScreenshotClient ssc;
    const void *pixels;
    size_t size;
    int buffer_index;

    if(ssc.update(
        android::SurfaceComposerClient::getBuiltInDisplay(
            android::ISurfaceComposer::eDisplayIdMain)) != NO_ERROR ){
        printf("Captured: w=%d, h=%d, format=%d/n");
        ssc.getWidth(), ssc.getHeight(), ssc.getFormat());
        size = ssc.getSize();
        do_save(av[1], pixels, size);
    }
    else
        printf(" screen shot client Captured Failed");
    return 0;
}

Answer 8

si desea realizar una captura de pantalla desde el código Java en la aplicación Android AFAIK, debe tener Root provileges.