Java tutorial
/* * ### * Android Maven Plugin - android-maven-plugin * * Copyright (C) 1999 - 2012 Photon Infotech Inc. * * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 * * 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. * ### */ /* * Copyright (C) 2009 Jayway AB * * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 * 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.photon.maven.plugins.android.standalonemojos; import java.io.File; import java.io.IOException; import org.apache.commons.io.FilenameUtils; import org.apache.commons.lang.StringUtils; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import com.android.ddmlib.AdbCommandRejectedException; import com.android.ddmlib.FileListingService; import com.android.ddmlib.FileListingService.FileEntry; import com.android.ddmlib.IDevice; import com.android.ddmlib.SyncException; import com.android.ddmlib.SyncService; import com.android.ddmlib.TimeoutException; import com.photon.maven.plugins.android.AbstractAndroidMojo; import com.photon.maven.plugins.android.DeviceCallback; import com.photon.maven.plugins.android.common.LogSyncProgressMonitor; import com.photon.maven.plugins.android.configuration.Pull; /** * Copy file or directory from all the attached (or specified) * devices/emulators. * * * @goal pull * @requiresProject false */ public class PullMojo extends AbstractAndroidMojo { /** * <p>The configuration for the pull goal can be set up in the plugin configuration in the pom file as:</p> * <pre> * <pull> * <source>path</source> * <destination>path</destination> * </pull> * </pre> * <p>The parameters can also be configured as property in the pom or settings file * <pre> * <properties> * <pull.source>pathondevice</pull.source> * <pull.destination>path</pull.destination> * </properties> * </pre> * or from command-line with parameter <code>-Dandroid.pull.source=path</code> * and <code>-Dandroid.pull.destination=path</code>.</p> * * @parameter */ private Pull pull; /** * The path of the source file or directory on the emulator/device. * * @parameter expression="${android.pull.source}" * @required */ private String pullSource; /** * The path of the destination to copy the file to. * * If destination ends with {@link File#separator}, it is supposed to be a * directory. Therefore the source - whether it refers to a file or * directory - will be copied into the destination directory. * * If destination does not end with {@link File#separator}, the last path * segment will be assumed as the new file or directory name (depending on * the type of source). * * Any missing directories will be created. * * @parameter expression="${android.pull.destination}" * @required */ private String pullDestination; private String parsedSource; private String parsedDestination; public void execute() throws MojoExecutionException, MojoFailureException { parseConfiguration(); doWithDevices(new DeviceCallback() { public void doWithDevice(final IDevice device) throws MojoExecutionException { // message will be set later according to the processed files String message = ""; try { SyncService syncService = device.getSyncService(); FileListingService fileListingService = device.getFileListingService(); FileEntry sourceFileEntry = getFileEntry(parsedSource, fileListingService); if (sourceFileEntry.isDirectory()) { // pulling directory File destinationDir = new File(parsedDestination); if (!destinationDir.exists()) { getLog().info("Creating destination directory " + destinationDir); destinationDir.mkdirs(); destinationDir.mkdir(); } String destinationDirPath = destinationDir.getAbsolutePath(); FileEntry[] fileEntries; if (parsedDestination.endsWith(File.separator)) { // pull source directory directly fileEntries = new FileEntry[] { sourceFileEntry }; } else { // pull the children of source directory only fileEntries = fileListingService.getChildren(sourceFileEntry, true, null); } message = "Pull of " + parsedSource + " to " + destinationDirPath + " from "; syncService.pull(fileEntries, destinationDirPath, new LogSyncProgressMonitor(getLog())); } else { // pulling file File parentDir = new File(FilenameUtils.getFullPath(parsedDestination)); if (!parentDir.exists()) { getLog().info("Creating destination directory " + parentDir); parentDir.mkdirs(); } String destinationFileName; if (parsedDestination.endsWith(File.separator)) { // keep original filename destinationFileName = FilenameUtils.getName(parsedSource); } else { // rename filename destinationFileName = FilenameUtils.getName(parsedDestination); } File destinationFile = new File(parentDir, destinationFileName); String destionationFilePath = destinationFile.getAbsolutePath(); message = "Pull of " + parsedSource + " to " + destionationFilePath + " from "; syncService.pullFile(sourceFileEntry, destionationFilePath, new LogSyncProgressMonitor(getLog())); } getLog().info(message + device.getSerialNumber() + " (avdName=" + device.getAvdName() + ") successful."); } catch (SyncException e) { throw new MojoExecutionException( message + device.getSerialNumber() + " (avdName=" + device.getAvdName() + ") failed.", e); } catch (IOException e) { throw new MojoExecutionException( message + device.getSerialNumber() + " (avdName=" + device.getAvdName() + ") failed.", e); } catch (TimeoutException e) { throw new MojoExecutionException( message + device.getSerialNumber() + " (avdName=" + device.getAvdName() + ") failed.", e); } catch (AdbCommandRejectedException e) { throw new MojoExecutionException( message + device.getSerialNumber() + " (avdName=" + device.getAvdName() + ") failed.", e); } } }); } private void parseConfiguration() { if (pull != null) { if (StringUtils.isNotEmpty(pull.getSource())) { parsedSource = pull.getSource(); } else { parsedSource = pullSource; } if (StringUtils.isNotEmpty(pull.getDestination())) { parsedDestination = pull.getDestination(); } else { parsedDestination = pullDestination; } } else { parsedSource = pullSource; parsedDestination = pullDestination; } } /** * Retrieves the corresponding {@link FileEntry} on the emulator/device for * a given file path. * * If the file path starts with the symlink "sdcard", it will be resolved * statically to "/mnt/sdcard". * * @param filePath * path to file or directory on device or emulator * @param fileListingService * {@link FileListingService} for retrieving the * {@link FileEntry} * @return a {@link FileEntry} object for the given file path * @throws MojoExecutionException * if the file path could not be found on the device */ private FileEntry getFileEntry(String filePath, FileListingService fileListingService) throws MojoExecutionException { // static resolution of symlink if (filePath.startsWith("/sdcard")) { filePath = "/mnt" + filePath; } String[] destinationPathSegments = StringUtils.split(filePath, "/"); FileEntry fileEntry = fileListingService.getRoot(); for (String destinationPathSegment : destinationPathSegments) { // build up file listing cache fileListingService.getChildren(fileEntry, true, null); fileEntry = fileEntry.findChild(destinationPathSegment); if (fileEntry == null) { throw new MojoExecutionException("Cannot execute goal: " + filePath + " does not exist on device."); } } return fileEntry; } }