Juin 28

Pour récupérer une image, il faut :

  1. Se connecter à ADB avec AndroidDebugBridge.createBridge("<Chemin vers ADB>", true);
  2. Récupérer la liste des périphériques disponibles, getDevices()
  3. Appeler la méthode getScreenshot() pour finalement récupérer la capture

Vous pouvez tester le JAR que j’ai généré en le téléchargeant depuis ce lien. Pour l’utiliser, ouvrez une invite de commande en passant les paramètres requis :

  • java -jar wGetScreenshot.jar -adb="<Chemin vers le SDK Android>\android-sdk\platform-tools\adb.exe" -png="<Chemin avec le nom du fichier PNG à générer>"
  • Vous pouvez ajouter :
    • -L pour le mode paysage
    • -e pour faire une capture depuis l’émulateur
Capture

Capture

Vous pouvez facilement améliorer ce code. Je l’ai testé en faisant des captures aussi bien sur un vrai téléphone que sur un émulateur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
package org.whiler.helper;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import com.android.ddmlib.AndroidDebugBridge;
import com.android.ddmlib.IDevice;
import com.android.ddmlib.RawImage;
import com.android.ddmlib.TimeoutException;

public class GetScreenshot {

  public final static int RC_OK            = 0;
  public final static int RC_WRONG_PARAMS  = 1;
  public final static int RC_NO_LIST       = 2;
  public final static int RC_NOTHING_FOUND = 3;
  public final static int RC_NO_MATCH      = 4;
  public final static int RC_NO_SNAPSHOT   = 5;
 
  public static void main(String[] args) {
    System.exit(getSnapshot(args));
  }

  private static int getSnapshot(String sADB, String sPng, boolean bDevice, boolean bEmulator, boolean bLandscape, int iTimeOut) {
    int         iLoop;

    BufferedImage   biSnapshot;
    AndroidDebugBridge  adbBridge;
    IDevice       dDevices[];
    IDevice       dTarget   = null;

    RawImage      riSnapshot  = null;

    AndroidDebugBridge.init(false);

    adbBridge = AndroidDebugBridge.createBridge(sADB, true);
    iLoop     = 0;

    while (!adbBridge.hasInitialDeviceList() && (iLoop <= (iTimeOut * 10))) {
      try {
        Thread.sleep(100L);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      iLoop++;
    }

    if (iLoop > (iTimeOut * 10)) {
      // Impossible d'obtenir les périphériques
      System.err.println("Cannot get the list of device/emulator");
      AndroidDebugBridge.terminate();
      return RC_NO_LIST;
    }

    dDevices = adbBridge.getDevices();
    if (dDevices.length == 0) {
      // Aucun périphérique trouvé
      System.err.println("No device/emulator found!");
      AndroidDebugBridge.terminate();
      return RC_NOTHING_FOUND;
    }

    if (bEmulator || bDevice) {
      int iLoopDevice = 0;
      int iMaxDevice = dDevices.length;
      // Recherche le bon type de périphérique
      while ((dTarget == null) && (iLoopDevice < iMaxDevice)) {
        if ((dDevices[iLoopDevice].isEmulator() == bEmulator) || (!dDevices[iLoopDevice].isEmulator() == bDevice)) {
          dTarget = dDevices[iLoopDevice];
        }
        iLoopDevice++;
      }
    }

    if (dTarget == null) {
      System.err.println("No matching device/emulator found!");
      AndroidDebugBridge.terminate();
      return RC_NO_MATCH;
    }

    try {
      // Récupération du snapshot
      riSnapshot = dTarget.getScreenshot();
    } catch (TimeoutException te) {
      te.printStackTrace();
      System.err.println("Timeout when getting spnapshot!");
    } catch (com.android.ddmlib.AdbCommandRejectedException acre) {
      acre.printStackTrace();
      System.err.println("Adb has rejected the request!");
    } catch (IOException ioe) {
      ioe.printStackTrace();
      System.err.println("IO exception!");
    }

    // Mode paysage
    if (bLandscape && (riSnapshot != null)) {
      riSnapshot = riSnapshot.getRotated();
    }

    if (riSnapshot != null) {
      biSnapshot = new BufferedImage(riSnapshot.width, riSnapshot.height, BufferedImage.TYPE_INT_ARGB);
      int iIndex = 0;
      int iDelta = (riSnapshot.bpp >> 3);
      for (int iY = 0; iY < riSnapshot.height; iY++) {
        for (int iX = 0; iX < riSnapshot.width; iX++) {
          biSnapshot.setRGB(iX, iY, riSnapshot.getARGB(iIndex));
          iIndex += iDelta;
        }
      }

      try {
        File fPng = new File(sPng);
        ImageIO.write(biSnapshot, "png", fPng);
        System.out.println("PNG file created");
        return RC_OK;
      } catch (IOException e) {
        e.printStackTrace();
        System.err.println("Cannot create the PNG!");
      }
    }
   
    return RC_NO_SNAPSHOT;
  }
 
  private static int getSnapshot(String[] args) {
    String        sADB    = "";
    String        sPng    = "";
    boolean       bDevice   = false;
    boolean       bEmulator = false;
    boolean       bLandscape  = false;
    int         iTimeOut  = 10;

    // Parsing des arguments
    ArgumentsParser   ap      = new ArgumentsParser(args);

    // Arguments obligatoires
    if (ap.hasOption("adb") && ap.hasOption("png")) {
      sADB = ap.getOption("adb");
      sPng = ap.getOption("png");

      // Check ADB path
      if (!(new File(sADB)).exists()) {
        System.err.println("adb path is not valid!");
        System.err.println("  " + sADB);
        return RC_WRONG_PARAMS;
      }

      // Check PNG folder
      String sPngPath = (new File(sPng)).getParent() + File.separatorChar;
      if (!(new File(sPngPath)).exists()) {
        System.err.println("The directory where the PNG should be generated must already exist!");
        System.err.println("  " + sPngPath);
        return RC_WRONG_PARAMS;
      }

      // Optional arguments
      if (ap.hasOption("d")) {
        bDevice = true;
      }
      if (ap.hasOption("e")) {
        bEmulator = true;
      }
      if (!(bDevice || bEmulator)) {
        bDevice = true;
      }

      if (ap.hasOption("l")) {
        bLandscape = true;
      }

      if (ap.hasOption("timeout")) {
        try {
          iTimeOut = Integer.parseInt(ap.getOption("timeout"));
        } catch (NumberFormatException e) {
          System.out.println("Invalid timeout value:");
          System.out.println("  " + ap.getOption("timeout"));
          System.out.println("Using default value: 10s");
        }
      }
    } else {
      printUsage();
      return RC_WRONG_PARAMS;
    }
   
    return getSnapshot(sADB, sPng, bDevice, bEmulator, bLandscape, iTimeOut);
  }

  private static void printUsage() {
    System.out.println("java -jar wGetScreenshot.jar -adb=<Full path to adb application> -png=<Full path to the png to generate> [-d] [-e] [-l] [-timeout=5]");
    System.out.println("You need to specify 2 arguments:");
    System.out.println("-adb=<Full path to adb application>");
    System.out.println("-png=<Full path to the png to generate>");
    System.out.println("");
    System.out.println("Optional:");
    System.out.println("-d: device");
    System.out.println("-e: emulator");
    System.out.println("-l: landscape (instead of the default portrait)");
    System.out.println("-timeout=<timeout in second> (Default = 10s)");
  }

}

Attention !!! Java et le SDK d’Android doivent être installés pour que le JAR puisse fonctionner ! Le pilote ADB pour votre téléphone doit également être installé. Votre téléphone doit être sur le mode débogage USB.

Share

Pages : 1 2

Lien permanent vers Capture d’écran Android Rédigé par Whiler \\ Tags : , , , , ,

4 réponses pour “Capture d’écran Android”

  1. Lorand a dit :

    Moi j’ai un super système personnalisé pour faire mes captures d’écran (lol)

    Merci Whiler (y) (hi) (clap) (bow)

    Répondre

  2. emna a dit :

    j ai un tel android et une cam ip j ai fait le flux de l image maintenant je veux capturer une image je fai comment

    Répondre

  3. Whiler a dit :

    @ emna : je ne comprends pas la question… :s
    Je ne vois pas le rapport entre la caméra IP et les captures d’écran dont je parle dans cet article ?
    Vous avez développé une application sur Android comme IP Cam Viewer ?

    Répondre

Laisser une réponse

(requis)

(requis)

*

Notifiez-moi les commentaires à venir via email. Vous pouvez aussi vous abonner sans commenter.

;) (lol) (y) |-( (hi) 8-) (angel) :s (clap) (bow) (tmi) (:| plus »