& pourquoi j’n’écrirais pas ça ?

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

}