分类：Android

dependencies {

    implementation 'com.squareup.leakcanary:leakcanary-android:1.5'

}

if(LeakCanary.isInAnalyzerProcess(this)){
    return ;
}

LeakCanary.install(this);

@MainThread

AS中创建AIDL文件的时候会报与.java文件名冲突。解决方法是先创建AIDL文件，后创建JAVA文件。

Glide: load drawable but don’t scale placeholder

<style name="">
    <item name="android:shadowColor">#7f000000</item>
    <item name="android:shadowDx">0</item>
    <item name="android:shadowDy">0</item>
    <item name="android:shadowRadius">5</item>
</style>

android:typeface="monospace"

TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 6, getResources().getDisplayMetrics());

View childView = createChildView(inflater, resources, BoothCenterItemData.defaultData[0]);
int widthMeasureSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
int heightMeasureSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
childView.measure(widthMeasureSpec, heightMeasureSpec);
int measuredHeight = childView.getMeasuredHeight();

public class BoothCenterAdapter extends PagerAdapter {
    private final List<BoothCenterItemView> itemViews;

    public BoothCenterAdapter(List<BoothCenterItemView> itemViews) {
        this.itemViews = itemViews;
    }

    @NonNull
    @Override
    public Object instantiateItem(@NonNull ViewGroup container, int position) {
        View view = itemViews.get(position);
        container.addView(view);
        return view;
    }

    @Override
    public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
        container.removeView((View) object);
    }

    @Override
    public int getCount() {
        return itemViews.size();
    }

    @Override
    public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
        return view == object;
    }
}

1、创建

keytool -genkey -keystore [签名文件]  -alias bieming -keyalg RSA -validity 10000

2、查看

keytool -list -keystore  [签名文件]

注：当密码中有特殊符号时：keytool -list -v -keystore android.keystore -storepass ‘112&He’

3、修改别名

keytool -changealias -keystore android.keystore -alias [当前别名] -destalias [新别名]

android:fillViewport=“true” 解决

<ScrollView
android:layout_width=”match_parent”
android:layout_height=”match_parent”
android:fillViewport=”true”
android:scrollbars=”none” >

1、在Edittext中加入以下属性
android:cursorVisible=”true”
android:textCursorDrawable=”@null”

2、在Edittext中加入以下属性
android:cursorVisible=”true”
android:textCursorDrawable=”@drawable/test_cursor”

对应的drawable文件

3、如果以上没有效果就请用这个

明确指定EditText的inputType属性值inputType属性中的textCapSentences
不要用这个，国内手机好像没有用到这个，个人证实而已，用text或者textMultiLine
android:inputType=”text|textMultiLine”

1.自定义Drawable，绘制“原创”文本字符串

public class LabelDrawable extends Drawable {
    private String tag;
    private Paint paint;
    private String labelText;
    private float textSize;
    private float labelWidth;
    private float labelHeight;
    private float leftPadding;
    private float rightPadding;
    private float labelLeftRightPadding;
    private float labelTopBottomPadding;
    private float borderWidth;
    private float round;

    private float strokeWidth;

    public LabelDrawable(String tag, String labelText, float textSize) {
        this.tag = tag;
        this.labelText = labelText;
        this.textSize = textSize;
        this.paint = new Paint();
        this.paint.setColor(0xffff6f00);
        this.paint.setAntiAlias(true);

        this.paint.setTextSize(textSize);
        this.labelWidth = this.paint.measureText(labelText);
        this.labelHeight = this.paint.descent() - this.paint.ascent();

        this.strokeWidth = this.paint.getStrokeWidth();
    }

    public void setLeftPadding(float leftPadding) {
        this.leftPadding = leftPadding;
    }

    public void setRightPadding(float rightPadding) {
        this.rightPadding = rightPadding;
    }

    public void setLabelLeftRightPadding(float labelLeftRightPadding) {
        this.labelLeftRightPadding = labelLeftRightPadding;
    }

    public void setLabelTopBottomPadding(float labelTopBottomPadding) {
        this.labelTopBottomPadding = labelTopBottomPadding;
    }

    public void setBorderWidth(float borderWidth) {
        this.borderWidth = borderWidth;
    }

    public void setRound(float round) {
        this.round = round;
    }

    @Override
    public void draw(@NonNull Canvas canvas) {
        Rect bounds = getBounds();
        Log.w("zzh", tag + " bounds:" + bounds);

        Paint.FontMetrics fontMetrics = this.paint.getFontMetrics();

        float x = bounds.left + leftPadding + borderWidth + labelLeftRightPadding;
        float y = bounds.top + borderWidth + labelTopBottomPadding + Math.abs(fontMetrics.ascent);// - fontMetrics.descent;
        Log.w("zzh", tag + " x:" + x + " y:" + y);

        paint.setTextSize(textSize);
        paint.setStyle(Paint.Style.FILL);
        paint.setStrokeWidth(this.strokeWidth);
        canvas.drawText(labelText, x, y, paint);

        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeWidth(borderWidth);

        RectF borderRect = new RectF();
        borderRect.left     = bounds.left + leftPadding;
        borderRect.top      = bounds.top + labelTopBottomPadding;
        borderRect.right    = bounds.right - rightPadding;
        borderRect.bottom   = bounds.bottom - labelTopBottomPadding;

        canvas.drawRoundRect(borderRect, round, round, paint);

        Log.w("zzh", tag + " bounds:" + borderRect);
    }

    @Override
    public void setAlpha(int alpha) {
        this.paint.setAlpha(alpha);
    }

    @Override
    public void setColorFilter(@Nullable ColorFilter colorFilter) {

    }

    @Override
    public int getOpacity() {
        return PixelFormat.TRANSLUCENT;
    }

    // 固有的大小
    @Override
    public int getIntrinsicHeight() {
        return (int) (borderWidth + labelTopBottomPadding + labelHeight + labelTopBottomPadding + borderWidth);
    }

    @Override
    public int getIntrinsicWidth() {
        return (int) (leftPadding + borderWidth + labelLeftRightPadding
                + labelWidth +
                labelLeftRightPadding + borderWidth + rightPadding);
    }
}

2、调整Drawable和文本的对齐

public class CenterAlignImageSpan extends ImageSpan {

    public CenterAlignImageSpan(Drawable drawable) {
        super(drawable);
    }

    @Override
    public void draw(@NonNull Canvas canvas, CharSequence text, int start, int end, float x, int top, int y, int bottom,
                     @NonNull Paint paint) {
        Drawable b = getDrawable();
        Paint.FontMetricsInt fm = paint.getFontMetricsInt();
        int transY = (y + fm.descent + y + fm.ascent) / 2 - b.getBounds().bottom / 2;//计算y方向的位移
        canvas.save();
        canvas.translate(x, transY);//绘制图片位移一段距离
        b.draw(canvas);
        canvas.restore();
    }
}

3、写个帮助类，协调各类

public class LabelTextViewHelper{
    private TextView textView;
    private final float textSize;
    private final float leftPadding;
    private final float rightPadding;
    private final float borderWidth;
    private final float round;
    private final float labelLeftRightPadding;
    private final float labelTopBottomPadding;

    public LabelTextViewHelper(@NonNull TextView textView) {
        this.textView = textView;

        DisplayMetrics displayMetrics = textView.getResources().getDisplayMetrics();

        textSize        = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 13, displayMetrics);
        leftPadding     = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1, displayMetrics);
        rightPadding    = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 8, displayMetrics);
        borderWidth     = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1, displayMetrics);
        round           = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 2, displayMetrics);
        labelLeftRightPadding = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 6, displayMetrics);
        labelTopBottomPadding = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 4, displayMetrics);
    }

    public void setLabelAndText(@NonNull String label, @NonNull String text){
        SpannableString sp = new SpannableString(label + text);

        //获取一张图片
        LabelDrawable drawable = new LabelDrawable("TextView", label, textSize);
        drawable.setLeftPadding(leftPadding);
        drawable.setRightPadding(rightPadding);
        drawable.setLabelLeftRightPadding(labelLeftRightPadding);
        drawable.setLabelTopBottomPadding(labelTopBottomPadding);
        drawable.setBorderWidth(borderWidth);
        drawable.setRound(round);
        drawable.setBounds(0, 0, drawable.getMinimumWidth(), drawable.getMinimumHeight());

        //居中对齐imageSpan
        ImageSpan imageSpan = new CenterAlignImageSpan(drawable);
        sp.setSpan(imageSpan, 0, label.length(), ImageSpan.ALIGN_BASELINE);

        textView.setText(sp);
    }
}

4、实际使用

String labelText = "原创";

TextView textView = findViewById(R.id.main_txt);
textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, 18);
LabelTextViewHelper helper = new LabelTextViewHelper(textView);
helper.setLabelAndText(labelText, "10个高效的有氧减肥动作，快速瘦成一道闪电");

一、解析插件Apk

DLPluginManager pluginManager = DLPluginManager.getInstance(BaseApplication.getInstance());

DLPluginPackage pluginPackage = pluginManager.loadApk(pluginApkPath);
DLIntent intent = new DLIntent(pluginPackage.packageName, pluginPackage.defaultActivity);

pluginManager.startPluginActivity(this, intent);

1、loadApk方法

public DLPluginPackage loadApk(final String dexPath, boolean hasSoLib){
    mFrom = DLConstants.From_external;
    
    int packageInfoFlags = PackageManager.Get_activities | PackageManager.Get_services;
    PackageInfo packageInfo = mContext.getPackageManager().getPackageArchiveInfo(dexPath, packageInfoFlags);
    if(packageInfo == null) return null;

    DLPluginPackage pluginPackage = preparePluginEnv(packageInfo, dexPath);
    if(hasSoLib){
        copySoLib(dexPath);
    }

    return pluginPackage;
}

2、preparePluginEnv方法

private DLPluginPackage preparePluginEnv(PackageInfo packageInfo, String dexPath){
    DLPluginPackage pluginPackage = mPackagesHolder.get(packageInfo.packageName);
    if(pluginPackage != null) return pluginPackage;

    DexClassLoader dexClassLoader = createDexClassLoader(dexPath);
    AssetManager assetManager = createAssetManager(dexPath);
    Resources resources = createResources(assetManager);

    // create PluginPackage
    pluginPackage = new DLPluginPackage(dexClassLoader, resources, packageInfo);
    mPackageHolder.put(packageInfo.packageName, pluginPackage);

    return pluginPackage;
}

private DexClassLoader createDexClassLoader(String dexPath){
    File dexOutputDir = mContext.getDir("dex", Context.Mode_private);
    dexOutputPath = dexOutputDir.getAbsolutePath();

    DexClassLoader loader = new DexClassLoader(
        dexPath,
        dexOutputPaht,
        mNativeLibDir,
        mContext.getClassLoader()
    );

    return loader;
}

private AssetManager createAssetManager(String dexPath){
    try{
        AssetManager assetManager = AssetManager.class.newInstance();
        Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
        addAssetPath.invoke(assetManager, dexPath);
        return assetManager;
    }catch(Exception e){}
}

private Resources createResources(AssetManager assetManager){
    Resources superRes = mContext.getResources();
    Resources resources = new Resources(
        assetManager,
        superRes.getDisplayMetrics(),
        superRes.getConfiguration()
    );

    return resources;
}

二、运行插件Apk

启动代理的Activity，分别可以：在DLPluginManager里调用startPluginActivityForResult（一般宿主使用），还可以在DLPluginActivity里使用startPluginActivity（在插件里使用）。

DLIntent intent = new DLIntent(getPackageName(), SecondActivity.class);
startPluginActivity(intent);

上面是调用Activity方法，再往下看：

public int startPluginActivity(DLIntent dlIntent){
    return startPluginActivityForResult(dlIntent, -1);
}

/** @return may be 
    {@link #Start_result_success}, 
    {@link #Start_result_no_pkg},  
    {@link #Start_result_no_class}, 
    {@link #Start_result_type_error} */
public int startPluginActivityForResult(DLIntent dlIntent, int requestCode){
    if(mFrom == DLConstants.From_external){
        if(dlIntent.getPluginPackage() == null){
            dlIntent.setPluginPackage(mPluginPackage.packageName);
        }
    }

    return mPluginManager.startPluginActivityForResult(that, dlIntent, requestCode);
}

之后交给PluginManager启动Activity：

public int startPluginActivityForResult(Context context, DLIntent dlIntent, int requestCode){
    if(mFrom == DLConstants.From_internal){
        dlIntent.setClassName(context, dlIntent.getPluginClass());
        preformStartActivityForResult(context, dlIntent, requestCode);
        return DLPluginManager.Start_result_success;
    }

    String packageName = dlIntent.getPluginPackage();
    if(TextUtils.isEmpty(packageName)){
        throw new NullPointerException("disallow null packageName.");
    }

    DLPluginPackage pluginPackage = mPackageHolder.get(packageName);
    if(pluginPackage == null){
        return Start_result_no_pkg;
    }

    final String className = getPluginActivityFullPath(dlIntent, pluginPackage);
    Class<?> clazz = loadPluginClass(pluginPackage.classLoader, className);
    if(clazz == null){
        return Start_result_no_class;
    }

    Class<? extends Activity> activityClass = getProxyActivityClass(clazz);
    if(activityClass == null){
        return Start_result_type_error;
    }

    dlIntent.putExtra(DLConstants.Extra_class, className);
    dlIntent.putExtra(DLConstants.Extra_package, packageName);
    dlIntent.setClass(mContext, activityClass);
    performStartActivityForResult(context, dlIntent, requestCode);
    return Start_result_success;
}

先进行一些判断，然后获取要启动的Activity的全称，然后通过函数loadPluginClass()利用反射获取插件实例activityClass

函数loadPluginClass：

private Class<?> loadPluginClass(ClassLoader classLoader, String className){
    Class<?> clazz = null;
    try{
        clazz = Class.forName(className, true, classLoader);
    }catch(ClassNotFoundException e){}
    return clazz;
}

通过函数getProxyActivityClass(),根据插件实例获取它对应在宿主里对应的代理类：

private Class<? extends Activity> getProxyActivityClass(Class<?> clazz){
    Class<? extends Activity> activityClass = null;
    if(DLBasePluginActivity.class.isAssignableFrom(clazz)){
        activityClass = DLProxyActivity.class;
    }else if(DLBasePluginFragmentActivity.class.isAssignableFrom(clazz)){
        activityClass = DLProxyFragmentActivity.class;
    }else if(Activity.class.isAssignableFrom(clazz)){
        activityClass = Activity.class;
    }
    return activityClass;
}

当这一步基本上完成偷天换柱的任务，表面上要启动的是插件类，其实启动的是一个宿主代理类。
在把插件包名和要启动的插件类名放到Intent中，传递一个代理类，最后直接启动代理Activity就好了。

private void performStartActivityForResult(Context context, DLIntent dlIntent, int requestCode){
    if(context instanceof Activity){
        ((Activity)context).startActivityForResult(dlIntent, requestCode);
    }else{
        context.startActivity(dlIntent);
    }
}

三、通过代理类运行插件类

在这里分析DLProxyActivity，经前面分析，已经启动了代理类，当然就执行到代理类的onCreate了：

protected DLPlugin mRemoteActivity;
private DLProxyImpl impl = new DLProxyImpl(this);

@Override
protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    impl.onCreate(getIntent());
}

接着流程就跑到DLProxyImpl类的onCreate()方法中：

public void onCreate(Intent intent){
    intent.setExtrasClassLoader(DLConfigs.sPluginClassLoader);

    mPackageName = intent.getStringExtra(DLConstants.Extra_package);
    mClass = intent.getStringExtra(DLConstants.Extra_class);

    mPluginManager = DLPluginManager.getInstance(mProxyActivity);
    mPluginPackage = mPluginManager.getPackage(mPackageName);
    mAssetManager = mPluginPackage.assetManager;
    mResources = mPluginPackage.resources;

    initializeActivityInfo();
    handleActivityInfo();
    launchTargetActivity();
}

1、在initializeActivityInfo()之前是获取intent传递过来的插件包名、插件类，并根据它们获取插件信息PluginPackage
2、PluginPackage里面存放了插件的resource和assetManager
3、initializeActivityInfo()和handleActivityInfo()主要是进行一些主题处理
4、重点在launchTargetActivity()方法，初始化插件类

protected void launchTargetActivity(){
    try{
        Class<?> localClass = getClassLoader().loadClass(mClass);
        Constructor<?> localConstructor = localClass.getConstructor(new Class[]{});
        Object instance = localConstructor.newInstance(new Object[]{});
        mPluginActivity = (DLPlugin)instance;

        ((DLAttachable)mProxyActivity).attach(mPluginActivity, mPluginManager);
        mPluginActivity.attach(mProxyActivity, mPluginPackage);

        Bundle bundle = new Bundle();
        bundle.putInt(DLConstants.From, DLConstants.From_external);
        mPluginActivity.onCreate(bundle);
    }catch(Exception e){}
}

创建好了代理类对象和插件类对象，就需要通过两个attach()方法将它们绑定在一起。

第一个是代理类的attach()方法：

public void attach(DLPlugin remoteActivity, DLPluginManager pluginManager){
    mRemoteActivity = remoteActivity;
}

第二个是插件类的attach()方法：

public void attach(Activity proxyActivity, DLPluginPackage pluginPackage){
    mProxyActivity = proxyActivity;
    that = mProxyActivity;
    mPluginPackage = pluginPackage;
}

可以看到插件类里的that被赋值了代理类对象，所以在编写插件代码的时候this的功能将被废弃,不能使用this，必须使用that

代码结构：

一、internal包

1、DLAttachable接口：

public void attach(DLPlugin proxyActivity, DLPluginManager pluginManager)

当代理启动插件的Activity，DL将会调用attach方法将代理Activity与插件管理器连接到插件Activity中，插件Activity将会加载插件的资源，所以代理Activity是插件内部的Activity的一个资源托管。

2、DLIntent：

Intent的子类，内部包含两个变量：1) 需要启动的插件的包名以，2) 需要启动的插件类名

3、DLPluginManager：

主要功能：获取Dex，启动服务，停止服务，绑定服务，解绑服务，启动Activity，加载指定class名的class，拷贝so文件等

START_RESULT_SUCCESS：插件启动成功
START_RESULT_NO_PKG  ：没找到指定的包名的插件
START_RESULT_NO_CLASS：没找到需要启动的插件类
START_RESULT_TYPE_ERROR：

4、DLPluginPackage:

指定一个插件Apk。在相同的apk中的一系列的Activities共享的AssetManager、Resources以及DexClassLoader。

包含：
1）插件的完整包名
2）默认的Activity的名称
3）Dex类加载器
4）AssetManager对象
5）资源Resources对象
6）包的相关描述对象PackageInfo对象

5、DLProxyImpl:

是一个插件Activity的代理，代理将会利用反射创建插件Activity，并同时调用插件Activity的attach以及onCreate的方法，此时插件Activity就处于运行的状态了。

1）String mClass：当前插件Activity的类名
2）String mPackageName：当前插件Activity的包名
3）DLPluginPackage mPluginPackage：标识当前的插件Apk的对象
4）DLPluginManage mPluginManager：插件管理器
5）AssetManager mAssetManager：Asset管理器
6）Resources mResources：资源管理器
7）Theme mTheme：主题对象
8）ActivityInfo mActivityInfo：描述当前的插件Activity的相关的信息对象
9）Activity mProxyActivity：代理Activity对象
10）DLPlugin mPluginActivity：插件的接口
11）ClassLoader mPluginClassLoader：类加载器

6、DLServiceAttachable:

与DLAttachable的功能是类似的，只不过一个是针对Activity，一个是针对Service。

7、DLServiceProxyImpl：

1）利用类加载器加载指定的插件内部的服务名称，实际上是利用反射创建对象
2) 将插件内部的Service对象绑定到代理Service对象上
3）直接调用插件Service的onCreate的方法

二、dynamicload包

1、DLBasePluginActivity、DLBasePluginFragmentActivity

1、Activity mProxyActivity：Activity代理是真正运行中的Activity
2、Activity that：等同mProxyActivity
3、DLPluginManager mPluginManager：插件管理器
4、DLPluginPackage mPluginPackage：插件的包名

职责：
1、代理Activity的赋值
2、指向插件Apk对象的本身
3、类似onCreate、setContentView等Activity相关方法，判断是内部启动还是外部启动，如果是内部启动，完全可以不需要代理Activity的处理
4、凡是调用了onAttach，均是属于外部的启动

2、DLPlugin：

这是一个插件开发的接口：

public void onCreate(Bundle savedInstanceState);
public void onStart();
public void onRestart();
public void onActivityResult(int requestCode, int resultCode, Intent data);
public void onResume();
public void onPause();
public void onStop();
public void onDestroy();
public void attach(Activity proxyActivity, DLPluginPackage pluginPackage);
public void onSaveInstanceState(Bundle outState);
public void onNewIntent(Intent intent);
public void onRestoreInstanceState(Bundle savedInstanceState);
public boolean onTouchEvent(MotionEvent event);
public boolean onKeyUp(int keyCode, KeyEvent event);
public void onWindowAttributesChanged(LayoutParams params);
public void onWindowFocusChanged(boolean hasFocus);
public void onBackPressed();
public boolean onCreateOptionsMenu(Menu menu);
public boolean onOptionsItemSelected(MenuItem item);

3、DLProxyActivity、DLProxyFragmentActivity：

插件Activity的代理类。其中的主要成员变量：

1、DLPlugin：指向插件对象
2、DLProxyImpl：指向代理的实现对象

4、DLProxyService

Service代理服务

5、DLServicePlugin

一个接口，包括Service的关键性的方法。

三、util包

1、DLConfigs：

存储与获取so的修改时间

2、DLConstants:

在这个常量类中，主要配置下面几大类常量：

1、内部启动还是外部启动
2、Dex路径以及相关的包名，存储的Tag
3、Activity的相关类型
4、CPU相关的体系结构

3、DLUtils:

这个工具类包含以下功能：

1、获取在SDcard目录下指定插件Apk文件的包名getPackageInfo
2、获取在SDcard目录下指定插件Apk文件的应用图标getAppIcon
3、获取在SDcard目录下指定插件Apk文件的应用名称getAppLabel
4、利用反射机制获取指定的插件Activity中的类型

4、SoLibManager

1、获取CPU相关信息
2、在线程中将插件的so文件拷贝到当前工程目录的so文件的目录文件夹中（根据当前的cpu体系结构，拷贝合适的so文件）