FancyLoader.java revision a5a184892e60a89b564ca7c74e50b2ecb27d9f80 
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
17import java.io.File;
18import java.io.FileNotFoundException;
19import java.io.IOException;
20import java.io.RandomAccessFile;
21import java.lang.reflect.Constructor;
22import java.lang.reflect.Method;
23import 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 */
36public 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}
229