Three, AOP thought

The banking system will have a withdrawal process, we can put the process into a box, the other system will also have a balance of query process, we first put the two processes together, have found that the two are the same validation process, we ring them up to say again first, next ever think can reduce the user authentication code is extracted, That’s where AOP comes in. With AOP, you can write code that doesn’t include the authentication user step, that is, you don’t think about the authentication user at all.

• What is AOP: centralizing these capabilities, such as monitoring the performance of each method, across and embedded in many modules, into a single place to control and manage them
• What can it bring me: Don’t modify the source code to the program under the condition of the technique of dynamic unified add functionality, to pick up the scattered on the public portion of the program, make it cut class, so the advantage of reusable code, when it comes to the function requirement change, you can just modify the code, otherwise, you want to change, if as long as modified 1, 2) it can also accept, What if there are 1,000.

Iv. Piling entrance of Android packaging process

This is the whole process of app packaging process, which I divided into the following steps:

• Aapt to package resource files to generate r.java files
• Process the AIDL and generate the corresponding. Java interface file
• Compile the Java file to generate the corresponding.class file
• Convert the. Class file to the. Dex file supported by the Davik VM
• Package to generate unsigned. Apk files.

Bytecode peg entry: We know that Android programs from Java source code to executable Apk package analysis of the main two links:

• Javac: Compile the source file into a file in class format
• Dex: Collects class files into dex files

If we want to modify the bytecode, we only need to scan the class file after JavAC and before DEX, filter and modify it according to certain rules, so that the modified bytecode will be sent to APK in the subsequent DEX packaging process, which is our peg entry.

Piling method 1: Transform API

Each Transform is actually a Gradle Task. The TaskManager in the Android compiler concatenates each Transform. The first Transform receives the result from the Javac compilation. As well as third-party dependencies that have been pulled locally (jar.aar), and resource resources, note that the resource is not the RES resource in the Android project, but the asset directory. These compiled intermediates flow along a chain of transforms, and each Transform node can process the class and pass it on to the next Transform. Our common confusions, such as Desugar logic, are now implemented in a single Transform, and our custom Transform is inserted at the top of the Transform chain.

implementation 'com. Android. Tools. Build: gradle: 1.5.0'Copy the code

5. Customize Gradle plugin

Create an Android Library Module project

Build. Gradle: Groovy

apply plugin: 'groovy'

    dependencies {
        compile gradleApi()
        compile localGroovy()
    }Copy the code

Groovy extends Plugin and implements the apply method. Note that the class suffix is.groovy instead of.java

4. Create the Resources directory under main

5. Add the corresponding Maven Deployer to local or remote repositories

6. Use published repositories

Six, ASM

You can use a plugin [ASM Bytecode Outline] to write Bytecode in ASM more efficiently

ASM (Core API) accesses each part of a class file in sequence according to the class file structure in a visitor pattern. There are several important visitors.

Operation process

1. You need to create a ClassReader object that reads the contents of the.class file into a byte array
2. You then need a ClassWriter object to write back the byte array of the bytecode after the operation
3. An event filter ClassVisitor is required. A new XXXVisitor object is generated when some of the methods of ClassVisitor are called, and when we need to modify the corresponding content, we simply implement our own XXXVisitor and return

ClassReader class

This class reads the.class file into a byte array in ClassReader, and its Accept method takes a ClassVisitor implementation class and calls the methods in ClassVisitor in order

ClassWriter class

ClassWriter is a subclass of ClassVisitor that corresponds to ClassReader, which reads the.class file into a byte array, ClassWriter outputs the bytecode content of a modified class as a byte array.

ClassVisitor abstract class

• A fully qualified name is a “in a fully qualified name. /, for example:

  Class. Android widgets. AdapterView. OnItemClickListener fully qualified name: android/widget/AdapterView$OnItemClickListenerCopy the code

• 1. Type descriptors, as shown in the following figure:

In class files, type Boolean is described by “Z” and array is described by “[” (multi-dimensional arrays can be stacked), so what is the most common custom reference type? Android android.view. view class, descriptor is “Landroid/view/ view;”

2. The organizational structure of method descriptors is:

(Parameter type descriptor) Return value descriptor copies codeCopy the code

Void is replaced by “V”, for example:

Boolean onGroupClick(ExpandableListView parent, View V, int groupPosition, long ID)  (Landroid/widget/ExpandableListView; Landroid/view/View; IJ)ZCopy the code

Assume that the method to be modified is as follows:

public int test() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }}Copy the code

After modification, it needs to be changed to:

public int test() { long startTime = System.currentTimeMillis(); try { Thread.sleep(1000); } catch (InterruptedException e){ e.printStackTrace(); } long timing = System.currentTimeMillis() - startTime; BlockManager.timingPage(getLocalClassName(), timing); }Copy the code