tests/068-classloader/src/FancyLoader.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 import java.io.File;
  18 import java.io.FileNotFoundException;
  19 import java.io.IOException;
  20 import java.io.RandomAccessFile;
  21 import java.lang.reflect.Constructor;
  22 import java.lang.reflect.Method;
  23 import java.lang.reflect.InvocationTargetException;
  24
  25 /**
  26  * A class loader with atypical behavior: we try to load a private
  27  * class implementation before asking the system or boot loader.  This
  28  * is used to create multiple classes with identical names in a single VM.
  29  *
  30  * If DexFile is available, we use that; if not, we assume we're not in
  31  * Dalvik and instantiate the class with defineClass().
  32  *
  33  * The location of the DEX files and class data is dependent upon the
  34  * test framework.
  35  */
  36 public class FancyLoader extends ClassLoader {
  37     /* this is where the "alternate" .class files live */
  38     static final String CLASS_PATH = "classes-ex/";
  39
  40     /* this is the "alternate" DEX/Jar file */
  41     static final String DEX_FILE = "test-ex.jar";
  42
  43     /* on Dalvik, this is a DexFile; otherwise, it's null */
  44     private Class mDexClass;
  45
  46     private Object mDexFile;
  47
  48     /**
  49      * Construct FancyLoader, grabbing a reference to the DexFile class
  50      * if we're running under Dalvik.
  51      */
  52     public FancyLoader(ClassLoader parent) {
  53         super(parent);
  54
  55         try {
  56             mDexClass = parent.loadClass("dalvik.system.DexFile");
  57         } catch (ClassNotFoundException cnfe) {
  58             // ignore -- not running Dalvik
  59         }
  60     }
  61
  62     /**
  63      * Finds the class with the specified binary name.
  64      *
  65      * We search for a file in CLASS_PATH or pull an entry from DEX_FILE.
  66      * If we don't find a match, we throw an exception.
  67      */
  68     protected Class<?> findClass(String name) throws ClassNotFoundException
  69     {
  70         if (mDexClass != null) {
  71             return findClassDalvik(name);
  72         } else {
  73             return findClassNonDalvik(name);
  74         }
  75     }
  76
  77     /**
  78      * Finds the class with the specified binary name, from a DEX file.
  79      */
  80     private Class<?> findClassDalvik(String name)
  81         throws ClassNotFoundException {
  82
  83         if (mDexFile == null) {
  84             synchronized (FancyLoader.class) {
  85                 Constructor ctor;
  86                 /*
  87                  * Construct a DexFile object through reflection.
  88                  */
  89                 try {
  90                     ctor = mDexClass.getConstructor(new Class[] {String.class});
  91                 } catch (NoSuchMethodException nsme) {
  92                     throw new ClassNotFoundException("getConstructor failed",
  93                         nsme);
  94                 }
  95
  96                 try {
  97                     mDexFile = ctor.newInstance(DEX_FILE);
  98                 } catch (InstantiationException ie) {
  99                     throw new ClassNotFoundException("newInstance failed", ie);
 100                 } catch (IllegalAccessException iae) {
 101                     throw new ClassNotFoundException("newInstance failed", iae);
 102                 } catch (InvocationTargetException ite) {
 103                     throw new ClassNotFoundException("newInstance failed", ite);
 104                 }
 105             }
 106         }
 107
 108         /*
 109          * Call DexFile.loadClass(String, ClassLoader).
 110          */
 111         Method meth;
 112
 113         try {
 114             meth = mDexClass.getMethod("loadClass",
 115                     new Class[] { String.class, ClassLoader.class });
 116         } catch (NoSuchMethodException nsme) {
 117             throw new ClassNotFoundException("getMethod failed", nsme);
 118         }
 119
 120         try {
 121             meth.invoke(mDexFile, name, this);
 122         } catch (IllegalAccessException iae) {
 123             throw new ClassNotFoundException("loadClass failed", iae);
 124         } catch (InvocationTargetException ite) {
 125             throw new ClassNotFoundException("loadClass failed",
 126                 ite.getCause());
 127         }
 128
 129         return null;
 130     }
 131
 132     /**
 133      * Finds the class with the specified binary name, from .class files.
 134      */
 135     private Class<?> findClassNonDalvik(String name)
 136         throws ClassNotFoundException {
 137
 138         String pathName = CLASS_PATH + name + ".class";
 139         //System.out.println("--- Fancy: looking for " + pathName);
 140
 141         File path = new File(pathName);
 142         RandomAccessFile raf;
 143
 144         try {
 145             raf = new RandomAccessFile(path, "r");
 146         } catch (FileNotFoundException fnfe) {
 147             throw new ClassNotFoundException("Not found: " + pathName);
 148         }
 149
 150         /* read the entire file in */
 151         byte[] fileData;
 152         try {
 153             fileData = new byte[(int) raf.length()];
 154             raf.readFully(fileData);
 155         } catch (IOException ioe) {
 156             throw new ClassNotFoundException("Read error: " + pathName);
 157         } finally {
 158             try {
 159                 raf.close();
 160             } catch (IOException ioe) {
 161                 // drop
 162             }
 163         }
 164
 165         /* create the class */
 166         //System.out.println("--- Fancy: defining " + name);
 167         try {
 168             return defineClass(name, fileData, 0, fileData.length);
 169         } catch (Throwable th) {
 170             throw new ClassNotFoundException("defineClass failed", th);
 171         }
 172     }
 173
 174     /**
 175      * Load a class.
 176      *
 177      * Normally a class loader wouldn't override this, but we want our
 178      * version of the class to take precedence over an already-loaded
 179      * version.
 180      *
 181      * We still want the system classes (e.g. java.lang.Object) from the
 182      * bootstrap class loader.
 183      */
 184     protected Class<?> loadClass(String name, boolean resolve)
 185         throws ClassNotFoundException
 186     {
 187         Class res;
 188
 189         /*
 190          * 1. Invoke findLoadedClass(String) to check if the class has
 191          * already been loaded.
 192          *
 193          * This doesn't change.
 194          */
 195         res = findLoadedClass(name);
 196         if (res != null) {
 197             System.out.println("FancyLoader.loadClass: "
 198                 + name + " already loaded");
 199             if (resolve)
 200                 resolveClass(res);
 201             return res;
 202         }
 203
 204         /*
 205          * 3. Invoke the findClass(String) method to find the class.
 206          */
 207         try {
 208             res = findClass(name);
 209             if (resolve)
 210                 resolveClass(res);
 211         }
 212         catch (ClassNotFoundException e) {
 213             // we couldn't find it, so eat the exception and keep going
 214         }
 215
 216         /*
 217          * 2. Invoke the loadClass method on the parent class loader.  If
 218          * the parent loader is null the class loader built-in to the
 219          * virtual machine is used, instead.
 220          *
 221          * (Since we're not in java.lang, we can't actually invoke the
 222          * parent's loadClass() method, but we passed our parent to the
 223          * super-class which can take care of it for us.)
 224          */
 225         res = super.loadClass(name, resolve);   // returns class or throws
 226         return res;
 227     }
 228 }