Comment capturer le contenu de l'écran de l'appareil Android?

Question

Dupliquer possible:
Comment faire une capture d'écran par programme sur Android?

Comment capturer le contenu de l'écran du périphérique Android et créer un fichier image en utilisant les données de l'instantané? Quelle API dois-je utiliser ou où pourrais-je trouver des ressources connexes?

BTW: pas d'instantané de la caméra, mais écran de l'appareil

Answer 1

Utilisez le code suivant:

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

Ici, MyView est le View grâce à qui nous avons besoin d'inclure dans l'écran. Vous pouvez également obtenir de l' DrawingCache de tout View de cette façon (sans getRootView()).

Il y a aussi une autre manière..
Si nous ayant ScrollView comme vue de la racine puis, de son mieux pour utiliser code suivant

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)

Voici l' getBitmapFromView() méthode

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;
    }

Il affiche la totalité de l'écran, y compris le contenu caché dans votre ScrollView

Answer 2

Autant que je sache, Toutes les méthodes actuellement à une capture de l'écran de android utilise /dev/graphiques/fb0 framebuffer. Cela comprend ddms. Il exige de la racine à lire à partir de ce flux. ddms utilise adbd pour demander de l'information, de sorte que la racine n'est pas nécessaire que la bad a les autorisations nécessaires à la demande les données à partir de /dev/graphiques/fb0.

Le tampon contient 2+ "cadres" de RGB565 images. Si vous êtes en mesure de lire les données, vous devez connaître la résolution de l'écran de savoir combien d'octets sont nécessaires pour obtenir l'image. chaque pixel est de 2 octets, de sorte que si l'écran res a été 480x800, vous devez lire 768,000 octets de l'image, depuis un 480x800 RGB565 image a 384,000 pixels.

Answer 3

Pour les nouvelles plates-formes Android, vous pouvez exécuter un utilitaire système "screencap" dans / system / bin pour obtenir la capture d'écran sans autorisation root. Vous pouvez essayer "/ system / bin / screencap -h" pour voir comment l'utiliser sous adb ou n'importe quel shell.

En passant, je pense que cette méthode n’est valable que pour les instantanés uniques. Si nous voulons capturer plusieurs images pour la lecture à l'écran, ce sera trop lent. Je ne sais pas s'il existe une autre approche pour une capture d'écran plus rapide.

Answer 4

[Basé sur le code source Android:]

Au C++ côté, le SurfaceFlinger met en œuvre la captureScreen API. Ce est exposée au cours de la reliure de l'IPC de l'interface, de retour à chaque fois une nouvelle ashmem zone qui contient le raw pixels de l'écran. La réelle capture d'écran est prise par OpenGL.

Pour le système C++ clients, l'interface est exposée à travers la ScreenshotClient classe, définie en <surfaceflinger_client/SurfaceComposerClient.h> pour Android < 4.1; pour Android > 4.1 utilisation <gui/SurfaceComposerClient.h>

Avant de JB, pour prendre une capture d'écran dans un programme C++, c'était assez:

ScreenshotClient ssc;
ssc.update();

Avec JB et plusieurs écrans, il devient un peu plus compliqué:

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

Ensuite, vous pouvez accéder:

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

En utilisant le code source Android, vous pouvez compiler votre propre bibliothèque partagée pour accéder à l'API, puis l'exposer à travers JNI pour Java. Pour créer une capture d'écran du formulaire de votre application, l'application doit avoir l' READ_FRAME_BUFFERautorisation. Mais même alors, apparemment, vous pouvez créer des captures d'écran uniquement à partir des applications du système, c'est à dire ceux qui sont signés avec la même clé que le système. (Cette partie je n'ai toujours pas comprendre, car je ne suis pas assez familier avec les Autorisations Android système.)

Voici un morceau de code, pour 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 5

Vous pouvez essayer la bibliothèque suivante: http://code.google.com/p/android-screenshot-library/ La bibliothèque de captures d'écran Android (ASL) permet de capturer par programme des captures d'écran à partir d'appareils Android sans qu'il soit nécessaire d'avoir les privilèges d'accès root. Au lieu de cela, ASL utilise un service natif fonctionnant en arrière-plan, démarré via le pont de débogage Android (ADB) une fois par démarrage du périphérique.