Merge commit '1b7cfbf722e00fb1ea858ba8e356c32ce4e92ec0'

# Conflicts:
#	PluginDemo/build.gradle
#	README.md
#	build.gradle
#	virtualapk-gradle-plugin/gradle.properties

Author: superqiaopu

AndroidStub/build.gradle

@@ -63,4 +63,6 @@ uploadArchives {
 
 dependencies {
     compile 'com.android.support:support-annotations:22.2.0'
+    compile 'com.android.databinding:library:1.3.1'
+    compile 'com.android.databinding:baseLibrary:3.0.0'
 }

AndroidStub/src/main/java/android/content/pm/PackageParser.java

@@ -377,6 +377,7 @@ public final static class Package {
 
         // Signatures that were read from the package.
         public Signature[] mSignatures;
+        public SigningDetails mSigningDetails;
         public Certificate[][] mCertificates;
 
         // For use by package manager service for quick lookup of
@@ -737,5 +738,9 @@ public PackageParserException(int error, String detailMessage, Throwable throwab
         }
 
     }
+    
+    public static class SigningDetails {
+        public Signature[] signatures;
+    }
 
 }

AndroidStub/src/main/java/android/databinding/DataBinderMapper.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.databinding;
+import android.view.View;
+/**
+ * This class will be stripped from the jar and then replaced by the annotation processor
+ * as part of the code generation step. This class's existence is just to ensure that
+ * compile works and no reflection is needed to access the generated class.
+ */
+class DataBinderMapper {
+    public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
+            int layoutId) {
+        return null;
+    }
+    ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View[] view, int layoutId) {
+        return null;
+    }
+    public int getLayoutId(String tag) { return 0; }
+    public String convertBrIdToString(int id) {
+        return null;
+    }
+    public static int TARGET_MIN_SDK = 0;
+}

AndroidStub/src/main/java/android/databinding/DataBindingComponent.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.databinding;
+/**
+ * This interface is generated during compilation to contain getters for all used instance
+ * BindingAdapters. When a BindingAdapter is an instance method, an instance of the class
+ * implementing the method must be instantiated. This interface will be generated with a getter
+ * for each class with the name get* where * is simple class name of the declaring BindingAdapter
+ * class/interface. Name collisions will be resolved by adding a numeric suffix to the getter.
+ * <p>
+ * An instance of this class may also be passed into static or instance BindingAdapters as the
+ * first parameter.
+ * <p>
+ * If you are using Dagger 2, you should extend this interface and annotate the extended interface
+ * as a Component.
+ */
+public interface DataBindingComponent {
+}

CoreLibrary/build.gradle

@@ -31,7 +31,6 @@ repositories {
 
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.android.support:appcompat-v7:22.2.0'
 
     provided project(':AndroidStub')
 

CoreLibrary/src/main/java/android/databinding/DataBinderMapperProxy.java

@@ -0,0 +1,122 @@
+package android.databinding;
+
+import android.support.annotation.NonNull;
+import android.util.Log;
+import android.view.View;
+
+import com.didi.virtualapk.PluginManager;
+import com.didi.virtualapk.internal.LoadedPlugin;
+
+import java.util.LinkedList;
+
+/**
+ * Replace {@link DataBindingUtil#sMapper}.
+ * Created by qiaopu on 2018/4/11.
+ */
+public class DataBinderMapperProxy extends DataBinderMapper implements PluginManager.Callback {
+    public static final String TAG = "DataBinderMapperProxy";
+    
+    private final LinkedList<DataBinderMapper> mMappers;
+    private DataBinderMapper[] mCache;
+    
+    public DataBinderMapperProxy(@NonNull Object source) {
+        mMappers = new LinkedList<>();
+    
+        addMapper((DataBinderMapper) source);
+    }
+    
+    @Override
+    public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view, int layoutId) {
+        ViewDataBinding viewDataBinding;
+    
+        for (DataBinderMapper mapper : getCache()) {
+            viewDataBinding = mapper.getDataBinder(bindingComponent, view, layoutId);
+            if (viewDataBinding != null) {
+//                Log.d(TAG, "Found by mapper: " + mapper);
+                return viewDataBinding;
+            }
+        }
+        
+        return null;
+    }
+    
+    @Override
+    ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View[] view, int layoutId) {
+        ViewDataBinding viewDataBinding;
+    
+        for (DataBinderMapper mapper : getCache()) {
+            viewDataBinding = mapper.getDataBinder(bindingComponent, view, layoutId);
+            if (viewDataBinding != null) {
+//                Log.d(TAG, "Found by mapper: " + mapper);
+                return viewDataBinding;
+            }
+        }
+    
+        return null;
+    }
+    
+    @Override
+    public int getLayoutId(String tag) {
+        int layoutId;
+    
+        for (DataBinderMapper mapper : getCache()) {
+            layoutId = mapper.getLayoutId(tag);
+            if (layoutId != 0) {
+//                Log.d(TAG, "Found by mapper: " + mapper);
+                return layoutId;
+            }
+        }
+    
+        return 0;
+    }
+    
+    @Override
+    public String convertBrIdToString(int id) {
+        String brId;
+    
+        for (DataBinderMapper mapper : getCache()) {
+            brId = mapper.convertBrIdToString(id);
+            if (brId != null) {
+//                Log.d(TAG, "Found by mapper: " + mapper);
+                return brId;
+            }
+        }
+    
+        return null;
+    }
+    
+    @Override
+    public void onAddedLoadedPlugin(LoadedPlugin plugin) {
+        try {
+            String clsName = "android.databinding.DataBinderMapper_" + plugin.getPackageName().replace('.', '_');
+            Log.d(TAG, "Try to find the class: " + clsName);
+            Class cls = Class.forName(clsName, true, plugin.getClassLoader());
+            Object obj = cls.newInstance();
+    
+            addMapper((DataBinderMapper) obj);
+            
+        } catch (Exception e) {
+            Log.w(TAG, e);
+        }
+    }
+    
+    private void addMapper(DataBinderMapper mapper) {
+        int size = 0;
+        synchronized (mMappers) {
+            mMappers.add(mapper);
+            mCache = null;
+            size = mMappers.size();
+        }
+    
+        Log.d(TAG, "Added mapper: " + mapper + ", size: " + size);
+    }
+    
+    private DataBinderMapper[] getCache() {
+        synchronized (mMappers) {
+            if (mCache == null) {
+                mCache = mMappers.toArray(new DataBinderMapper[mMappers.size()]);
+            }
+            return mCache;
+        }
+    }
+}

CoreLibrary/src/main/java/com/didi/virtualapk/PluginManager.java

@@ -28,6 +28,7 @@
 import android.content.Intent;
 import android.content.pm.ProviderInfo;
 import android.content.pm.ResolveInfo;
+import android.databinding.DataBinderMapperProxy;
 import android.net.Uri;
 import android.os.Build;
 import android.util.Log;
@@ -65,6 +66,7 @@ public class PluginManager {
     private Context mContext;
     private ComponentsHandler mComponentsHandler;
     private Map<String, LoadedPlugin> mPlugins = new ConcurrentHashMap<>();
+    private final List<Callback> mCallbacks = new ArrayList<>();
 
     private Instrumentation mInstrumentation; // Hooked instrumentation
     private IActivityManager mActivityManager; // Hooked IActivityManager binder
@@ -94,11 +96,8 @@ private PluginManager(Context context) {
     private void prepare() {
         Systems.sHostContext = getHostContext();
         this.hookInstrumentationAndHandler();
-        if (Build.VERSION.SDK_INT >= 26) {
-            this.hookAMSForO();
-        } else {
-            this.hookSystemServices();
-        }
+        this.hookSystemServices();
+        hookDataBindingUtil();
     }
 
     public void init() {
@@ -113,13 +112,42 @@ public void run() {
 
     private void doInWorkThread() {
     }
+    
+    private void hookDataBindingUtil() {
+        try {
+            Class cls = Class.forName("android.databinding.DataBindingUtil");
+            Object old = ReflectUtil.getField(cls, null, "sMapper");
+            Callback callback = new DataBinderMapperProxy(old);
+            ReflectUtil.setField(cls, null, "sMapper", callback);
+            
+            addCallback(callback);
+    
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    public void addCallback(Callback callback) {
+        if (callback == null) {
+            return;
+        }
+        synchronized (mCallbacks) {
+            mCallbacks.add(callback);
+        }
+    }
 
     /**
      * hookSystemServices, but need to compatible with Android O in future.
      */
     private void hookSystemServices() {
         try {
-            Singleton<IActivityManager> defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManagerNative.class, null, "gDefault");
+            Singleton<IActivityManager> defaultSingleton;
+    
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManager.class, null, "IActivityManagerSingleton");
+            } else {
+                defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManagerNative.class, null, "gDefault");
+            }
             IActivityManager activityManagerProxy = ActivityManagerProxy.newInstance(this, defaultSingleton.get());
 
             // Hook IActivityManager from ActivityManagerNative
@@ -133,17 +161,6 @@ private void hookSystemServices() {
         }
     }
 
-
-    private void hookAMSForO() {
-        try {
-            Singleton<IActivityManager> defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManager.class, null, "IActivityManagerSingleton");
-            IActivityManager activityManagerProxy = ActivityManagerProxy.newInstance(this, defaultSingleton.get());
-            ReflectUtil.setField(defaultSingleton.getClass().getSuperclass(), defaultSingleton, "mInstance", activityManagerProxy);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
     private void hookInstrumentationAndHandler() {
         try {
             Instrumentation baseInstrumentation = ReflectUtil.getInstrumentation(this.mContext);
@@ -219,6 +236,11 @@ public void loadPlugin(File apk) throws Exception {
         LoadedPlugin plugin = LoadedPlugin.create(this, this.mContext, apk);
         if (null != plugin) {
             this.mPlugins.put(plugin.getPackageName(), plugin);
+            synchronized (mCallbacks) {
+                for (int i = 0; i < mCallbacks.size(); i++) {
+                    mCallbacks.get(i).onAddedLoadedPlugin(plugin);
+                }
+            }
             // try to invoke plugin's application
             plugin.invokeApplication();
         } else {
@@ -357,4 +379,7 @@ public List<ResolveInfo> queryBroadcastReceivers(Intent intent, int flags) {
         return resolveInfos;
     }
 
+    public interface Callback {
+        void onAddedLoadedPlugin(LoadedPlugin plugin);
+    }
 }