android刷新按钮

㈠ 如何强制刷新Android系统图库

系统自带的话，一般都是往下拉。如果没有，那就是不能刷新
不过我们可以投机取巧啊！你点一下设置→应用→找到图库（在全部应用里），强制关闭
之后你再打开就好了，系统崩溃就重启。或直接重启也行

㈡ Android 怎么实现支持所有View的通用的下拉刷新控件

下拉刷新对于一个app来说是必不可少的一个功能，在早期大多数使用的是chrisbanes的PullToRefresh，或是修改自该框架的其他库。而到现在已经有了更多的选择，github上还是有很多体验不错的下拉刷新。
而下拉刷新主要有两种实现方式：
1. 在ListView中添加header和footer，监听ListView的滑动事件，动态设置header/footer的高度，但是这种方式只适用于ListView，RecyclerView。
2. 第二种方式则是继承ViewGroup或其子类，监听事件，通过scroll或Layout的方式移动child。如图（又分两种情况）

Layout时将header放到屏幕外面，target则填充满屏幕。这个也是SwipeRefreshLayout的实现原理（第二种，只下拉header）

这两种（指的是继承ListView或继承ViewGroup）下拉刷新的实现方式主要有以下区别

继承ListView/RecyclerView

继承ViewGroup或其子类

适用范围
ListView/Recycler
理论支持所有View和ViewGroup

加载更多
实现简单，体验好
可以实现，看需求了，做不出ListView那种加载效果的,体验比较一般

多点触控
可以完美支持
header下拉状态中是完美支持的，但是回去之后，很难将多点触控事件传递给child

案例
QQ好友列表
美团、京东等

而今天，我打算先讲第二种方式实现方式，继承ViewGroup，代码可以直接参考SwipeRefreshLayout，或者pullToRefresh，或者ultra-pull-to-refresh

一、思考和需求

下拉刷新需要几个状态：Reset–> Pull – > Refreshing – >Completed –>Reset

为了应对各式各样的下拉刷新设计，我们应该提供设置自定义的Header，开发者可以通过实现接口从而自定义自己的header。

而且header可以有两种显示方式，一种是只下拉header，另外一种则是header和target一起下拉。

二、着手实现代码

2.1 定义Header的接口，创建自定义Layout

<code class="hljs java">/**
* Created by AItsuki on 2016/6/13.
*
*/
public enum State {
RESET, PULL, LOADING, COMPLETE
}</code>

<code class="hljs java">/**
* Created by AItsuki on 2016/6/13.
*
*/
public interface RefreshHeader {

/**
* 松手，头部隐藏后会回调这个方法
*/
void reset();

/**
* 下拉出头部的一瞬间调用
*/
void pull();

/**
* 正在刷新的时候调用
*/
void refreshing();

/**
* 头部滚动的时候持续调用
* @param currentPos target当前偏移高度
* @param lastPos target上一次的偏移高度
* @param refreshPos 可以松手刷新的高度
* @param isTouch 手指是否按下状态（通过scroll自动滚动时需要判断）
* @param state 当前状态
*/
void onPositionChange(float currentPos, float lastPos, float refreshPos, boolean isTouch, State state);

/**
* 刷新成功的时候调用
*/
void complete();
}</code>
package com.aitsuki.custompulltorefresh;

import android.content.Context;
import android.graphics.Color;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.ImageView;

/**
* Created by AItsuki on 2016/6/13.
* -
*/
public class RefreshLayout extends ViewGroup {

private View refreshHeader;
private View target;
private int currentTargetOffsetTop; // target偏移距离
private boolean hasMeasureHeader; // 是否已经计算头部高度
private int touchSlop;
private int headerHeight; // header高度
private int totalDragDistance; // 需要下拉这个距离才进入松手刷新状态，默认和header高度一致

public RefreshLayout(Context context) {
this(context, null);
}

public RefreshLayout(Context context, AttributeSet attrs) {
super(context, attrs);

touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

// 添加默认的头部，先简单的用一个ImageView代替头部
ImageView imageView = new ImageView(context);
imageView.setImageResource(R.drawable.one_piece);
imageView.setBackgroundColor(Color.BLACK);
setRefreshHeader(imageView);
}

/**
* 设置自定义header
*/
public void setRefreshHeader(View view) {
if (view != null && view != refreshHeader) {
removeView(refreshHeader);

// 为header添加默认的layoutParams
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
if (layoutParams == null) {
layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
view.setLayoutParams(layoutParams);
}
refreshHeader = view;
addView(refreshHeader);
}
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
if (target == null) {
ensureTarget();
}

if (target == null) {
return;
}

// ----- measure target -----
// target占满整屏
target.measure(MeasureSpec.makeMeasureSpec(
getMeasuredWidth() - getPaddingLeft() - getPaddingRight(),
MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(
getMeasuredHeight() - getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY));

// ----- measure refreshView-----
measureChild(refreshHeader, widthMeasureSpec, heightMeasureSpec);
if (!hasMeasureHeader) { // 防止header重复测量
hasMeasureHeader = true;
headerHeight = refreshHeader.getMeasuredHeight(); // header高度
totalDragDistance = headerHeight; // 需要pull这个距离才进入松手刷新状态
}
}

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
final int width = getMeasuredWidth();
final int height = getMeasuredHeight();
if (getChildCount() == 0) {
return;
}

if (target == null) {
ensureTarget();
}
if (target == null) {
return;
}

// onLayout执行的时候，要让target和header加上偏移距离（初始0），因为有可能在滚动它们的时候，child请求重新布局，从而导致target和header瞬间回到原位。

// target铺满屏幕
final View child = target;
final int childLeft = getPaddingLeft();
final int childTop = getPaddingTop() + currentTargetOffsetTop;
final int childWidth = width - getPaddingLeft() - getPaddingRight();
final int childHeight = height - getPaddingTop() - getPaddingBottom();
child.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);

// header放到target的上方，水平居中
int refreshViewWidth = refreshHeader.getMeasuredWidth();
refreshHeader.layout((width / 2 - refreshViewWidth / 2),
-headerHeight + currentTargetOffsetTop,
(width / 2 + refreshViewWidth / 2),
currentTargetOffsetTop);
}

/**
* 将第一个Child作为target
*/
private void ensureTarget() {
// Don't bother getting the parent height if the parent hasn't been laid
// out yet.
if (target == null) {
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
if (!child.equals(refreshHeader)) {
target = child;
break;
}
}
}
}
}</code>

㈢ android中怎么实现上拉刷新

这篇文章主要介绍了android实现listview下拉刷新和上拉刷新效果,Android的ListView上拉下拉刷新，原理都一样，在Touch事件中操作header/footer的paddingTop属性，需要的朋友可以参考下

{

privatestaticfinalStringTAG=PullToLoadListView.class.getSimpleName();

privatestaticfinalintSTATE_NON=0;
privatestaticfinalintSTATE_PULL_TO_REFRESH=1;
privatestaticfinalintSTATE_RELEASE_TO_REFRESH=2;
privatestaticfinalintSTATE_REFRESHING=3;

privateintstate;

privateintfirstVisibleItem;
privateintlastVisisibleItem;

privatefloatprevY=0;

privateViewheaderView;
privateViewfooterView;

//headerwidgets
;
;
privateTextViewheaderText;
;
;
//footerwidgets
;
privateTextViewfooterText;

privatebooleanheaderIsHanding=false;
privatebooleanfooterIsHanding=false;

privateintheaderHeight;
privateintfooterHeight;

;

;

;

publicPullToLoadListView(Contextcontext){
super(context);
init(context);
}

publicPullToLoadListView(Contextcontext,AttributeSetattrs){
super(context,attrs);
init(context);
}

privatevoidinit(Contextcontext){
state=STATE_NON;
firstVisibleItem=0;
lastVisisibleItem=0;

LayoutInflaterinflater=LayoutInflater.from(context);
headerView=inflater.inflate(R.layout.view_pull_header,null);
footerView=inflater.inflate(R.layout.view_pull_footer,null);

headerProgressBar=(ProgressBar)headerView.findViewById(R.id.progressbar);
headerImageArrow=(ImageView)headerView.findViewById(R.id.arrow);
headerText=(TextView)headerView.findViewById(R.id.text);
headerArrowAnim=newRotateAnimation(0,-180,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
headerArrowAnim.setDuration(300);
headerArrowAnim.setFillAfter(true);
headerArrowReverseAnim=newRotateAnimation(-180,0,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
headerArrowReverseAnim.setDuration(300);
headerArrowReverseAnim.setFillAfter(true);

footerProgressBar=(ProgressBar)footerView.findViewById(R.id.progressbar);
footerText=(TextView)footerView.findViewById(R.id.text);

measureView(headerView);
measureView(footerView);
headerHeight=headerView.getMeasuredHeight();
footerHeight=footerView.getMeasuredHeight();
headerView.setPadding(0,-1*headerView.getMeasuredHeight(),0,0);
footerView.setPadding(0,-1*footerView.getMeasuredHeight(),0,0);
headerView.invalidate();
footerView.invalidate();
addHeaderView(headerView,null,false);
addFooterView(footerView,null,false);

super.setOnScrollListener(this);
}

privatevoidmeasureView(Viewview){
ViewGroup.LayoutParamslp=view.getLayoutParams();
if(lp==null){
lp=newViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.WRAP_CONTENT);
}
intchildWidthSpec=ViewGroup.getChildMeasureSpec(0,0,lp.width);
intchildHeightSpec;
if(lp.height>0){
childHeightSpec=MeasureSpec.makeMeasureSpec(0,MeasureSpec.EXACTLY);
}else{
childHeightSpec=MeasureSpec.makeMeasureSpec(0,MeasureSpec.UNSPECIFIED);
}
view.measure(childWidthSpec,childHeightSpec);
}

privatevoidresetHeader(){
//headerView.setPadding(0,-1*headerHeight,0,0);
resetAnim=newResetAnimation(headerView,headerHeight,headerView.getPaddingTop());
resetAnim.start();
}

privatevoidresetFooter(){
resetAnim=newResetAnimation(footerView,footerHeight,footerView.getPaddingTop());
resetAnim.start();
}

(intstate){
if(this.state==state){
return;
}
intprevState=this.state;
this.state=state;

switch(state){
caseSTATE_NON:
headerProgressBar.setVisibility(View.INVISIBLE);
headerImageArrow.setVisibility(View.VISIBLE);
headerImageArrow.clearAnimation();
headerText.setText("PullDownToRefresh");
break;
caseSTATE_PULL_TO_REFRESH:
headerProgressBar.setVisibility(View.INVISIBLE);
headerImageArrow.setVisibility(View.VISIBLE);
headerText.setText("PullDownToRefresh");
if(prevState==STATE_RELEASE_TO_REFRESH){
headerImageArrow.startAnimation(headerArrowReverseAnim);
}else{
headerImageArrow.clearAnimation();
}
break;
caseSTATE_RELEASE_TO_REFRESH:
headerProgressBar.setVisibility(View.INVISIBLE);
headerImageArrow.setVisibility(View.VISIBLE);
headerImageArrow.startAnimation(headerArrowAnim);
headerText.setText("ReleaseToRefresh");
break;
caseSTATE_REFRESHING:
headerProgressBar.setVisibility(View.VISIBLE);
headerImageArrow.setVisibility(View.INVISIBLE);
headerImageArrow.clearAnimation();
headerText.setText("Refreshing");
break;
default:
break;
}
}

(intstate){
if(this.state==state){
return;
}
this.state=state;

switch(state){
caseSTATE_NON:
footerProgressBar.setVisibility(View.INVISIBLE);
footerText.setText("PullUpToRefresh");
break;
caseSTATE_PULL_TO_REFRESH:
footerProgressBar.setVisibility(View.INVISIBLE);
footerText.setText("PullUpToRefresh");
break;
caseSTATE_RELEASE_TO_REFRESH:
footerProgressBar.setVisibility(View.INVISIBLE);
footerText.setText("ReleaseToRefresh");
break;
caseSTATE_REFRESHING:
footerProgressBar.setVisibility(View.VISIBLE);
footerText.setText("Refreshing");
break;
default:
break;
}
}

@Override
publicvoidsetOnScrollListener(OnScrollListenerl){
this.onScrollListener=l;
}

(){
this.onLoadingListener=onLoadingListener;
}

publicvoidloadCompleted(){
if(headerIsHanding){
changeHeaderViewByState(STATE_NON);
resetHeader();
headerIsHanding=false;
}
if(footerIsHanding){
changeFooterViewByState(STATE_NON);
resetFooter();
footerIsHanding=false;
}
}

(MotionEventev){
headerIsHanding=true;
floattempY=ev.getRawY();
floatvector=tempY-prevY;
vector/=2;
prevY=tempY;
if(vector>0){
intnewPadding=(int)(headerView.getPaddingTop()+vector);
newPadding=Math.min(newPadding,headerHeight/2);
headerView.setPadding(0,newPadding,0,0);
if(state!=STATE_REFRESHING){
if(newPadding>0){
changeHeaderViewByState(STATE_RELEASE_TO_REFRESH);
}else{
changeHeaderViewByState(STATE_PULL_TO_REFRESH);
}
}
}else{
if(state==STATE_RELEASE_TO_REFRESH||state==STATE_PULL_TO_REFRESH){
intnewPadding=(int)(headerView.getPaddingTop()+vector);
newPadding=Math.max(newPadding,-1*headerHeight);
headerView.setPadding(0,newPadding,0,0);
if(newPadding<=-1*headerHeight){
changeHeaderViewByState(STATE_NON);
headerIsHanding=false;
}elseif(newPadding<=0){
changeHeaderViewByState(STATE_PULL_TO_REFRESH);
}else{

}
}
}
}

(MotionEventev){
footerIsHanding=true;
floattempY=ev.getRawY();
floatvector=tempY-prevY;
vector/=2;
prevY=tempY;
if(vector<0){
intnewPadding=(int)(footerView.getPaddingTop()-vector);
if(newPadding>0){
newPadding=0;
}
footerView.setPadding(0,newPadding,0,0);
if(state!=STATE_REFRESHING){
if(newPadding<0){
changeFooterViewByState(STATE_PULL_TO_REFRESH);
}else{
changeFooterViewByState(STATE_RELEASE_TO_REFRESH);
}
}
}else{
intnewPadding=(int)(footerView.getPaddingTop()-vector);
newPadding=Math.min(newPadding,footerHeight);
footerView.setPadding(0,newPadding,0,0);
if(newPadding<=-1*footerHeight){
changeFooterViewByState(STATE_NON);
footerIsHanding=false;
}elseif(newPadding<0){
changeFooterViewByState(STATE_PULL_TO_REFRESH);
}
}
}

㈣ Android屏幕刷新机制—VSync、Choreographer 全面理解！

在阅读本篇之前，建议先了解《View的工作原理》、《Handler：Android消息机制》、《Window和WindowManager》、《Activity的启动过程详解》等基础知识。接下来，我们深入探讨Android屏幕刷新机制，特别是VSync、Choreographer的重要作用。

屏幕刷新机制的背景和疑问：在Android中，我们追求高效的布局优化和减少主线程耗时操作，以避免出现丢帧现象。丢帧严重时，界面会表现出明显的卡顿感。我们知道，手机通常以每秒60次的频率刷新屏幕，即每16.6毫秒刷新一次。然而，实际操作中，我们经常面临如何在固定刷新频率与CPU/GPU计算速度不匹配的情况下的挑战。

屏幕撕裂问题：CPU/GPU在计算和刷新屏幕时，可能因为数据刷新的速度跟不上屏幕刷新的速度，导致屏幕上显示的数据不完整，这就是屏幕撕裂。双缓存机制可以有效解决这一问题，通过使用两个缓冲区，确保屏幕在刷新时得到的数据是完整的。VSync（垂直同步）是实现双缓存交换的关键，它利用屏幕刷新间隙进行缓冲区的交换，确保了屏幕显示的连续性和完整性。

Android屏幕刷新机制详解：在Android4.1之前，系统通过双缓存+VSync机制来管理屏幕刷新。然而，随着系统的发展，针对更复杂的界面和计算需求，Android4.1引入了Project Butter计划，优化了显示性能，使得CPU和GPU在VSync信号到来时开始下一帧的渲染，有效减少了卡顿现象。为了进一步提升性能，Android引入了三缓存机制，通过增加额外的缓冲区，最大限度地利用等待VSync的时间，但同时也带来了额外的内存开销。

Choreographer的作用：Choreographer作为关键的系统组件，负责协调UI的绘制流程，确保在VSync信号到来时启动下一帧的渲染。通过使用Choreographer，系统可以更高效地管理UI任务的执行顺序，优化显示性能。Choreographer通过创建特定的线程实例，安排和处理UI相关的回调任务，包括绘制任务（TRAVERSAL）、动画任务（ANIMATION）等，确保在合适的时机执行这些任务，从而达到流畅的用户体验。

异步消息与同步屏障：在处理UI任务时，Choreographer使用异步消息来调度任务执行，而同步屏障则是用于控制消息队列的执行顺序，确保在特定任务完成后才执行后续任务。这些机制协同工作，使得Choreographer能够高效地管理系统资源，优化显示性能。

总结：理解Android屏幕刷新机制和Choreographer的作用对于优化UI性能、减少卡顿现象至关重要。通过合理利用双缓存、VSync、Choreographer等技术，可以显着提升Android应用的用户体验。深入学习这些机制的基础知识，并将其应用于实际开发中，将有助于开发者构建更加流畅和响应迅速的Android应用。

㈤ 如何定时刷新Android界面

Android程序中可以使用的界面刷新方法有两种，分别是利用Handler和利用postInvalidate()来实现在线程中刷新界面。
利用Handler刷新界面
实例化一个Handler对象，并重写handleMessage方法调用invalidate()实现界面刷新；而在线程中通过sendMessage发送界面更新消息。
复制到剪贴板 java代码// 在onCreate()中开启线程 new Thread(new GameThread()).start();、 // 实例化一个handler Handler myHandler = new Handler() { //接收到消息后处理 public void handleMessage(Message msg) { switch (msg.what) { case Activity01.REFRESH: mGameView.invalidate(); //刷新界面 break; } super.handleMessage(msg); } }; class GameThread implements Runnable { public void run() { while (!Thread.currentThread().isInterrupted()) { Message message = new Message(); message.what = Activity01.REFRESH; //发送消息 Activity01.this.myHandler.sendMessage(message); try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } } 使用postInvalidate()刷新界面
使用postInvalidate则比较简单，不需要handler，直接在线程中调用postInvalidate即可。
复制到剪贴板 Java代码class GameThread implements Runnable { public void run() { while (!Thread.currentThread().isInterrupted()) { try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } //使用postInvalidate可以直接在线程中更新界 mGameView.postInvalidate(); } } }

㈥ Android下拉刷新，上拉加载，有没有比较好的第三方库

拉刷新和下拉刷新的两种方法（包括使用第三方库MJRefresh）一、使用苹果原生的方法1、下拉刷新2、上拉刷新(1首先要新建一个footer得XIB文件，当然同时包括对应的控制器文件，例如在XIB文件中可以如下拖拉对应的控件（2然后在代码文件中写一个实例方法+(instancetype)footer{return[[[NSBundlemainBundle]loadNibNamed:@"XIB文件名"owner:niloptions:nil]lastObject];}（3然后在我们的列表控制器中调用：/***集成上拉刷新控件*/-(void)refreshUpStateDateList{XBLoadMoreFooter*footer=[XBLoadMoreFooterfooter];footer.hidden=YES;//一开始是要隐藏起来的，当scrollView拖拉到底部的时候我们才把它放出来self.tableView.tableFooterView=footer;//其实就是相当于把这个XIB文件当作是tableView的Footer}（4上拉到底部的时候去调用刷新数据的方法二、使用第三方库MJRefresh1、下拉刷新遵守协议:,然后其实就是把它当成tableview的header来用2、下拉刷新3、需要注意：最后需要dealloc