Exemple #1
0
  /**
   * Execute the zipalign for a certain apk
   *
   * @param apk
   */
  public static void zipAlign(File apk) {
    // String zipAlign = SdkUtils.getSdkToolsPath();
    String zipAlign =
        AndroidUtils.getSDKPathByPreference() + IPath.SEPARATOR + IAndroidConstants.FD_TOOLS;
    try {
      File tempFile = File.createTempFile("_tozipalign", ".apk");
      FileUtil.copyFile(apk, tempFile);

      if (!zipAlign.endsWith(File.separator)) {
        zipAlign += File.separator;
      }
      zipAlign += Platform.getOS().equals(Platform.OS_WIN32) ? "zipalign.exe" : "zipalign";

      String[] command =
          new String[] {
            zipAlign, "-f", "-v", "4", tempFile.getAbsolutePath(), apk.getAbsolutePath()
          };
      StringBuilder commandLine = new StringBuilder();
      for (String commandPart : command) {
        commandLine.append(commandPart);
        commandLine.append(" ");
      }

      AndmoreLogger.info(PackageFile.class, "Zipaligning package: " + commandLine.toString());
      Runtime.getRuntime().exec(command);
    } catch (IOException e) {
      AndmoreLogger.error(PackageFile.class, "Error while zipaligning package", e);
    } catch (Exception e) {
      AndmoreLogger.error(
          PackageFile.class,
          "Zipalign application cannot be executed - insuficient permissions",
          e);
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.andmore.android.model.java.JavaClass#addComments()
   */
  @Override
  protected void addComments() throws AndroidException {
    ASTNode todoComment;

    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(document.get().toCharArray());

    compUnit = (CompilationUnit) parser.createAST(null);
    ast = compUnit.getAST();
    rewrite = ASTRewrite.create(ast);

    todoComment =
        rewrite.createStringPlaceholder(
            CodeUtilsNLS.MODEL_Common_ToDoPutYourCodeHere, ASTNode.EMPTY_STATEMENT);

    TypeDeclaration receiverClass = (TypeDeclaration) compUnit.types().get(0);
    MethodDeclaration method;
    Block block;

    // Adds the Override annotation and ToDo comment to all overridden
    // methods
    for (int i = 0; i < receiverClass.bodyDeclarations().size(); i++) {
      method = (MethodDeclaration) receiverClass.bodyDeclarations().get(i);

      // Adds the Override annotation
      rewrite
          .getListRewrite(method, method.getModifiersProperty())
          .insertFirst(OVERRIDE_ANNOTATION, null);

      // Adds the ToDo comment
      block = method.getBody();
      rewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY).insertFirst(todoComment, null);
    }

    try {
      // Writes the modifications
      TextEdit modifications = rewrite.rewriteAST(document, null);
      modifications.apply(document);
    } catch (IllegalArgumentException e) {
      String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);

      AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
      throw new AndroidException(errMsg);
    } catch (MalformedTreeException e) {
      String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);

      AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
      throw new AndroidException(errMsg);
    } catch (BadLocationException e) {
      String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);

      AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
      throw new AndroidException(errMsg);
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.jface.wizard.Wizard#performFinish()
   */
  @Override
  public boolean performFinish() {
    boolean saved = false;

    try {
      DoSave doSave = new DoSave();

      getContainer().run(false, false, doSave);

      if (doSave.exception != null) {
        throw doSave.exception;
      } else {
        saved = doSave.saved;
      }
    } catch (Exception e) {
      IStatus status =
          new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, e.getLocalizedMessage());
      EclipseUtils.showErrorDialog(
          CodeUtilsNLS.UI_GenericErrorDialogTitle,
          CodeUtilsNLS.ERR_BuildingBlockCreation_ErrorMessage,
          status);
    }

    if (saved) {
      ICompilationUnit javaFile =
          getBuildingBlock()
              .getPackageFragment()
              .getCompilationUnit(getBuildingBlock().getName() + ".java"); // $NON-NLS-1$

      if ((javaFile != null) && javaFile.exists()) {
        try {
          JavaUI.openInEditor(javaFile);
        } catch (Exception e) {
          // Do nothing
          AndmoreLogger.error(
              NewActivityBasedOnTemplateWizard.class,
              "Could not open the activity " //$NON-NLS-1$
                  + getBuildingBlock().getName()
                  + " on an editor.",
              e); //$NON-NLS-1$
        }
      }
    }

    if (saved) {
      // Collecting usage data for statistical purposes
      try {
        AndmoreLogger.collectUsageData(
            UsageDataConstants.WHAT_BUILDINGBLOCK_ACTIVITY,
            UsageDataConstants.KIND_BUILDINGBLOCK,
            UsageDataConstants.DESCRIPTION_DEFAULT,
            CodeUtilsActivator.PLUGIN_ID,
            CodeUtilsActivator.getDefault().getBundle().getVersion().toString());
      } catch (Throwable e) {
        // Do nothing, but error on the log should never prevent app
        // from working
      }
    }
    return saved;
  }
  /*
   * Wait until the device status becomes online
   *
   * @param serialNumber device serial number
   *
   * @param instance TmL instance, if it exists
   *
   * @return true if the device became online, false otherwise
   */
  private static boolean waitForDeviceToBeOnline(String serialNumber, ISerialNumbered instance) {
    AndmoreLogger.debug("Wait device to be online: " + serialNumber);

    boolean instanceOnline = false;
    long timeoutLimit = 0;

    if (instance != null) {
      Properties prop = ((IInstance) instance).getProperties();
      String timeout = prop.getProperty(RemoteDeviceInstance.PROPERTY_TIMEOUT);
      timeoutLimit = System.currentTimeMillis() + (Integer.parseInt(timeout) * 1000);
    } else {
      timeoutLimit = System.currentTimeMillis() + (RemoteDeviceConstants.DEFAULT_TIMEOUT * 1000);
    }

    while ((instanceOnline = DDMSFacade.isDeviceOnline(serialNumber)) == false) {
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        AndmoreLogger.error("Wait for device to be online: thread has been interrupted");
      }

      try {
        testTimeout(timeoutLimit);
      } catch (TimeoutException e) {
        AndmoreLogger.warn("Timeout reached wile wating device to be online: " + serialNumber);
        break;
      }
    }
    return instanceOnline;
  }
Exemple #5
0
  /**
   * Writes this package file to an output stream
   *
   * @param outputStream the stream to write the package to
   * @throws IOException if an I/O error occurs when writing the package contents to the output
   *     stream
   */
  public void write(OutputStream outputStream) throws IOException {
    // create a jar output stream
    JarOutputStream jarOut = null;

    try {
      jarOut = new JarOutputStream(outputStream, manifest);

      // for each entry in the package file
      for (String jarEntryName : entryMap.keySet()) {
        if (jarEntryName.contains("raw/") || rawFiles.contains(jarEntryName)) {
          writeRaw(jarOut, jarEntryName);
        } else {
          writeCompressed(jarOut, jarEntryName);
        }
      }
    } finally {
      if (jarOut != null) {
        try {
          jarOut.finish();
          jarOut.close();
        } catch (IOException e) {
          AndmoreLogger.error("Could not close stream while writing jar file. " + e.getMessage());
        }
      }
    }
  }
Exemple #6
0
 private void writeCompressed(JarOutputStream jarOut, String entryName) throws IOException {
   File file = entryMap.get(entryName);
   if ((file.exists()) && (file.isFile())) {
     JarEntry entry = new JarEntry(entryName);
     jarOut.putNextEntry(entry);
     WritableByteChannel outputChannel = null;
     FileChannel readFromFileChannel = null;
     FileInputStream inputStream = null;
     try {
       outputChannel = Channels.newChannel(jarOut);
       inputStream = new FileInputStream(file);
       readFromFileChannel = inputStream.getChannel();
       readFromFileChannel.transferTo(0, file.length(), outputChannel);
     } finally {
       try {
         if (jarOut != null) {
           jarOut.closeEntry();
         }
         if (readFromFileChannel != null) {
           readFromFileChannel.close();
         }
         if (inputStream != null) {
           inputStream.close();
         }
       } catch (IOException e) {
         AndmoreLogger.error("Could not close stream: ", e.getMessage()); // $NON-NLS-1$
       }
     }
   }
 }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator#
   * isSelectedValid(java.lang.Object)
   */
  @Override
  public boolean isSelectedValid(Object element) {
    boolean isValid = false;
    try {
      if (element instanceof IJavaProject) {
        IJavaProject jproject = (IJavaProject) element;
        IPath path = jproject.getProject().getFullPath();
        isValid = (jproject.findPackageFragmentRoot(path) != null);
      } else if (element instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;

        boolean isSrc = (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE);
        boolean isGen =
            packageFragmentRoot.getElementName().equals(IAndroidConstants.GEN_SRC_FOLDER)
                && (packageFragmentRoot.getParent() instanceof IJavaProject);

        isValid = isSrc && !isGen;
      } else {
        isValid = true;
      }
    } catch (JavaModelException e) {
      AndmoreLogger.error(ElementTreeValidator.class, e.getLocalizedMessage(), e);
    }
    return isValid;
  }
Exemple #8
0
  /**
   * Retrieves an image data. If it has never been used at the current session, loads it from skin.
   * Released image is retrieved if both parameters are false.
   *
   * @param isPressed true if the image to be retrieved is the pressed image
   * @param isEnter true if the image to be retrieved is the enter image. It only has effect if
   *     isPressed == false
   * @return An image data containing the desired image pixels
   */
  private ImageData getImageData(boolean isPressed, boolean isEnter) {

    ImageData imageData = null;

    IAndroidEmulatorInstance instance = UIHelper.getInstanceAssociatedToControl(this);

    try {
      if (isPressed) {
        imageData = skin.getPressedImageData(instance.getCurrentLayout());

      } else {
        if (isEnter) {
          imageData = skin.getEnterImageData(instance.getCurrentLayout());

        } else {
          imageData = skin.getReleasedImageData(instance.getCurrentLayout());
        }
      }
    } catch (SkinException e) {
      error(
          "The image requested from skin could not be retrieved. isPressed="
              + isPressed
              + "; message="
              + e.getMessage());
      EclipseUtils.showErrorDialog(e);
      error("The skin could not provide an important resource. Stopping the instance");
      try {
        instance.stop(true);
      } catch (InstanceStopException e1) {
        error("Error while running service for stopping virtual machine");
        EclipseUtils.showErrorDialog(
            EmulatorNLS.GEN_Error, EmulatorNLS.EXC_General_CannotRunStopService);
      }
    }

    return imageData;
  }
  /**
   * Execute a command.
   *
   * @param cmd Array of strings holding the command to be executed.
   * @return The {@link IStatus} of the command execution.
   * @throws IOException Exception thrown in case there are problems executing the command.
   */
  public static IStatus executeCommand(String[] cmd) throws IOException {
    IStatus status = Status.OK_STATUS;

    Runtime runtime = Runtime.getRuntime();
    Process process = runtime.exec(cmd);

    try {
      // wait for the command to finish its execution
      process.waitFor();
    } catch (InterruptedException e) {
      AndmoreLogger.error(RemoteDeviceUtils.class, "Problems executing the command");
      status =
          new Status(
              IStatus.ERROR, RemoteDevicePlugin.PLUGIN_ID, "Problems executing the command", e);
    }
    // in case the is a problem with the command execution, create an error
    // status
    if (process.exitValue() != 0) {
      AndmoreLogger.error(RemoteDeviceUtils.class, "The IP was not found");
      status = new Status(IStatus.ERROR, RemoteDevicePlugin.PLUGIN_ID, "The IP was not found");
    }

    return status;
  }
 @Override
 public void run(IProgressMonitor monitor)
     throws InvocationTargetException, InterruptedException {
   try {
     saved = getBuildingBlock().save(getContainer(), monitor);
     getBuildingBlock().getProject().refreshLocal(IResource.DEPTH_INFINITE, monitor);
     getBuildingBlock().getProject().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
   } catch (CoreException ce) {
     // build failed - show a warning message
     AndmoreLogger.error(this.getClass(), ce.getMessage(), ce);
     EclipseUtils.showWarningDialog(
         CodeUtilsNLS.UI_NewActivityWizard_TitleNewActivityWizard,
         CodeUtilsNLS.NewActivityWizard_MessageSomeProblemsOccurredWhileBuildingProject);
   } catch (AndroidException e) {
     exception = e;
   }
 }
Exemple #11
0
  @Override
  public void applyLayout(String layoutName) {
    // Populate the attributes with information from skin
    AndroidSkinBean skinBean = null;

    try {
      skinBean = skin.getSkinBean(layoutName);
    } catch (SkinException e) {
      error("The skin data could not be retrieved from skin files. Cause: " + e.getMessage());
      EclipseUtils.showErrorDialog(e);
    }

    // Create layout and set it to composite
    if (skinBean != null) {
      // When changing to a new layout, the key may move to another
      // position
      // It does not make sense to keep the old key object
      currentKey = null;

      // Change the background color to the one that applies to the layout
      // being set
      RGB color = skin.getBackgroundColor(layoutName);
      setBackground(new Color(PlatformUI.getWorkbench().getDisplay(), color));

      Layout prevLayout = getLayout();
      if (prevLayout instanceof AndroidSkinLayout) {
        ((AndroidSkinLayout) prevLayout).dispose();
      }

      AndroidSkinLayout androidLayout = new AndroidSkinLayout(skinBean, skin.isFlipSupported());
      setLayout(androidLayout);

      embeddedViewScale = skinBean.getEmbeddedViewScale();

      layout();
      redraw();
    }
  }
  /**
   * Handle Remote Device disconnection
   *
   * @param serialNumber the serial number of the disconnected device
   */
  public static void disconnectDevice(String serialNumber) {
    if (DDMSFacade.isRemote(serialNumber)) {

      ISerialNumbered instance = DevicesManager.getInstance().getDeviceBySerialNumber(serialNumber);

      AndmoreLogger.debug(
          "Handle remote device disconnected event. Serial Number: "
              + serialNumber
              + " Instance: "
              + instance);

      if (instance != null) {
        Object volatileProperty =
            ((RemoteDeviceInstance) instance)
                .getProperties()
                .get(RemoteDeviceInstance.PROPERTY_VOLATILE);
        boolean isVolatile =
            ((volatileProperty != null) ? ((Boolean) volatileProperty).booleanValue() : false);

        if (!isVolatile) {
          try {
            AndmoreLogger.debug(
                "Disconnecting Remote Device: the device is NOT volatile, the TmL service will be called");

            Map<Object, Object> arguments = new HashMap<Object, Object>();
            arguments.put(RemoteDeviceConstants.DUMMY_TRANSITION, true);
            RemoteDevicePlugin.getDisconnectServiceHandler().run((IInstance) instance, arguments);
          } catch (Exception e) {
            AndmoreLogger.error("Error when running TmL disconnect service: " + e.getMessage());
          }
        } else {
          AndmoreLogger.debug(
              "Disconnecting Remote Device: the device is volatile, it will be deleted");
          DevicesManager.getInstance().deleteInstanceOfDevice(serialNumber);
        }
      }
    }
  }