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