Lines Matching refs:is

25 - some classes need to be overridden, for example all the drawing code that is replaced by Java 2D
35 - generates a modified JAR file that is suitable for the Android plugin for Eclipse to perform
38 The ASM library is used to do the bytecode modification using its visitor pattern API.
40 The layoutlib_create is *NOT* generic. There is no configuration file. Instead all the configuration
41 is done in the main() method and the CreateInfo structure is expected to change with the Android
43 dependent is also present elsewhere in code.
45 The resulting JAR is used by layoutlib_bridge (a.k.a. "the bridge"), also part of the platform, that
61 The goal of the analyzer is to create a graph of all the classes from the input JAR with their
64 To do that, the analyzer is created with a list of base classes to keep -- everything that derives
65 from these is kept. Currently the one such class is android.view.View: since we want to render
66 layouts, anything that is sort of a view needs to be kept.
68 The analyzer is also given a list of class names to keep in the output. This is done using
70 ("*" does not matches dots whilst "**" does, and "." and "$" are interpreted as-is). In practice we
73 The analyzer is also given a list of classes to exclude. A fake implementation of these classes is
82 The output of the analyzer is a set of ASM ClassReader instances which are then fed to the
89 The generator is constructed from a CreateInfo struct that acts as a config file and lists:
101 The core method of the generator is transform(): it takes an input ASM ClassReader and modifies it
104 The first step of the transformation is to implement the method delegates.
106 The TransformClassAdapter is then used to process the potentially renamed class.  All protected or
107 private classes are market as public. All classes are made non-final. Interfaces are left as-is.
109 If a method has a return type that must be erased, the whole method is skipped.  Methods are also
110 changed from protected/private to public. The code of the methods is then kept as-is, except for
116 The next step of the transformation is changing the name of the class in case we requested the class
121 The class is then fed to RefactorClassAdapter which is like RenameClassAdapter but updates the
122 references in all classes. This is used to update the references of classes in the java package that
125 these (com.android.tools.layoutlib.java.*) is injected.
129 class was originally compiled with Java 7 (version 51). This is because we don't currently generate
134 ReplaceMethodCallsAdapter replaces calls to certain methods. This is different from the
137 This is useful for methods in the Java namespace where we cannot add delegates. The configuration
138 for this is not done through the CreateInfo class, but done in the ReplaceMethodAdapter.
142 these is:
158 This strategy is now obsolete and replaced by the method delegates.
171 This is the easiest: we currently inject the following classes:
180   added to the Dalvik VM for performance reasons. An implementation that is very close to the
181   original (which is at platform/libcore/luni/src/main/java/...) is injected. Since these classees
192 This strategy is now obsolete and replaced by the method delegates (See strategy 6- Method
202 An example will make this easier: android.graphics.Paint is the main drawing class that we need to
217 This is very similar to the Renaming classes except that it also updates the reference in all
218 classes. This is done for classes which are added to the Dalvik VM for performance reasons but are
219 not present in the Desktop VM. An implementation for these classes is also injected.
224 This is mostly an implementation detail of the bridge: in the Paint class mentioned above, some
226 all the original implementation is native.
235 This strategy is used to override method implementations. Given a method SomeClass.MethodName(), 1
237 a- A copy of the original method named SomeClass.MethodName_Original(). The content is the original
238 method as-is from the reader. This step is omitted if the method is native, since it has no Java
241 named SomeClass_Delegate.MethodName(). The implementation of this 'delegate' method is done in
244 The delegate method is a static method. If the original method is non-static, the delegate method
245 receives the original 'this' as its first argument. If the original method is an inner non-static