1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Eclipse Public License, Version 1.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.eclipse.org/org/documents/epl-v10.php 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.ide.eclipse.adt.internal.build; 18 19 import com.android.ide.eclipse.adt.AdtPlugin; 20 21 import org.eclipse.core.runtime.CoreException; 22 import org.eclipse.core.runtime.IStatus; 23 import org.eclipse.core.runtime.Status; 24 25 import java.io.File; 26 import java.io.PrintStream; 27 import java.lang.reflect.Constructor; 28 import java.lang.reflect.Field; 29 import java.lang.reflect.Method; 30 import java.net.MalformedURLException; 31 import java.net.URL; 32 import java.net.URLClassLoader; 33 import java.util.Collection; 34 35 /** 36 * Wrapper to access dx.jar through reflection. 37 * <p/>Since there is no proper api to call the method in the dex library, this wrapper is going 38 * to access it through reflection. 39 */ 40 public final class DexWrapper { 41 42 private final static String DEX_MAIN = "com.android.dx.command.dexer.Main"; //$NON-NLS-1$ 43 private final static String DEX_CONSOLE = "com.android.dx.command.DxConsole"; //$NON-NLS-1$ 44 private final static String DEX_ARGS = "com.android.dx.command.dexer.Main$Arguments"; //$NON-NLS-1$ 45 46 private final static String MAIN_RUN = "run"; //$NON-NLS-1$ 47 48 private Method mRunMethod; 49 50 private Constructor<?> mArgConstructor; 51 private Field mArgOutName; 52 private Field mArgVerbose; 53 private Field mArgJarOutput; 54 private Field mArgFileNames; 55 56 private Field mConsoleOut; 57 private Field mConsoleErr; 58 59 /** 60 * Loads the dex library from a file path. 61 * 62 * The loaded library can be used via 63 * {@link DexWrapper#run(String, String[], boolean, PrintStream, PrintStream)}. 64 * 65 * @param osFilepath the location of the dx.jar file. 66 * @return an IStatus indicating the result of the load. 67 */ loadDex(String osFilepath)68 public synchronized IStatus loadDex(String osFilepath) { 69 try { 70 File f = new File(osFilepath); 71 if (f.isFile() == false) { 72 return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, String.format( 73 Messages.DexWrapper_s_does_not_exists, osFilepath)); 74 } 75 URL url = f.toURI().toURL(); 76 77 URLClassLoader loader = new URLClassLoader(new URL[] { url }, 78 DexWrapper.class.getClassLoader()); 79 80 // get the classes. 81 Class<?> mainClass = loader.loadClass(DEX_MAIN); 82 Class<?> consoleClass = loader.loadClass(DEX_CONSOLE); 83 Class<?> argClass = loader.loadClass(DEX_ARGS); 84 85 try { 86 // now get the fields/methods we need 87 mRunMethod = mainClass.getMethod(MAIN_RUN, argClass); 88 89 mArgConstructor = argClass.getConstructor(); 90 mArgOutName = argClass.getField("outName"); //$NON-NLS-1$ 91 mArgJarOutput = argClass.getField("jarOutput"); //$NON-NLS-1$ 92 mArgFileNames = argClass.getField("fileNames"); //$NON-NLS-1$ 93 mArgVerbose = argClass.getField("verbose"); //$NON-NLS-1$ 94 95 mConsoleOut = consoleClass.getField("out"); //$NON-NLS-1$ 96 mConsoleErr = consoleClass.getField("err"); //$NON-NLS-1$ 97 98 } catch (SecurityException e) { 99 return createErrorStatus(Messages.DexWrapper_SecuryEx_Unable_To_Find_API, e); 100 } catch (NoSuchMethodException e) { 101 return createErrorStatus(Messages.DexWrapper_SecuryEx_Unable_To_Find_Method, e); 102 } catch (NoSuchFieldException e) { 103 return createErrorStatus(Messages.DexWrapper_SecuryEx_Unable_To_Find_Field, e); 104 } 105 106 return Status.OK_STATUS; 107 } catch (MalformedURLException e) { 108 // really this should not happen. 109 return createErrorStatus( 110 String.format(Messages.DexWrapper_Failed_to_load_s, osFilepath), e); 111 } catch (ClassNotFoundException e) { 112 return createErrorStatus( 113 String.format(Messages.DexWrapper_Failed_to_load_s, osFilepath), e); 114 } 115 } 116 117 /** 118 * Removes any reference to the dex library. 119 * <p/> 120 * {@link #loadDex(String)} must be called on the wrapper 121 * before {@link #run(String, String[], boolean, PrintStream, PrintStream)} can 122 * be used again. 123 */ unload()124 public synchronized void unload() { 125 mRunMethod = null; 126 mArgConstructor = null; 127 mArgOutName = null; 128 mArgJarOutput = null; 129 mArgFileNames = null; 130 mArgVerbose = null; 131 mConsoleOut = null; 132 mConsoleErr = null; 133 System.gc(); 134 } 135 136 /** 137 * Runs the dex command. 138 * The wrapper must have been initialized via {@link #loadDex(String)} first. 139 * 140 * @param osOutFilePath the OS path to the outputfile (classes.dex 141 * @param osFilenames list of input source files (.class and .jar files) 142 * @param verbose verbose mode. 143 * @param outStream the stdout console 144 * @param errStream the stderr console 145 * @return the integer return code of com.android.dx.command.dexer.Main.run() 146 * @throws CoreException 147 */ run(String osOutFilePath, Collection<String> osFilenames, boolean verbose, PrintStream outStream, PrintStream errStream)148 public synchronized int run(String osOutFilePath, Collection<String> osFilenames, 149 boolean verbose, PrintStream outStream, PrintStream errStream) throws CoreException { 150 151 assert mRunMethod != null; 152 assert mArgConstructor != null; 153 assert mArgOutName != null; 154 assert mArgJarOutput != null; 155 assert mArgFileNames != null; 156 assert mArgVerbose != null; 157 assert mConsoleOut != null; 158 assert mConsoleErr != null; 159 160 if (mRunMethod == null) { 161 throw new CoreException(createErrorStatus( 162 String.format(Messages.DexWrapper_Unable_To_Execute_Dex_s, 163 "wrapper was not properly loaded first"), 164 null /*exception*/)); 165 } 166 167 try { 168 // set the stream 169 mConsoleErr.set(null /* obj: static field */, errStream); 170 mConsoleOut.set(null /* obj: static field */, outStream); 171 172 // create the Arguments object. 173 Object args = mArgConstructor.newInstance(); 174 mArgOutName.set(args, osOutFilePath); 175 mArgFileNames.set(args, osFilenames.toArray(new String[osFilenames.size()])); 176 mArgJarOutput.set(args, false); 177 mArgVerbose.set(args, verbose); 178 179 // call the run method 180 Object res = mRunMethod.invoke(null /* obj: static method */, args); 181 182 if (res instanceof Integer) { 183 return ((Integer)res).intValue(); 184 } 185 186 return -1; 187 } catch (Exception e) { 188 Throwable t = e; 189 while (t.getCause() != null) { 190 t = t.getCause(); 191 } 192 193 String msg = t.getMessage(); 194 if (msg == null) { 195 msg = String.format("%s. Check the Eclipse log for stack trace.", 196 t.getClass().getName()); 197 } 198 199 throw new CoreException(createErrorStatus( 200 String.format(Messages.DexWrapper_Unable_To_Execute_Dex_s, msg), t)); 201 } 202 } 203 createErrorStatus(String message, Throwable e)204 private static IStatus createErrorStatus(String message, Throwable e) { 205 AdtPlugin.log(e, message); 206 AdtPlugin.printErrorToConsole(Messages.DexWrapper_Dex_Loader, message); 207 208 return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, message, e); 209 } 210 } 211