package hudson.plugins.android_emulator;

   import  hudson.EnvVars;

   import  hudson.Extension;

   import  hudson.FilePath;

   import  hudson.Launcher;

   import  hudson.Proc;

   import  hudson.Util;

  import  hudson.Launcher.ProcStarter;

  import  hudson.model.AbstractBuild;

  import  hudson.model.AbstractProject;

  import  hudson.model.BuildListener;

  import  hudson.model.Computer;

  import  hudson.model.Hudson;

  import  hudson.model.Result;

  import  hudson.model.TaskListener;

  import hudson.remoting.Callable;

  import  hudson.tasks.BuildWrapper;

  import  hudson.tasks.BuildWrapperDescriptor;

  import  hudson.util.ArgumentListBuilder;

  import  hudson.util.FormValidation;

  import java.io.BufferedReader;

  import java.io.File;

  import java.io.IOException;

  import java.io.InputStreamReader;

  import java.io.OutputStream;

  import java.io.PrintStream;

  import java.io.PrintWriter;

  import java.io.Serializable;

  import java.net.Socket;

  import java.util.Map;

  import java.util.regex.Matcher;

  import java.util.regex.Pattern;

  import net.sf.json.JSONObject;

  import org.apache.commons.io.output.ByteArrayOutputStream;

  import  org.jvnet.hudson.plugins.port_allocator.PortAllocationManager;

  import org.kohsuke.stapler.DataBoundConstructor;

  import org.kohsuke.stapler.QueryParameter;

  import org.kohsuke.stapler.StaplerRequest;

  public class AndroidEmulator extends BuildWrapper implements Serializable {

      private static final long serialVersionUID = 1L;

    

      private static final int ADB_CONNECT_TIMEOUT_MS = 60 * 1000;

    

      private static final int BOOT_COMPLETE_TIMEOUT_MS = 120 * 1000;

      private DescriptorImpl descriptor;

      private final String avdName;

      private final String osVersion;

      private final String screenDensity;

      private final String screenResolution;

      private final String deviceLocale;

      private final String sdCardSize;

      private final boolean wipeData;

      private final boolean showWindow;

      private final String commandLineOptions;

      private final int startupDelay;

      @DataBoundConstructor

      public AndroidEmulator(String avdName, String osVersion, String screenDensity,

              String screenResolution, String deviceLocale, String sdCardSize, boolean wipeData,

              boolean showWindow, String commandLineOptions, int startupDelay) {

          this.avdName = avdName;

          this.osVersion = osVersion;

          this.screenDensity = screenDensity;

          this.screenResolution = screenResolution;

          this.deviceLocale = deviceLocale;

          this.sdCardSize = sdCardSize;

          this.wipeData = wipeData;

          this.showWindow = showWindow;

          this.commandLineOptions = commandLineOptions;

          this.startupDelay = Math.abs(startupDelay);

      }

      public boolean getUseNamedEmulator() {

          return avdName != null;

      }

      public String getOsVersion() {

          return osVersion;

      }

      public String getAvdName() {

          return avdName;

      }

      public String getScreenDensity() {

          return screenDensity;

      }

     public String getScreenResolution() {

         return screenResolution;

     }

     public String getDeviceLocale() {

         return deviceLocale;

     }

     public String getSdCardSize() {

         return sdCardSize;

     }

     public boolean shouldWipeData() {

         return wipeData;

     }

     public boolean shouldShowWindow() {

         return showWindow;

     }

     public String getCommandLineOptions() {

         return commandLineOptions;

     }

     public int getStartupDelay() {

         return startupDelay;

     }

     @Override

     @SuppressWarnings("unchecked")

     public Environment setUp(AbstractBuild build, final Launcher launcher, BuildListener listener)

             throws IOException, InterruptedException {

         final PrintStream logger = listener.getLogger();

         if (descriptor == null) {

             descriptor = Hudson.getInstance().getDescriptorByType(DescriptorImpl.class);

         }

         // Substitute environment and build variables into config

         final EnvVars localVars = Computer.currentComputer().getEnvironment();

         final EnvVars envVars = new EnvVars(localVars);

         envVars.putAll(build.getEnvironment(listener));

         final Map<String, String> buildVars = build.getBuildVariables();

         // Device properties

         String avdName = expandVariables(envVars, buildVars, this.avdName);

         String osVersion = expandVariables(envVars, buildVars, this.osVersion);

         String screenDensity = expandVariables(envVars, buildVars, this.screenDensity);

         String screenResolution = expandVariables(envVars, buildVars, this.screenResolution);

         String deviceLocale = expandVariables(envVars, buildVars, this.deviceLocale);

         String sdCardSize = expandVariables(envVars, buildVars, this.sdCardSize);

         // Emulator properties

         String commandLineOptions = expandVariables(envVars, buildVars, this.commandLineOptions);

         // SDK location

         String androidHome = expandVariables(envVars, buildVars, descriptor.androidHome);

         androidHome = discoverAndroidHome(launcher, localVars, androidHome);

         // Despite the nice inline checks and warnings when the user is editing the config,

         // these are not binding, so the user may have saved invalid configuration.

         // Here we check whether or not it's worth proceeding based on the saved values.

         String configError = isConfigValid(avdName, osVersion, screenDensity, screenResolution,

                 deviceLocale, sdCardSize);

         if (configError != null) {

             log(logger, Messages.ERROR_MISCONFIGURED(configError));

             build.setResult(Result.NOT_BUILT);

             return null;

         }

         // Confirm that tools are available on PATH

         AndroidSdk androidSdk = new AndroidSdk(androidHome);

         if (androidHome == null) {

             if (!validateAndroidToolsInPath(launcher)) {

                 log(logger, Messages.SDK_TOOLS_NOT_FOUND());

                 build.setResult(Result.NOT_BUILT);

                 return null;

             }

         } else {

             // Determine SDK type, if tools aren't on the PATH

             boolean usesPlatformTools = sdkUsesPlatformTools(launcher, androidSdk);

             androidSdk.setUsesPlatformTools(usesPlatformTools);

         }

         // Ok, everything looks good.. let's go

         String displayHome = androidSdk.hasKnownRoot() ? androidSdk.getSdkRoot() : Messages.USING_PATH();

         log(logger, Messages.USING_SDK(displayHome));

         EmulatorConfig emuConfig = EmulatorConfig.create(avdName, osVersion, screenDensity,

                 screenResolution, deviceLocale, sdCardSize, wipeData, showWindow, commandLineOptions);

         return doSetUp(build, launcher, listener, androidSdk, emuConfig);

     }

     private Environment doSetUp(final AbstractBuild<?, ?> build, final Launcher launcher,

             final BuildListener listener, final AndroidSdk androidSdk, final EmulatorConfig emuConfig)

                 throws IOException, InterruptedException {

         final PrintStream logger = listener.getLogger();

         final boolean isUnix = launcher.isUnix();

         // First ensure that emulator exists

         final Computer computer = Computer.currentComputer();

         final boolean emulatorAlreadyExists;

         try {

             Callable<Boolean, AndroidEmulatorException> task = emuConfig.getEmulatorCreationTask(androidSdk, isUnix, listener);

             emulatorAlreadyExists = launcher.getChannel().call(task);

         } catch (EmulatorDiscoveryException ex) {

             log(logger, Messages.CANNOT_START_EMULATOR(ex.getMessage()));

             build.setResult(Result.FAILURE);

             return null;

         } catch (AndroidEmulatorException ex) {

             log(logger, Messages.COULD_NOT_CREATE_EMULATOR(ex.getMessage()));

             build.setResult(Result.NOT_BUILT);

             return null;

         }

         // Delay start up by the configured amount of time

         final int delaySecs = getStartupDelay();

         if (delaySecs > 0) {

             log(logger, Messages.DELAYING_START_UP(delaySecs));

             Thread.sleep(delaySecs * 1000);

         }

         // Use the Port Allocator plugin to reserve the two ports we need

         final PortAllocationManager portAllocator = PortAllocationManager.getManager(computer);

         final int userPort = portAllocator.allocateRandom(build, 0);

         final int adbPort = portAllocator.allocateRandom(build, 0);

         // Compile complete command for starting emulator

         final String avdArgs = emuConfig.getCommandArguments();

         String emulatorArgs = String.format("-ports %s,%s %s", userPort, adbPort, avdArgs);

         ArgumentListBuilder emulatorCmd = Utils.getToolCommand(androidSdk, isUnix, Tool.EMULATOR, emulatorArgs);

         // Start emulator process

         log(logger, Messages.STARTING_EMULATOR());

         if (emulatorAlreadyExists && emuConfig.shouldWipeData()) {

             log(logger, Messages.ERASING_EXISTING_EMULATOR_DATA());

         }

         final long bootTime = System.currentTimeMillis();

         final EnvVars buildEnvironment = build.getEnvironment(TaskListener.NULL);

         final ProcStarter procStarter = launcher.launch().stdout(logger).stderr(logger);

         final Proc emulatorProcess = procStarter.envs(buildEnvironment).cmds(emulatorCmd).start();

         // Wait for TCP socket to become available

         boolean socket = waitForSocket(launcher, adbPort, ADB_CONNECT_TIMEOUT_MS);

         if (!socket || !emulatorProcess.isAlive()) {

             log(logger, Messages.EMULATOR_DID_NOT_START());

             build.setResult(Result.NOT_BUILT);

             cleanUp(logger, portAllocator, emulatorProcess, adbPort, userPort);

             return null;

         }

         // Notify adb of our existence

         final String adbConnectArgs = "connect localhost:"+ adbPort;

         ArgumentListBuilder adbConnectCmd = Utils.getToolCommand(androidSdk, isUnix, Tool.ADB, adbConnectArgs);

         int result = procStarter.cmds(adbConnectCmd).stdout(new NullOutputStream()).start().join();

         if (result != 0) { // adb currently only ever returns 0!

             log(logger, Messages.CANNOT_CONNECT_TO_EMULATOR());

             build.setResult(Result.NOT_BUILT);

             cleanUp(logger, portAllocator, emulatorProcess, adbPort, userPort);

             return null;

         }

         // Start dumping logs to disk

         final File artifactsDir = build.getArtifactsDir();

         final FilePath logcatFile = build.getWorkspace().createTempFile("logcat_", ".log");

         final OutputStream logcatStream = logcatFile.write();

         final String logcatArgs = "-s localhost:"+ adbPort +" logcat -v time";

         ArgumentListBuilder logcatCmd = Utils.getToolCommand(androidSdk, isUnix, Tool.ADB, logcatArgs);

         final Proc logWriter = procStarter.cmds(logcatCmd).stdout(logcatStream).stderr(new NullOutputStream()).start();

         // Monitor device for boot completion signal

         log(logger, Messages.WAITING_FOR_BOOT_COMPLETION());

         int bootTimeout = BOOT_COMPLETE_TIMEOUT_MS;

         if (!emulatorAlreadyExists || emuConfig.shouldWipeData()) {

             bootTimeout *= 4;

         }

         boolean bootSucceeded = waitForBootCompletion(logger, launcher, androidSdk, adbPort, bootTimeout);

         if (!bootSucceeded) {

             log(logger, Messages.BOOT_COMPLETION_TIMED_OUT(bootTimeout / 1000));

             build.setResult(Result.NOT_BUILT);

             cleanUp(logger, launcher, androidSdk, portAllocator, emulatorProcess,

                     adbPort, userPort, logWriter, logcatFile, logcatStream, artifactsDir);

             return null;

         }

         // Unlock emulator by pressing the Menu key once, if required.

         // Upon first boot (and when the data is wiped) the emulator is already unlocked

         if (emulatorAlreadyExists && !wipeData) {

             // Even if the emulator has started, we generally need to wait longer before the lock

             // screen is up and ready to accept key presses.

             // The delay here is a function of boot time, i.e. relative to the slowness of the host

             final long bootDuration = System.currentTimeMillis() - bootTime;

             Thread.sleep(bootDuration / 4);

             log(logger, Messages.UNLOCKING_SCREEN());

             final String keyEventArgs = String.format("-s localhost:%d shell input keyevent %%d", adbPort);

             final String menuArgs = String.format(keyEventArgs, 82);

             ArgumentListBuilder menuCmd = Utils.getToolCommand(androidSdk, isUnix, Tool.ADB, menuArgs);

             procStarter.cmds(menuCmd).start().join();

             // If a named emulator already existed, it may not have been booted yet, so the screen

             // wouldn't be locked.  In this case, after pressing Menu, we press Back to compensate

             if (emuConfig.isNamedEmulator()) {

                 final String backArgs = String.format(keyEventArgs, 4);

                 ArgumentListBuilder backCmd = Utils.getToolCommand(androidSdk, isUnix, Tool.ADB, backArgs);

                 procStarter.cmds(backCmd).start().join();

             }

         }

         // Done!

         final long bootCompleteTime = System.currentTimeMillis();

         log(logger, Messages.EMULATOR_IS_READY((bootCompleteTime - bootTime) / 1000));

         // Return wrapped environment

         return new Environment() {

             @Override

             public void buildEnvVars(Map<String, String> env) {

                 env.put("ANDROID_AVD_DEVICE", "localhost:"+ adbPort);

                 env.put("ANDROID_AVD_ADB_PORT", Integer.toString(adbPort));

                 env.put("ANDROID_AVD_USER_PORT", Integer.toString(userPort));

                 env.put("ANDROID_AVD_NAME", emuConfig.getAvdName());

                 if (!emuConfig.isNamedEmulator()) {

                     env.put("ANDROID_AVD_OS", emuConfig.getOsVersion().toString());

                     env.put("ANDROID_AVD_DENSITY", emuConfig.getScreenDensity().toString());

                     env.put("ANDROID_AVD_RESOLUTION", emuConfig.getScreenResolution().toString());

                     env.put("ANDROID_AVD_SKIN", emuConfig.getScreenResolution().getSkinName());

                     env.put("ANDROID_AVD_LOCALE", emuConfig.getDeviceLocale());

                 }

             }

             @Override

             @SuppressWarnings("unchecked")

             public boolean tearDown(AbstractBuild build, BuildListener listener)

                     throws IOException, InterruptedException {

                 cleanUp(logger, launcher, androidSdk, portAllocator, emulatorProcess,

                         adbPort, userPort, logWriter, logcatFile, logcatStream, artifactsDir);

                 return true;

             }

         };

     }

    

     synchronized static void log(final PrintStream logger, final String message) {

         log(logger, message, false);

     }

    

     synchronized static void log(final PrintStream logger, String message, boolean indent) {

         if (indent) {

             message = '\t' + message.replace("\n", "\n\t");

         } else {

             logger.print("[android] ");

         }

         logger.println(message);

     }

    

     private void cleanUp(PrintStream logger, PortAllocationManager portAllocator,

             Proc emulatorProcess, int adbPort, int userPort) throws IOException, InterruptedException {

         cleanUp(logger, null, null, portAllocator, emulatorProcess, adbPort, userPort, null, null, null, null);

     }

    

     private void cleanUp(PrintStream logger, Launcher launcher, AndroidSdk androidSdk,

             PortAllocationManager portAllocator, Proc emulatorProcess, int adbPort,

             int userPort, Proc logcatProcess, FilePath logcatFile,

             OutputStream logcatStream, File artifactsDir)

                 throws IOException, InterruptedException {

         // FIXME: Sometimes on Windows neither the emulator.exe nor the adb.exe processes die.

         //        Launcher.kill(EnvVars) does not appear to help either.

         //        This is (a) inconsistent; (b) very annoying.

         // Disconnect emulator from adb, if it's running

         if (launcher != null) {

             final String args = "disconnect localhost:"+ adbPort;

             ArgumentListBuilder adbDisconnectCmd = Utils.getToolCommand(androidSdk, launcher.isUnix(), Tool.ADB, args);

             final ProcStarter procStarter = launcher.launch().stderr(logger);

             procStarter.cmds(adbDisconnectCmd).stdout(new NullOutputStream()).start().join();

         }

         // Stop emulator process

         log(logger, Messages.STOPPING_EMULATOR());

         if (logcatProcess != null) {

             sendEmulatorCommand(launcher, logger, userPort, "kill");

             if (logcatProcess.isAlive()) {

                 logcatProcess.kill();

             }

             logcatStream.close();

             // Archive the logs

             if (logcatFile.length() != 0) {

                 log(logger, Messages.ARCHIVING_LOG());

                 logcatFile.copyTo(new FilePath(artifactsDir).child("logcat.txt"));

             }

             logcatFile.delete();

         }

         // Ensure the process is dead and free up the TCP ports

         if (emulatorProcess.isAlive()) {

             emulatorProcess.kill();

         }

         portAllocator.free(adbPort);

         portAllocator.free(userPort);

     }

    

     private String expandVariables(EnvVars envVars, Map<String,String> buildVars,

             String token) {

         String result = Util.fixEmptyAndTrim(token);

         if (result != null) {

             result = Util.replaceMacro(Util.replaceMacro(result, envVars), buildVars);

         }

         return result;

     }

    

     private String isConfigValid(String avdName, String osVersion, String screenDensity,

             String screenResolution, String deviceLocale, String sdCardSize) {

         if (getUseNamedEmulator()) {

             ValidationResult result = descriptor.doCheckAvdName(avdName, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

         } else {

             ValidationResult result = descriptor.doCheckOsVersion(osVersion, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

             result = descriptor.doCheckScreenDensity(screenDensity, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

             result = descriptor.doCheckScreenResolution(screenResolution, null, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

             result = descriptor.doCheckDeviceLocale(deviceLocale, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

             result = descriptor.doCheckSdCardSize(sdCardSize, false);

             if (result.isFatal()) {

                 return result.getMessage();

             }

         }

         return null;

     }

    

     private String discoverAndroidHome(final Launcher launcher, final EnvVars envVars,

             final String androidHome) {

         Callable<String, InterruptedException> task = new Callable<String, InterruptedException>() {

             public String call() throws InterruptedException {

                 // Verify existence of provided value

                 if (validateHomeDir(androidHome)) {

                     return androidHome;

                 }

                 // Check for common environment variables

                 String[] keys = { "ANDROID_SDK_ROOT", "ANDROID_SDK_HOME",

                                   "ANDROID_HOME", "ANDROID_SDK" };

                 for (String key : keys) {

                     String home = envVars.get(key);

                     if (validateHomeDir(home)) {

                         return home;

                     }

                 }

                 // Give up

                 return null;

             }

             private boolean validateHomeDir(String dir) {

                 if (Util.fixEmptyAndTrim(dir) == null) {

                     return false;

                 }

                 return !descriptor.doCheckAndroidHome(new File(dir), false).isFatal();

             }

             private static final long serialVersionUID = 1L;

         };

         String result = androidHome;

         try {

             result = launcher.getChannel().call(task);

         } catch (InterruptedException e) {

             // Ignore; will return default value

         } catch (IOException e) {

             // Ignore; will return default value

         }

         return result;

     }

    

     private boolean validateAndroidToolsInPath(Launcher launcher) {

         final boolean isUnix = launcher.isUnix();

         Callable<Boolean, IOException> task = new Callable<Boolean, IOException>() {

             public Boolean call() throws IOException {

                 // Get list of required tools when working from PATH

                 Tool[] tools = { Tool.ADB, Tool.EMULATOR };

                 // Examine each directory specified by the PATH environment variable.

                 int toolCount = 0;

                 String[] paths = System.getenv("PATH").split(File.pathSeparator);

                 for (String path : paths) {

                     File toolsDirectory = new File(path);

                     if (toolsDirectory.isDirectory()) {

                         for (Tool tool : tools) {

                             String executable = tool.getExecutable(isUnix);

                             if (new File(toolsDirectory, executable).exists()) {

                                 toolCount++;

                             }

                         }

                     }

                     if (toolCount == tools.length) {

                         return true;

                     }

                 }

                 return false;

             }

             private static final long serialVersionUID = 1L;

         };

         try {

             return launcher.getChannel().call(task);

         } catch (IOException e) {

             // Ignore

         } catch (InterruptedException e) {

             // Ignore

         }

         return false;

     }

    

     private boolean sdkUsesPlatformTools(Launcher launcher, final AndroidSdk androidSdk) {

         Callable<Boolean, IOException> task = new Callable<Boolean, IOException>() {

             public Boolean call() throws IOException {

                 File toolsDirectory = new File(androidSdk.getSdkRoot(), "platform-tools");

                 return toolsDirectory.isDirectory();

             }

             private static final long serialVersionUID = 1L;

         };

         try {

             return launcher.getChannel().call(task);

         } catch (IOException e) {

             // Ignore

         } catch (InterruptedException e) {

             // Ignore

         }

         return false;

     }

    

     private boolean waitForSocket(Launcher launcher, int port, int timeout) {

         try {

             LocalPortOpenTask task = new LocalPortOpenTask(port, timeout);

             return launcher.getChannel().call(task);

         } catch (InterruptedException ex) {

             // Ignore

         } catch (IOException e) {

             // Ignore

         }

         return false;

     }

    

     private boolean waitForBootCompletion(final PrintStream logger, final Launcher launcher,

             final AndroidSdk androidSdk, final int port, final int timeout) {

         long start = System.currentTimeMillis();

         int sleep = timeout / (int) Math.sqrt(timeout / 1000);

         final String serialNo = "localhost:"+ port;

         final String args = "-s "+ serialNo +" shell getprop dev.bootcomplete";

         ArgumentListBuilder cmd = Utils.getToolCommand(androidSdk, launcher.isUnix(), Tool.ADB, args);

         try {

             while (System.currentTimeMillis() < start + timeout) {

                 ByteArrayOutputStream stream = new ByteArrayOutputStream(4);

                 // Run "getprop"

                 launcher.launch().cmds(cmd).stdout(stream).start().join();

                 // Check output

                 String result = stream.toString().trim();

                 if (result.equals("1")) {

                     return true;

                 }

                 // Otherwise continue...

                 Thread.sleep(sleep);

             }

         } catch (InterruptedException ex) {

             log(logger, Messages.INTERRUPTED_DURING_BOOT_COMPLETION());

         } catch (IOException ex) {

             log(logger, Messages.COULD_NOT_CHECK_BOOT_COMPLETION());

             ex.printStackTrace(logger);

         }

         return false;

     }

    

     private boolean sendEmulatorCommand(final Launcher launcher, final PrintStream logger,