Example #1
0
File: Main.java Project: MIPS/sdk
 /** Displays the list of available AVDs. */
 private void displayAvdList() {
   try {
     AvdManager avdManager = new AvdManager(mSdkManager, mSdkLog);
     displayAvdList(avdManager);
   } catch (AndroidLocationException e) {
     errorAndExit(e.getMessage());
   }
 }
Example #2
0
File: Main.java Project: MIPS/sdk
 /** Updates a broken AVD. */
 private void updateAvd() {
   try {
     String avdName = mSdkCommandLine.getParamName();
     AvdManager avdManager = new AvdManager(mSdkManager, mSdkLog);
     avdManager.updateAvd(avdName, mSdkLog);
   } catch (AndroidLocationException e) {
     errorAndExit(e.getMessage());
   } catch (IOException e) {
     errorAndExit(e.getMessage());
   }
 }
Example #3
0
File: Main.java Project: MIPS/sdk
  /** Updates adb with the USB devices declared in the SDK add-ons. */
  private void updateAdb() {
    try {
      mSdkManager.updateAdb();

      mSdkLog.printf(
          "adb has been updated. You must restart adb with the following commands\n"
              + "\tadb kill-server\n"
              + "\tadb start-server\n");
    } catch (AndroidLocationException e) {
      errorAndExit(e.getMessage());
    } catch (IOException e) {
      errorAndExit(e.getMessage());
    }
  }
Example #4
0
File: Main.java Project: MIPS/sdk
  /**
   * Delete an AVD. If the AVD name is not part of the available ones look for an invalid AVD (one
   * not loaded due to some error) to remove it too.
   */
  private void deleteAvd() {
    try {
      String avdName = mSdkCommandLine.getParamName();
      AvdManager avdManager = new AvdManager(mSdkManager, mSdkLog);
      AvdInfo info = avdManager.getAvd(avdName, false /*validAvdOnly*/);

      if (info == null) {
        errorAndExit("There is no Android Virtual Device named '%s'.", avdName);
        return;
      }

      avdManager.deleteAvd(info, mSdkLog);
    } catch (AndroidLocationException e) {
      errorAndExit(e.getMessage());
    }
  }
  /**
   * Initializes the {@link SdkManager} and the {@link AvdManager}. Extracted so that we can
   * override this in unit tests.
   */
  @VisibleForTesting(visibility = Visibility.PRIVATE)
  protected void initSdk() {
    setSdkManager(SdkManager.createManager(mOsSdkRoot, mSdkLog));
    try {
      mAvdManager = null;
      mAvdManager = AvdManager.getInstance(mSdkManager, mSdkLog);
    } catch (AndroidLocationException e) {
      mSdkLog.error(e, "Unable to read AVDs: " + e.getMessage()); // $NON-NLS-1$

      // Note: we used to continue here, but the thing is that
      // mAvdManager==null so nothing is really going to work as
      // expected. Let's just display an error later in checkIfInitFailed()
      // and abort right there. This step is just too early in the SWT
      // setup process to display a message box yet.

      mAvdManagerInitError = e;
    }

    // notify listeners.
    broadcastOnSdkReload();
  }
Example #6
0
File: Main.java Project: MIPS/sdk
  /** Moves an AVD. */
  private void moveAvd() {
    try {
      String avdName = mSdkCommandLine.getParamName();
      AvdManager avdManager = new AvdManager(mSdkManager, mSdkLog);
      AvdInfo info = avdManager.getAvd(avdName, true /*validAvdOnly*/);

      if (info == null) {
        errorAndExit("There is no valid Android Virtual Device named '%s'.", avdName);
        return;
      }

      // This is a rename if there's a new name for the AVD
      String newName = mSdkCommandLine.getParamMoveNewName();
      if (newName != null && newName.equals(info.getName())) {
        // same name, not actually a rename operation
        newName = null;
      }

      // This is a move (of the data files) if there's a new location path
      String paramFolderPath = mSdkCommandLine.getParamLocationPath();
      if (paramFolderPath != null) {
        // check if paths are the same. Use File methods to account for OS idiosyncrasies.
        try {
          File f1 = new File(paramFolderPath).getCanonicalFile();
          File f2 = new File(info.getPath()).getCanonicalFile();
          if (f1.equals(f2)) {
            // same canonical path, so not actually a move
            paramFolderPath = null;
          }
        } catch (IOException e) {
          // Fail to resolve canonical path. Fail now since a move operation might fail
          // later and be harder to recover from.
          errorAndExit(e.getMessage());
          return;
        }
      }

      if (newName == null && paramFolderPath == null) {
        mSdkLog.warning("Move operation aborted: same AVD name, same canonical data path");
        return;
      }

      // If a rename was requested and no data move was requested, check if the original
      // data path is our default constructed from the AVD name. In this case we still want
      // to rename that folder too.
      if (newName != null && paramFolderPath == null) {
        // Compute the original data path
        File originalFolder =
            new File(
                AndroidLocation.getFolder() + AndroidLocation.FOLDER_AVD,
                info.getName() + AvdManager.AVD_FOLDER_EXTENSION);
        if (originalFolder.equals(info.getPath())) {
          try {
            // The AVD is using the default data folder path based on the AVD name.
            // That folder needs to be adjusted to use the new name.
            File f =
                new File(
                    AndroidLocation.getFolder() + AndroidLocation.FOLDER_AVD,
                    newName + AvdManager.AVD_FOLDER_EXTENSION);
            paramFolderPath = f.getCanonicalPath();
          } catch (IOException e) {
            // Fail to resolve canonical path. Fail now rather than later.
            errorAndExit(e.getMessage());
          }
        }
      }

      // Check for conflicts
      if (newName != null) {
        if (avdManager.getAvd(newName, false /*validAvdOnly*/) != null) {
          errorAndExit("There is already an AVD named '%s'.", newName);
          return;
        }

        File ini = info.getIniFile();
        if (ini.equals(AvdInfo.getIniFile(newName))) {
          errorAndExit("The AVD file '%s' is in the way.", ini.getCanonicalPath());
          return;
        }
      }

      if (paramFolderPath != null && new File(paramFolderPath).exists()) {
        errorAndExit(
            "There is already a file or directory at '%s'.\nUse --path to specify a different data folder.",
            paramFolderPath);
      }

      avdManager.moveAvd(info, newName, paramFolderPath, mSdkLog);
    } catch (AndroidLocationException e) {
      errorAndExit(e.getMessage());
    } catch (IOException e) {
      errorAndExit(e.getMessage());
    }
  }
Example #7
0
File: Main.java Project: MIPS/sdk
  /** Creates a new AVD. This is a text based creation with command line prompt. */
  private void createAvd() {
    // find a matching target
    int targetId = resolveTargetName(mSdkCommandLine.getParamTargetId());
    IAndroidTarget[] targets = mSdkManager.getTargets();

    if (targetId == INVALID_TARGET_ID || targetId > targets.length) {
      errorAndExit(
          "Target id is not valid. Use '%s list targets' to get the target ids.",
          SdkConstants.androidCmdName());
    }

    IAndroidTarget target = targets[targetId - 1]; // target id is 1-based

    try {
      boolean removePrevious = mSdkCommandLine.getFlagForce();
      AvdManager avdManager = new AvdManager(mSdkManager, mSdkLog);

      String avdName = mSdkCommandLine.getParamName();

      if (!AvdManager.RE_AVD_NAME.matcher(avdName).matches()) {
        errorAndExit(
            "AVD name '%1$s' contains invalid characters.\nAllowed characters are: %2$s",
            avdName, AvdManager.CHARS_AVD_NAME);
        return;
      }

      AvdInfo info = avdManager.getAvd(avdName, false /*validAvdOnly*/);
      if (info != null) {
        if (removePrevious) {
          mSdkLog.warning(
              "Android Virtual Device '%s' already exists and will be replaced.", avdName);
        } else {
          errorAndExit(
              "Android Virtual Device '%s' already exists.\n"
                  + "Use --force if you want to replace it.",
              avdName);
          return;
        }
      }

      String paramFolderPath = mSdkCommandLine.getParamLocationPath();
      File avdFolder = null;
      if (paramFolderPath != null) {
        avdFolder = new File(paramFolderPath);
      } else {
        avdFolder = AvdManager.AvdInfo.getAvdFolder(avdName);
      }

      // Validate skin is either default (empty) or NNNxMMM or a valid skin name.
      Map<String, String> skinHardwareConfig = null;
      String skin = mSdkCommandLine.getParamSkin();
      if (skin != null && skin.length() == 0) {
        skin = null;
      }

      if (skin != null && target != null) {
        boolean valid = false;
        // Is it a know skin name for this target?
        for (String s : target.getSkins()) {
          if (skin.equalsIgnoreCase(s)) {
            skin = s; // Make skin names case-insensitive.
            valid = true;

            // get the hardware properties for this skin
            File skinFolder = avdManager.getSkinPath(skin, target);
            FileWrapper skinHardwareFile = new FileWrapper(skinFolder, AvdManager.HARDWARE_INI);
            if (skinHardwareFile.isFile()) {
              skinHardwareConfig = ProjectProperties.parsePropertyFile(skinHardwareFile, mSdkLog);
            }
            break;
          }
        }

        // Is it NNNxMMM?
        if (!valid) {
          valid = AvdManager.NUMERIC_SKIN_SIZE.matcher(skin).matches();
        }

        if (!valid) {
          displaySkinList(target, "Valid skins: ");
          errorAndExit("'%s' is not a valid skin name or size (NNNxMMM)", skin);
          return;
        }
      }

      Map<String, String> hardwareConfig = null;
      if (target != null && target.isPlatform()) {
        try {
          hardwareConfig = promptForHardware(target, skinHardwareConfig);
        } catch (IOException e) {
          errorAndExit(e.getMessage());
        }
      }

      @SuppressWarnings("unused") // oldAvdInfo is never read, yet useful for debugging
      AvdInfo oldAvdInfo = null;
      if (removePrevious) {
        oldAvdInfo = avdManager.getAvd(avdName, false /*validAvdOnly*/);
      }

      @SuppressWarnings("unused") // newAvdInfo is never read, yet useful for debugging
      AvdInfo newAvdInfo =
          avdManager.createAvd(
              avdFolder,
              avdName,
              target,
              skin,
              mSdkCommandLine.getParamSdCard(),
              hardwareConfig,
              removePrevious,
              mSdkCommandLine.getFlagSnapshot(),
              mSdkLog);

    } catch (AndroidLocationException e) {
      errorAndExit(e.getMessage());
    }
  }