2019年12月 – 77博园

RxJava的map

map的作用：对Observable发射的数据都应用一个函数，然后再发射最后的结果集。最后map()方法返回一个新的Observable。

举个例子：

        final List<Integer> list = new ArrayList<Integer>() {
            {
                add(0);
                add(1);
                add(2);
            }
        };
        Observable.fromIterable(list).map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer + 1;
            }
        }).toList().map(new Function<List<Integer>, List<Integer>>() {

            @Override
            public List<Integer> apply(List<Integer> integers) throws Exception {
                List<Integer> listInteger = new ArrayList<>();
                listInteger.add(4);
                return listInteger;
            }
        })
                .toObservable().subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d(TAG, o.toString());
                    }
                });

final List<Integer> list = new ArrayList<Integer>() {

{

add(0);

add(1);

add(2);

}

};

Observable.fromIterable(list).map(new Function<Integer, Integer>() {

@Override

public Integer apply(Integer integer) throws Exception {

return integer + 1;

}

}).toList().map(new Function<List<Integer>, List<Integer>>() {

@Override

public List<Integer> apply(List<Integer> integers) throws Exception {

List<Integer> listInteger = new ArrayList<>();

listInteger.add(4);

return listInteger;

}

})

.toObservable().subscribeOn(Schedulers.io())

.subscribeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Object o) throws Exception {

Log.d(TAG, o.toString());

}

});

首先遍历集合中的每一个项，然后给map进行映射更改，每一项都加一，然后再转换为集合，然后再将该集合传入map中，在map中加入新的项4，最后给观察者的回调方法，输出该集合。

打印的log为：

12-23 21:46:36.691 3072-3102/com.status.rxjavasample D/RxJavaHelper: [4]

中间可以有多个map操作符。

.map(new Function<Integer, Integer>(){}中的Function里面的泛型参数，第一个是指输入的类型，第二个是指输出的类型。

再看下面这个例子：

     final List<Integer> list = new ArrayList<Integer>() {
            {
                add(0);
                add(1);
                add(2);
            }
        };
        Observable.fromIterable(list).map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer + 1;
            }
        }).subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d(TAG, o.toString());
                    }
                });

final List<Integer> list = new ArrayList<Integer>() {

{

add(0);

add(1);

add(2);

}

};

Observable.fromIterable(list).map(new Function<Integer, Integer>() {

@Override

public Integer apply(Integer integer) throws Exception {

return integer + 1;

}

}).subscribeOn(Schedulers.io())

.subscribeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Object o) throws Exception {

Log.d(TAG, o.toString());

}

});

输出的log为：

12-30 21:45:25.713 32565-32611/com.status.rxjavasample D/RxJavaHelper: 1
12-30 21:45:25.713 32565-32611/com.status.rxjavasample D/RxJavaHelper: 2
12-30 21:45:25.713 32565-32611/com.status.rxjavasample D/RxJavaHelper: 3

RxJava的concat操作符

转载请标明出处，维权必究：http://77blogs.com/?p=170

使用场景一：

现在要执行两个任务：

1、输出字符串0

2、输出字符串1

我们就可以使用concat来实现多个数据源。

1、输出字符串0的数据源：

        Observable observableLocal = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("0");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());

Observable observableLocal = Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(ObservableEmitter emitter) throws Exception {

emitter.onNext("0");

emitter.onComplete();

}

}).subscribeOn(Schedulers.io());

2、输出字符串1的数据源：

        Observable observableNet = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("1");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());

Observable observableNet = Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(ObservableEmitter emitter) throws Exception {

emitter.onNext("1");

emitter.onComplete();

}

}).subscribeOn(Schedulers.io());

3、接收多个数据源：

        Observable.concat(observableLocal, observableNet)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d(TAG, (String) o);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG, throwable.getMessage());
                    }
                });
    }

Observable.concat(observableLocal, observableNet)

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Object o) throws Exception {

Log.d(TAG, (String) o);

}

}, new Consumer<Throwable>() {

@Override

public void accept(Throwable throwable) throws Exception {

Log.d(TAG, throwable.getMessage());

}

});

}

可以看到Log：

12-23 20:23:48.771 23643-23643/com.status.rxjavasample D/RxJavaHelper: 0
12-23 20:23:48.771 23643-23643/com.status.rxjavasample D/RxJavaHelper: 1

两个字符串都输出了，而且是有序的。

使用场景二、

获取数据，如果从本地缓存中获取得到数据，那么便不从网络获取，否则从网络获取。

我们将上面的1,2两个步骤分别当成从本地缓存获取数据和从网络缓存中获取数据，那么我们需要改变上面的3步骤。

        Observable.concat(observableLocal, observableNet)
                .firstElement()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d(TAG, (String) o);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG, throwable.getMessage());
                    }
                });
    }

Observable.concat(observableLocal, observableNet)

.firstElement()

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Object o) throws Exception {

Log.d(TAG, (String) o);

}

}, new Consumer<Throwable>() {

@Override

public void accept(Throwable throwable) throws Exception {

Log.d(TAG, throwable.getMessage());

}

});

}

唯一不同的是加上.firstElement()。

输出的log为：

12-23 20:29:11.731 24458-24458/com.status.rxjavasample D/RxJavaHelper: 0

firstElement操作符:按照顺序依次遍历被观察者中事件，事件不为空，则停止遍历。

RxJava基本使用

转载请标明出处：http://77blogs.com/?p=162

RxJava究竟是啥，从根本上来讲，它就是一个实现异步操作的库，并且能够使代码非常简洁。它的异步是使用观察者模式来实现的。

关于观察者模式的介绍，可以看我这一篇文章：

https://www.cnblogs.com/tangZH/p/11175120.html

这里我主要讲RxJava的一些基本用法，基本案例，原理的话暂时不深究：

一、自己构造事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter emitter) {
                int i = getNumber();
                if (i < 0) {
                    emitter.onComplete();
                    return;
                } else {
                    Log.d(TAG, Thread.currentThread().getName());
                    emitter.onNext(i);
                    emitter.onComplete();
                }
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, Thread.currentThread().getName());
                        Log.d(TAG, integer + "");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                });

Observable.create(new ObservableOnSubscribe<Integer>() {

@Override

public void subscribe(ObservableEmitter emitter) {

int i = getNumber();

if (i < 0) {

emitter.onComplete();

return;

} else {

Log.d(TAG, Thread.currentThread().getName());

emitter.onNext(i);

emitter.onComplete();

}

})

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer<Integer>() {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, Thread.currentThread().getName());

Log.d(TAG, integer + "");

}

}, new Consumer<Throwable>() {

@Override

public void accept(Throwable throwable) throws Exception {

}

});

RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

onNext():方法用来发送事件。

下面看看其他两个方法：

onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

讲一下我们上面的例子，上面这个例子是采用简洁的链式调用来写的：

首先使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则，然后通过emitter.onNext(i)传递出来，.subscribeOn(Schedulers.io())便是指定该事件产生的所在的线程为子线程，.observeOn(AndroidSchedulers.mainThread())指定观察者执行的线程为主线程。这时候为止返回的对象为Observable对象。

然后该Observable对象subscribe绑定观察者（也就是观察者进行订阅），里面有接收被观察者发出来的事件，有一个成功的方法，和一个失败的方法，这样就实现了由被观察者向观察传递事件。

二、对集合里的数据进行变换

        List<Integer> list = new ArrayList<Integer>() {
            {
                add(0);
                add(1);
                add(2);
            }
        };
        Observable.fromIterable(list).map(new Function() {
            @Override
            public Object apply(Object o) throws Exception {
                int i = (int) o + 1;
                return String.valueOf(i);
            }
        })
                .toList()
                .toObservable().subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        Log.d(TAG, o.toString());
                    }
                });

List<Integer> list = new ArrayList<Integer>() {

{

add(0);

add(1);

add(2);

}

};

Observable.fromIterable(list).map(new Function() {

@Override

public Object apply(Object o) throws Exception {

int i = (int) o + 1;

return String.valueOf(i);

}

})

.toList()

.toObservable().subscribeOn(Schedulers.io())

.subscribeOn(AndroidSchedulers.mainThread())

.subscribe(new Consumer() {

@Override

public void accept(Object o) throws Exception {

Log.d(TAG, o.toString());

}

});

且看，我们需要对某个集合里面的数据一一进行变换，然后发送出来执行其他操作。

上面便是对集合里面的每一项进行加一操作，然后再转换为String类型，然后toList()，组合成集合发送出来，最后在观察者方法中打印出每一项。

三、合并执行

定义两个被观察者，各自产生事件，然后合并在一起，发送给一个观察者。

首先定义我们上面第一个例子的被观察者，用于发送一个数字：

        Observable observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter emitter) {
                int i = getNumber();
                if (i < 0) {
                    emitter.onComplete();
                    return;
                } else {
                    Log.d(TAG, Thread.currentThread().getName());
                    emitter.onNext(i);
                    emitter.onComplete();
                }
            }
        })
                .subscribeOn(Schedulers.io());

Observable observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {

@Override

public void subscribe(ObservableEmitter emitter) {

int i = getNumber();

if (i < 0) {

emitter.onComplete();

return;

} else {

Log.d(TAG, Thread.currentThread().getName());

emitter.onNext(i);

emitter.onComplete();

}

})

.subscribeOn(Schedulers.io());

其次再定义我们上面第二个例子的被观察者：

        List<Integer> list = new ArrayList<Integer>() {
            {
                add(0);
                add(1);
                add(2);
            }
        };
        Observable observable2 = Observable.fromIterable(list).map(new Function() {
            @Override
            public Object apply(Object o) {
                int i = (int) o + 1;
                return String.valueOf(i);
            }
        })
                .toList()
                .toObservable().subscribeOn(Schedulers.io());

List<Integer> list = new ArrayList<Integer>() {

{

add(0);

add(1);

add(2);

}

};

Observable observable2 = Observable.fromIterable(list).map(new Function() {

@Override

public Object apply(Object o) {

int i = (int) o + 1;

return String.valueOf(i);

}

})

.toList()

.toObservable().subscribeOn(Schedulers.io());

最后将这两个被观察者的事件合并起来发送给一个观察者：

        Disposable disposable = Observable.zip(observable1, observable2, new BiFunction() {
            @Override
            public Object apply(Object o, Object o2) throws Exception {
                int i = (int) o;
                String k = (String) ((List) o2).get(0);
                return k + i;
            }
        })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) {
                        Log.d(TAG, (String) o);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) {
                        Log.d(TAG, throwable.getMessage());
                    }
                });

Disposable disposable = Observable.zip(observable1, observable2, new BiFunction() {

@Override

public Object apply(Object o, Object o2) throws Exception {

int i = (int) o;

String k = (String) ((List) o2).get(0);

return k + i;

}

})

.subscribe(new Consumer() {

@Override

public void accept(Object o) {

Log.d(TAG, (String) o);

}

}, new Consumer<Throwable>() {

@Override

public void accept(Throwable throwable) {

Log.d(TAG, throwable.getMessage());

}

});

zip方法，顾名思义，有点类似与于打包的意思。

o为被观察者1返回的结果，o2为被观察2返回的结果，将这两个结果一起处理后发送给观察者。打印出来。

现在先介绍这几个，找个时间再整理一些其他的用法以及原理实现。

Android签名机制

装载请标明出处，维权必究：http://77blogs.com/?p=274

首先我们在as中双击apk，出现apk的分析界面，然后选中保存签名相关文件的文件夹：

一：签名文件：

1、MANIFEST.MF：保存了所有其他文件的SHA-1并base64编码后的值

2、CERT.SF：

SHA1-Digest-Manifest的值，这个值就是MANIFEST.MF文件的SHA-1并base64编码后的值。

后面几项的值是对MANIFEST.MF文件中的每项再次SHA1并base64编码后的值。

将上一个文件的某一项取出，比如：

Name: assets/BookCategoryConfig

SHA1-Digest: u5YLUiucukHRhO/xAqnzbnCb6cU=

加两个\r\n，保存文件，再SHA1并base64编码便可得到。

3、CERT.RSA：

包含了公钥信息和发布机构信息。它把之前生成的 CERT.SF文件，用私钥计算出签名, 然后将签名以及包含公钥信息的数字证书一同写入 CERT.RSA 中保存。CERT.RSA是一个满足PKCS7格式的文件。

Name”属性，其值就是该文件在apk包中的路径。

二、签名过程

CERT.RSA文件生成：

它会把前面生成的 CERT.SF文件用私钥计算出签名, 然后将签名以及包含公钥信息的数字证书一同写入 CERT.RSA 中保存。CERT.RSA是一个满足PKCS7格式的文件。

三、APK安装校验过程

1、通过在CERT.RSA文件中记录的签名信息，验证了CERT.SF没有被篡改过

RSA是一种非对称加密算法。用私钥通过RSA算法对摘要信息进行加密。在安装时只能使用公钥才能解密它。解密之后，将它与未加密的摘要信息进行对比，如果相符，则表明内容没有被异常修改。

2、通过CERT.SF文件中记录的摘要值，验证了MANIFEST.MF没有被修改过

3、apk内文件的摘要值要与MANIFEST.MF文件中记录的一致

这里简单介绍下SHA1数字签名。简单地说，它就是一种安全哈希算法，类似于MD5算法。它把任意长度的输入，通过散列算法变成固定长度的输出（这里我们称作“摘要信息”）。你不能仅通过这个摘要信息复原原来的信息。另外，它保证不同信息的摘要信息彼此不同。因此，如果你改变了apk包中的文件，那么在apk安装校验时，改变后的文件摘要信息与MANIFEST.MF的检验信息不同，于是程序就不能成功安装。

1、 Android签名机制其实是对APK包完整性和发布机构唯一性的一种校验机制。

2、 Android签名机制不能阻止APK包被修改，但修改后的再签名无法与原先的签名保持一致。（拥有私钥的情况除外）。

3、 APK包加密的公钥就打包在APK包内，且不同的私钥对应不同的公钥。换句话言之，不同的私钥签名的APK公钥也必不相同。所以我们可以根据公钥的对比，来判断私钥是否一致。

软键盘无法把内容顶出屏幕外

转载请标明出处，维权必究：http://77blogs.com/?p=275

继上次这一篇后：https://www.cnblogs.com/tangZH/p/12013685.html

我继续探讨，这次的场景和上一次的场景是一样的，在一个布局中，根布局是相对布局，需要被软键盘顶上去的部分为线性布局。线性布局最下方为一个Editext，后来发现，当线性布局的内容过多的时候，线性布局没法被顶出屏幕外，到达顶端就停止了，导致下方的EdiText被软键盘遮挡住。

我在根布局最外层套上一个ScrollView,这样一来发现下方的Editext还是会被遮挡住，但是不同的是，这时候你可以去手动将整个布局往上滑动，可我们需要的是顶上去之后自动露出来全部，而不是靠用户手动去滑，于是乎我想到了下面这种方法：

scrollView = findViewById(R.id.scroll);
view.getViewTreeObserver().addOnGlobalLayoutListener(
   () -> scrollView.fullScroll(ScrollView.FOCUS_DOWN));

scrollView = findViewById(R.id.scroll);

view.getViewTreeObserver().addOnGlobalLayoutListener(

() -> scrollView.fullScroll(ScrollView.FOCUS_DOWN));

监听view布局发现变化（也就是软键盘出现或者消失的时候）的时候就将scrollView滑动到最底下，这样就能够使得需要显示的内容不被软键盘遮挡。

android只设置部分控件随着软键盘的出现而腾出空间

转载请标明出处：http://77blogs.com/?p=276

在项目过程中，出现了一个需求，软键盘要顶起部分控件，而另一部分控件不动。

关于这种需求，我们需要明确布局方式：

1、线性布局是行不通的，即使被顶上去也是全部被顶上去，因为线性布局中里面的控件都是线性排列的，那么我们就用相对布局这种方式。

2、相对布局这种方式中，需要被顶上去的那一部分需要用一个父布局包裹起来，并且与不需要顶起来的那一部分不能有依赖关系，比如layout_above这类的，否则一个位置改变，另一个也会跟着改变。

项目中需要被顶起来的那一部分使用了：android:layout_alignParentBottom=”true”，置于底部。

其余的：

布局这样子之后，还要在manifests文件里面配置android:windowSoftInputMode=”adjustResize”

然而会发现还是没有被顶起来，其实还差一个，在需要被顶起来的那一个父布局里面加上android:fitsSystemWindows=”true”

这样又出现了另一个问题：当我们使用沉浸式状态栏的时候，设置android:fitsSystemWindows=”true”会导致该父布局上面多出一块空白，据说这块空白的高度就是状态栏的高度。

最后发现可以用下面的方法解决：

需要被顶起来的一个父布局采用自定义的布局，然后重写相应的方法：

@Override
    protected boolean fitSystemWindows(Rect insets) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            insets.left = 0;
            insets.top = 0;
            insets.right = 0;
        }
        return super.fitSystemWindows(insets);
    }
 
    @RequiresApi(api = Build.VERSION_CODES.KITKAT_WATCH)
    @Override
    public WindowInsets onApplyWindowInsets(WindowInsets insets) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            return super.onApplyWindowInsets(insets.replaceSystemWindowInsets(0, 0, 0, insets.getSystemWindowInsetBottom()));
        } else {
            return insets;
        }
    }

@Override

protected boolean fitSystemWindows(Rect insets) {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {

insets.left = 0;

insets.top = 0;

insets.right = 0;

}

return super.fitSystemWindows(insets);

}

@RequiresApi(api = Build.VERSION_CODES.KITKAT_WATCH)

@Override

public WindowInsets onApplyWindowInsets(WindowInsets insets) {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {

return super.onApplyWindowInsets(insets.replaceSystemWindowInsets(0, 0, 0, insets.getSystemWindowInsetBottom()));

} else {

return insets;

}

这样便解决了。

参考：https://blog.csdn.net/dbmonkey/article/details/84966318

Android自定义ViewPager:水平滑动弹性效果，侧滑刷新加载的ViewPager

转载于：https://blog.csdn.net/Excellence1981/article/details/70807873

public class FlexibleViewPager extends ViewPager {
    private static final String TAG = "FlexibleViewPager::::";
    private boolean isMoveLeft = true;//左边是否能移动
    private boolean isMoveRight;
    private Rect normal = new Rect();//记录原来的位置
    private OnRefreshListener listener;
    float x = 0;//记录开始触摸的位置
    int xMove = 0;//移动的距离

    public FlexibleViewPager(Context context) {
        super(context);
    }

    public FlexibleViewPager(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_MOVE:
                if (x == 0) {
                    x = ev.getX();//记录位置
                }
                xMove = (int) (x - ev.getX()) / 2;//计算移动距离
                Log.e(TAG, "xMove:" + xMove + "isMoveLeft:" + isMoveLeft + "isMoveRight:" + isMoveRight);
                if (isMoveLeft && xMove <= 0 || isMoveRight && xMove >= 0) {//移动位置
                    this.layout(-xMove, normal.top, normal.right - xMove, normal.bottom);
                    return true;
                }
                break;
            case MotionEvent.ACTION_UP:
                if (isMoveLeft || isMoveRight) {
                    animation(xMove);//还原位置
                }
                break;
        }
        return super.onTouchEvent(ev);
    }

    @Override
    protected void onPageScrolled(int position, float offset, int offsetPixels) {//监听viewpager是否是第一页或最后一页
        if (getAdapter() == null && getAdapter().getCount() == 0) {
            isMoveLeft = false;
            isMoveRight = false;
        } else if (position == 0 && offset == 0 && offsetPixels == 0) {
            isMoveLeft = true;
        } else if (position == getAdapter().getCount() - 1 && offset == 0 && offsetPixels == 0) {
            isMoveRight = true;
        } else {
            isMoveLeft = false;
            isMoveRight = false;
        }
        if (normal.isEmpty() || normal.top - normal.bottom == 0) {
            normal.set(this.getLeft(), this.getTop(), this.getRight(), this.getBottom());//viewpager记录原来位置
        }
        super.onPageScrolled(position, offset, offsetPixels);
    }

    /**
     * 还原动画
     **/
    public void animation(int moveX) {
        if (listener != null) {
            if (moveX > getWidth() / 6) {//滑动的距离超过屏幕的1/6才回调
                listener.onLoadMore();
            } else if (moveX < -getWidth() / 6) {
                listener.onRefresh();
            }
        }
        x = 0;
        TranslateAnimation ta = new TranslateAnimation(this.getX(), normal.left, 0, 0);
        ta.setDuration(200);
        this.startAnimation(ta);
        this.layout(normal.left, normal.top, normal.right, normal.bottom);
    }

    public void setOnRefreshListener(OnRefreshListener listener) {
        this.listener = listener;
    }

    public interface OnRefreshListener {
        void onRefresh();

        void onLoadMore();
    }

}

public class FlexibleViewPager extends ViewPager {

private static final String TAG = "FlexibleViewPager::::";

private boolean isMoveLeft = true;//左边是否能移动

private boolean isMoveRight;

private Rect normal = new Rect();//记录原来的位置

private OnRefreshListener listener;

float x = 0;//记录开始触摸的位置

int xMove = 0;//移动的距离

public FlexibleViewPager(Context context) {

super(context);

}

public FlexibleViewPager(Context context, AttributeSet attrs) {

super(context, attrs);

}

@Override

protected void onFinishInflate() {

super.onFinishInflate();

}

@Override

public boolean onTouchEvent(MotionEvent ev) {

switch (ev.getAction()) {

case MotionEvent.ACTION_MOVE:

if (x == 0) {

x = ev.getX();//记录位置

}

xMove = (int) (x - ev.getX()) / 2;//计算移动距离

Log.e(TAG, "xMove:" + xMove + "isMoveLeft:" + isMoveLeft + "isMoveRight:" + isMoveRight);

if (isMoveLeft && xMove <= 0 || isMoveRight && xMove >= 0) {//移动位置

this.layout(-xMove, normal.top, normal.right - xMove, normal.bottom);

return true;

}

break;

case MotionEvent.ACTION_UP:

if (isMoveLeft || isMoveRight) {

animation(xMove);//还原位置

}

break;

}

return super.onTouchEvent(ev);

}

@Override

protected void onPageScrolled(int position, float offset, int offsetPixels) {//监听viewpager是否是第一页或最后一页

if (getAdapter() == null && getAdapter().getCount() == 0) {

isMoveLeft = false;

isMoveRight = false;

} else if (position == 0 && offset == 0 && offsetPixels == 0) {

isMoveLeft = true;

} else if (position == getAdapter().getCount() - 1 && offset == 0 && offsetPixels == 0) {

isMoveRight = true;

} else {

isMoveLeft = false;

isMoveRight = false;

}

if (normal.isEmpty() || normal.top - normal.bottom == 0) {

normal.set(this.getLeft(), this.getTop(), this.getRight(), this.getBottom());//viewpager记录原来位置

}

super.onPageScrolled(position, offset, offsetPixels);

}

/**

* 还原动画

**/

public void animation(int moveX) {

if (listener != null) {

if (moveX > getWidth() / 6) {//滑动的距离超过屏幕的1/6才回调

listener.onLoadMore();

} else if (moveX < -getWidth() / 6) {

listener.onRefresh();

}

x = 0;

TranslateAnimation ta = new TranslateAnimation(this.getX(), normal.left, 0, 0);

ta.setDuration(200);

this.startAnimation(ta);

this.layout(normal.left, normal.top, normal.right, normal.bottom);

}

public void setOnRefreshListener(OnRefreshListener listener) {

this.listener = listener;

}

public interface OnRefreshListener {

void onRefresh();

void onLoadMore();

}

去除TextView设置lineSpacingExtra后，最后一行多出的空白

转载请标明出处：http://77blogs.com/?p=278

有些手机中，给TextView设置lineSpacingExtra后会出现最后一行的文字也出现lineSpacingExtra，不是某些版本才会，这跟机型有关。

可以用下面这种方法解决：

public class LastLineNoSpaceTextView extends AppCompatTextView {
    private Rect mRect;

    public LastLineNoSpaceTextView(Context context) {
        super(context);
        init();
    }

    public LastLineNoSpaceTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public LastLineNoSpaceTextView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        mRect = new Rect();
    }

    protected void onMeasure(int i, int i2) {
        super.onMeasure(i, i2);
        int measuredHeight = getMeasuredHeight() - getLastLineSpace();
        setMeasuredDimension(getMeasuredWidth(), measuredHeight);
    }

    public int getLastLineSpace() {
        int lastLineIndex = getLineCount() - 1;
        if (lastLineIndex < 0) {
            return 0;
        }
        Layout layout = getLayout();
        int baseline = getLineBounds(lastLineIndex, mRect);
        if (getMeasuredHeight() - getPaddingTop() - getPaddingBottom() != layout.getHeight()) {
            return 0;
        }
        int fontHeight = baseline + layout.getPaint().getFontMetricsInt().descent;
        int lineHeight = mRect.bottom;
        return lineHeight - fontHeight;
    }
}

public class LastLineNoSpaceTextView extends AppCompatTextView {

private Rect mRect;

public LastLineNoSpaceTextView(Context context) {

super(context);

init();

}

public LastLineNoSpaceTextView(Context context, AttributeSet attrs) {

super(context, attrs);

init();

}

public LastLineNoSpaceTextView(Context context, AttributeSet attrs, int defStyleAttr) {

super(context, attrs, defStyleAttr);

init();

}

private void init() {

mRect = new Rect();

}

protected void onMeasure(int i, int i2) {

super.onMeasure(i, i2);

int measuredHeight = getMeasuredHeight() - getLastLineSpace();

setMeasuredDimension(getMeasuredWidth(), measuredHeight);

}

public int getLastLineSpace() {

int lastLineIndex = getLineCount() - 1;

if (lastLineIndex < 0) {

return 0;

}

Layout layout = getLayout();

int baseline = getLineBounds(lastLineIndex, mRect);

if (getMeasuredHeight() - getPaddingTop() - getPaddingBottom() != layout.getHeight()) {

return 0;

}

int fontHeight = baseline + layout.getPaint().getFontMetricsInt().descent;

int lineHeight = mRect.bottom;

return lineHeight - fontHeight;

}