--- /dev/null
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Eclipse Public License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.eclipse.org/org/documents/epl-v10.php
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.ide.eclipse.adt.internal.actions;
+
+import com.android.ide.eclipse.adt.AdtPlugin;
+import com.android.ide.eclipse.adt.AndroidPrintStream;
+import com.android.ide.eclipse.adt.internal.build.BuildHelper;
+import com.android.ide.eclipse.adt.internal.project.ProjectHelper;
+import com.android.ide.eclipse.adt.internal.sdk.ProjectState;
+import com.android.ide.eclipse.adt.internal.sdk.Sdk;
+import com.android.ide.eclipse.adt.io.IFolderWrapper;
+import com.android.sdklib.SdkConstants;
+import com.android.sdklib.internal.export.ApkData;
+import com.android.sdklib.internal.export.MultiApkExportHelper;
+import com.android.sdklib.internal.export.ProjectConfig;
+import com.android.sdklib.internal.export.MultiApkExportHelper.ExportException;
+import com.android.sdklib.internal.export.MultiApkExportHelper.Target;
+import com.android.sdklib.internal.project.ProjectProperties;
+import com.android.sdklib.internal.project.ProjectProperties.PropertyType;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.IObjectActionDelegate;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PlatformUI;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Multiple APK export Action.
+ * The action is triggered on a project selection, and performs a full APK export based on the
+ * content of the export.properties file.
+ */
+public class MultiApkExportAction implements IObjectActionDelegate {
+
+ private ISelection mSelection;
+
+ public void setActivePart(IAction action, IWorkbenchPart targetPart) {
+ // pass
+ }
+
+ public void run(IAction action) {
+ if (mSelection instanceof IStructuredSelection) {
+ for (Iterator<?> it = ((IStructuredSelection)mSelection).iterator(); it.hasNext();) {
+ Object element = it.next();
+ IProject project = null;
+ if (element instanceof IProject) {
+ project = (IProject)element;
+ } else if (element instanceof IAdaptable) {
+ project = (IProject)((IAdaptable)element).getAdapter(IProject.class);
+ }
+ if (project != null) {
+ IWorkbench workbench = PlatformUI.getWorkbench();
+ final IProject fProject = project;
+ try {
+ workbench.getProgressService().busyCursorWhile(new IRunnableWithProgress() {
+ /**
+ * Run the export.
+ * @throws InvocationTargetException
+ * @throws InterruptedException
+ */
+ public void run(IProgressMonitor monitor)
+ throws InvocationTargetException, InterruptedException {
+ try {
+ runMultiApkExport(fProject, monitor);
+ } catch (Exception e) {
+ AdtPlugin.logAndPrintError(e, fProject.getName(),
+ "Failed to export project: %1$s", e.getMessage());
+ } finally {
+ monitor.done();
+ }
+ }
+ });
+ } catch (Exception e) {
+ AdtPlugin.logAndPrintError(e, project.getName(),
+ "Failed to export project: %1$s",
+ e.getMessage());
+ }
+ }
+ }
+ }
+ }
+
+ public void selectionChanged(IAction action, ISelection selection) {
+ mSelection = selection;
+ }
+
+ /**
+ * Runs the multi-apk export.
+ * @param exportProject the main "export" project.
+ * @param monitor the progress monitor.
+ * @throws ExportException
+ * @throws CoreException
+ */
+ private void runMultiApkExport(IProject exportProject, IProgressMonitor monitor)
+ throws ExportException, CoreException {
+
+ ProjectProperties props = ProjectProperties.load(new IFolderWrapper(exportProject),
+ PropertyType.EXPORT);
+
+ // get some props and make sure their values are valid.
+
+ String appPackage = props.getProperty(ProjectProperties.PROPERTY_PACKAGE);
+ if (appPackage == null || appPackage.length() == 0) {
+ throw new IllegalArgumentException("Invalid 'package' property values.");
+ }
+
+ String version = props.getProperty(ProjectProperties.PROPERTY_VERSIONCODE);
+ int versionCode;
+ try {
+ versionCode = Integer.parseInt(version);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("version value is not a valid integer.", e);
+ }
+
+ String projects = props.getProperty(ProjectProperties.PROPERTY_PROJECTS);
+ if (projects == null || projects.length() == 0) {
+ throw new IllegalArgumentException("Missing project list.");
+ }
+
+ // create the multi apk helper to get the list of apk to export.
+ MultiApkExportHelper helper = new MultiApkExportHelper(
+ exportProject.getLocation().toOSString(),
+ appPackage, versionCode, Target.RELEASE, System.out);
+
+ List<ApkData> apks = helper.getApkData(projects);
+
+ // list of projects that have been resolved (ie the IProject has been found from the
+ // ProjectConfig) and compiled.
+ HashMap<ProjectConfig, ProjectState> resolvedProjects =
+ new HashMap<ProjectConfig, ProjectState>();
+
+ IWorkspace ws = ResourcesPlugin.getWorkspace();
+ IWorkspaceRoot wsRoot = ws.getRoot();
+
+ // bin folder for the export project
+ IFolder binFolder = exportProject.getFolder(SdkConstants.FD_OUTPUT);
+ if (binFolder.exists() == false) {
+ binFolder.create(true, true, monitor);
+ }
+
+ AndroidPrintStream stdout = new AndroidPrintStream(exportProject, null /*prefix*/,
+ System.out);
+ AndroidPrintStream stderr = new AndroidPrintStream(exportProject, null /*prefix*/,
+ System.err);
+
+ for (ApkData apk : apks) {
+ // find the IProject object for this apk.
+ ProjectConfig projectConfig = apk.getProjectConfig();
+ ProjectState projectState = resolvedProjects.get(projectConfig);
+ if (projectState == null) {
+ // first time? resolve the project and compile it.
+ IPath path = exportProject.getFullPath().append(projectConfig.getRelativePath());
+
+ IResource res = wsRoot.findMember(path);
+ if (res.getType() != IResource.PROJECT) {
+ throw new IllegalArgumentException(String.format(
+ "%1$s does not resolve to a project.",
+ projectConfig.getRelativePath()));
+ }
+
+ IProject project = (IProject)res;
+
+ projectState = Sdk.getProjectState(project);
+ if (projectState == null) {
+ throw new IllegalArgumentException(String.format(
+ "State for project %1$s could not be loaded.",
+ project.getName()));
+ }
+
+ if (projectState.isLibrary()) {
+ throw new IllegalArgumentException(String.format(
+ "Project %1$s is a library and cannot be part of a multi-apk export.",
+ project.getName()));
+ }
+
+ // build the project, mainly for the java compilation. The rest is handled below.
+ project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
+
+ // store the resolved project in the map.
+ resolvedProjects.put(projectConfig, projectState);
+ }
+
+ Map<String, String> variantMap = apk.getSoftVariantMap();
+
+ if (variantMap.size() > 0) {
+ // if there are soft variants, only export those.
+ for (Entry<String, String> entry : variantMap.entrySet()) {
+ buildVariant(wsRoot, projectState, appPackage, versionCode, apk, entry,
+ binFolder, stdout, stderr);
+ }
+ } else {
+ buildVariant(wsRoot, projectState, appPackage, versionCode, apk,
+ null /*soft variant*/, binFolder, stdout, stderr);
+ }
+ }
+
+ helper.writeLogs();
+ }
+
+ /**
+ * Builds a particular variant of an APK
+ * @param wsRoot the workspace root
+ * @param projectState the project to export
+ * @param appPackage the application package
+ * @param versionCode the major version code.
+ * @param apk the {@link ApkData} describing how the export should happen.
+ * @param softVariant an optional soft variant info. The entry contains (name, resource filter).
+ * @param binFolder the binFolder where the file must be created.
+ * @throws CoreException
+ */
+ private void buildVariant(IWorkspaceRoot wsRoot, ProjectState projectState, String appPackage,
+ int versionCode, ApkData apk, Entry<String, String> softVariant, IFolder binFolder,
+ AndroidPrintStream stdout, AndroidPrintStream stderr)
+ throws CoreException {
+ try {
+ // get the libraries for this project
+ List<IProject> libProjects = projectState.getFullLibraryProjects();
+
+ IProject project = projectState.getProject();
+ IJavaProject javaProject = JavaCore.create(project);
+
+ int compositeVersionCode = apk.getCompositeVersionCode(versionCode);
+
+ // figure out the file names
+ String pkgName = project.getName() + "-" + apk.getBuildInfo();
+ String finalNameRoot = appPackage + "-" + compositeVersionCode;
+ if (softVariant != null) {
+ String tmp = "-" + softVariant.getKey();
+ pkgName += tmp;
+ finalNameRoot += tmp;
+ }
+
+ pkgName += ".ap_";
+ String outputName = finalNameRoot + "-unsigned.apk";
+
+ BuildHelper helper = new BuildHelper(project, stdout, stderr,
+ false /*debugMode*/, false/*verbose*/);
+
+ // get the manifest file
+ IFile manifestFile = project.getFile(SdkConstants.FN_ANDROID_MANIFEST_XML);
+ // get the project bin folder
+ IFolder projectBinFolder = wsRoot.getFolder(javaProject.getOutputLocation());
+ String projectBinFolderPath = projectBinFolder.getLocation().toOSString();
+
+ // package the resources
+ helper.packageResources(manifestFile, libProjects,
+ softVariant != null ? softVariant.getValue() : null,
+ compositeVersionCode, projectBinFolderPath, pkgName);
+
+ apk.setOutputName(softVariant != null ? softVariant.getKey() : null, outputName);
+
+ // do the final export.
+ IFile dexFile = projectBinFolder.getFile(SdkConstants.FN_APK_CLASSES_DEX);
+ String outputFile = binFolder.getFile(outputName).getLocation().toOSString();
+
+ // get the list of referenced projects.
+ List<IProject> javaRefs = ProjectHelper.getReferencedProjects(project);
+ List<IJavaProject> referencedJavaProjects = BuildHelper.getJavaProjects(javaRefs);
+
+ helper.finalPackage(
+ new File(projectBinFolderPath, pkgName).getAbsolutePath(),
+ dexFile.getLocation().toOSString(),
+ outputFile,
+ javaProject,
+ libProjects,
+ referencedJavaProjects,
+ apk.getAbi(),
+ null, //key
+ null, //certificate
+ null); //ResourceMarker
+ } catch (CoreException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new CoreException(new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID,
+ e.getMessage(), e));
+ }
+
+ }
+}
OSDN Git Service
