Android下拉刷新完全解析

最新推荐文章于 2024-05-15 09:26:37 发布
最新推荐文章于 2024-05-15 09:26:37 发布
阅读量330 收藏
点赞数

首先讲一下实现原理。这里我们将采取的方案是使用组合View的方式，先自定义一个布局继承自LinearLayout，然后在这个布局中加入下拉头和ListView这两个子元素，并让这两个子元素纵向排列。初始化的时候，让下拉头向上偏移出屏幕，这样我们看到的就只有ListView了。然后对ListView的touch事件进行监听，如果当前ListView已经滚动到顶部并且手指还在向下拉的话，那就将下拉头显示出来，松手后进行刷新操作，并将下拉头隐藏。原理示意图如下：

\

那我们现在就来动手实现一下，新建一个项目起名叫PullToRefreshTest，先在项目中定义一个下拉头的布局文件pull_to_refresh.xml，代码如下所示：

[html] view plaincopy
  1. <relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
  2. xmlns:tools="http://schemas.android.com/tools"
  3. android:id="@+id/pull_to_refresh_head"
  4. android:layout_width="fill_parent"
  5. android:layout_height="60dip" >
  7. <linearlayout
  8. android:layout_width="200dip"
  9. android:layout_height="60dip"
  10. android:layout_centerInParent="true"
  11. android:orientation="horizontal" >
  13. <relativelayout
  14. android:layout_width="0dip"
  15. android:layout_height="60dip"
  16. android:layout_weight="3"
  17. >
  18. <imageview class="alt"
  19. android:id="@+id/arrow"
  20. android:layout_width="wrap_content"
  21. android:layout_height="wrap_content"
  22. android:layout_centerInParent="true"
  23. android:src="@drawable/arrow"
  24. />
  25. <progressbar
  26. android:id="@+id/progress_bar"
  27. android:layout_width="30dip"
  28. android:layout_height="30dip"
  29. android:layout_centerInParent="true"
  30. android:visibility="gone"
  31. />
  34. <linearlayout class="alt"
  35. android:layout_width="0dip"
  36. android:layout_height="60dip"
  37. android:layout_weight="12"
  38. android:orientation="vertical" >
  40. <textview class="alt"
  41. android:id="@+id/description"
  42. android:layout_width="fill_parent"
  43. android:layout_height="0dip"
  44. android:layout_weight="1"
  45. android:gravity="center_horizontal|bottom"
  46. android:text="@string/pull_to_refresh" />
  48. <textview class="alt"
  49. android:id="@+id/updated_at"
  50. android:layout_width="fill_parent"
  51. android:layout_height="0dip"
  52. android:layout_weight="1"
  53. android:gravity="center_horizontal|top"
  54. android:text="@string/updated_at" />
  58. 在这个布局中，我们包含了一个下拉指示箭头，一个下拉状态文字提示，和一个上次更新的时间。当然，还有一个隐藏的旋转进度条，只有正在刷新的时候我们才会将它显示出来。
    布局中所有引用的字符串我们都放在strings.xml中，如下所示: [html] view plaincopy
    4. PullToRefreshTest
    5. 下拉可以刷新
    6. 释放立即刷新
    7. 正在刷新…
    8. 暂未更新过
    9. 上次更新于%1$s前
    10. 刚刚更新
    11. 时间有问题
    13. 然后新建一个RefreshableView继承自LinearLayout，代码如下所示： [java] view plaincopy
      1. public class RefreshableView extends LinearLayout implements OnTouchListener {
      3. /**
      4. * 下拉状态
      5. */
      6. public static final int STATUS_PULL_TO_REFRESH = 0;
      8. /**
      9. * 释放立即刷新状态
      10. */
      11. public static final int STATUS_RELEASE_TO_REFRESH = 1;
      13. /**
      14. * 正在刷新状态
      15. */
      16. public static final int STATUS_REFRESHING = 2;
      18. /**
      19. * 刷新完成或未刷新状态
      20. */
      21. public static final int STATUS_REFRESH_FINISHED = 3;
      23. /**
      24. * 下拉头部回滚的速度
      25. */
      26. public static final int SCROLL_SPEED = -20;
      28. /**
      29. * 一分钟的毫秒值，用于判断上次的更新时间
      30. */
      31. public static final long ONE_MINUTE = 60 * 1000;
      33. /**
      34. * 一小时的毫秒值，用于判断上次的更新时间
      35. */
      36. public static final long ONE_HOUR = 60 * ONE_MINUTE;
      38. /**
      39. * 一天的毫秒值，用于判断上次的更新时间
      40. */
      41. public static final long ONE_DAY = 24 * ONE_HOUR;
      43. /**
      44. * 一月的毫秒值，用于判断上次的更新时间
      45. */
      46. public static final long ONE_MONTH = 30 * ONE_DAY;
      48. /**
      49. * 一年的毫秒值，用于判断上次的更新时间
      50. */
      51. public static final long ONE_YEAR = 12 * ONE_MONTH;
      53. /**
      54. * 上次更新时间的字符串常量，用于作为SharedPreferences的键值
      55. */
      56. private static final String UPDATED_AT = "updated_at";
      58. /**
      59. * 下拉刷新的回调接口
      60. */
      61. private PullToRefreshListener mListener;
      63. /**
      64. * 用于存储上次更新时间
      65. */
      66. private SharedPreferences preferences;
      68. /**
      69. * 下拉头的View
      70. */
      71. private View header;
      73. /**
      74. * 需要去下拉刷新的ListView
      75. */
      76. private ListView listView;
      78. /**
      79. * 刷新时显示的进度条
      80. */
      81. private ProgressBar progressBar;
      83. /**
      84. * 指示下拉和释放的箭头
      85. */
      86. private ImageView arrow;
      88. /**
      89. * 指示下拉和释放的文字描述
      90. */
      91. private TextView description;
      93. /**
      94. * 上次更新时间的文字描述
      95. */
      96. private TextView updateAt;
      98. /**
      99. * 下拉头的布局参数
      100. */
      101. private MarginLayoutParams headerLayoutParams;
      103. /**
      104. * 上次更新时间的毫秒值
      105. */
      106. private long lastUpdateTime;
      108. /**
      109. * 为了防止不同界面的下拉刷新在上次更新时间上互相有冲突，使用id来做区分
      110. */
      111. private int mId = -1;
      113. /**
      114. * 下拉头的高度
      115. */
      116. private int hideHeaderHeight;
      118. /**
      119. * 当前处理什么状态，可选值有STATUS_PULL_TO_REFRESH, STATUS_RELEASE_TO_REFRESH,
      120. * STATUS_REFRESHING 和 STATUS_REFRESH_FINISHED
      121. */
      122. private int currentStatus = STATUS_REFRESH_FINISHED;;
      124. /**
      125. * 记录上一次的状态是什么，避免进行重复操作
      126. */
      127. private int lastStatus = currentStatus;
      129. /**
      130. * 手指按下时的屏幕纵坐标
      131. */
      132. private float yDown;
      134. /**
      135. * 在被判定为滚动之前用户手指可以移动的最大值。
      136. */
      137. private int touchSlop;
      139. /**
      140. * 是否已加载过一次layout，这里onLayout中的初始化只需加载一次
      141. */
      142. private boolean loadOnce;
      144. /**
      145. * 当前是否可以下拉，只有ListView滚动到头的时候才允许下拉
      146. */
      147. private boolean ableToPull;
      149. /**
      150. * 下拉刷新控件的构造函数，会在运行时动态添加一个下拉头的布局。
      151. *
      152. * @param context
      153. * @param attrs
      154. */
      155. public RefreshableView(Context context, AttributeSet attrs) {
      156. super(context, attrs);
      157. preferences = PreferenceManager.getDefaultSharedPreferences(context);
      158. header = LayoutInflater.from(context).inflate(R.layout.pull_to_refresh, null, true);
      159. progressBar = (ProgressBar) header.findViewById(R.id.progress_bar);
      160. arrow = (ImageView) header.findViewById(R.id.arrow);
      161. description = (TextView) header.findViewById(R.id.description);
      162. updateAt = (TextView) header.findViewById(R.id.updated_at);
      163. touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
      164. refreshUpdatedAtValue();
      165. setOrientation(VERTICAL);
      166. addView(header, 0);
      167. }
      169. /**
      170. * 进行一些关键性的初始化操作，比如：将下拉头向上偏移进行隐藏，给ListView注册touch事件。
      171. */
      172. @Override
      173. protected void onLayout(boolean changed, int l, int t, int r, int b) {
      174. super.onLayout(changed, l, t, r, b);
      175. if (changed && !loadOnce) {
      176. hideHeaderHeight = -header.getHeight();
      177. headerLayoutParams = (MarginLayoutParams) header.getLayoutParams();
      178. headerLayoutParams.topMargin = hideHeaderHeight;
      179. header.setLayoutParams(headerLayoutParams);
      180. listView = (ListView) getChildAt(1);
      181. listView.setOnTouchListener(this);
      182. loadOnce = true;
      183. }
      184. }
      186. /**
      187. * 当ListView被触摸时调用，其中处理了各种下拉刷新的具体逻辑。
      188. */
      189. @Override
      190. public boolean onTouch(View v, MotionEvent event) {
      191. setIsAbleToPull(event);
      192. if (ableToPull) {
      193. switch (event.getAction()) {
      194. case MotionEvent.ACTION_DOWN:
      195. yDown = event.getRawY();
      196. break;
      197. case MotionEvent.ACTION_MOVE:
      198. float yMove = event.getRawY();
      199. int distance = (int) (yMove - yDown);
      200. // 如果手指是下滑状态，并且下拉头是完全隐藏的，就屏蔽下拉事件
      201. if (distance <= 0 && headerLayoutParams.topMargin <= hideHeaderHeight) {
      202. return false;
      203. }
      204. if (distance < touchSlop) {
      205. return false;
      206. }
      207. if (currentStatus != STATUS_REFRESHING) {
      208. if (headerLayoutParams.topMargin > 0) {
      209. currentStatus = STATUS_RELEASE_TO_REFRESH;
      210. } else {
      211. currentStatus = STATUS_PULL_TO_REFRESH;
      212. }
      213. // 通过偏移下拉头的topMargin值，来实现下拉效果
      214. headerLayoutParams.topMargin = (distance / 2) + hideHeaderHeight;
      215. header.setLayoutParams(headerLayoutParams);
      216. }
      217. break;
      218. case MotionEvent.ACTION_UP:
      219. default:
      220. if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
      221. // 松手时如果是释放立即刷新状态，就去调用正在刷新的任务
      222. new RefreshingTask().execute();
      223. } else if (currentStatus == STATUS_PULL_TO_REFRESH) {
      224. // 松手时如果是下拉状态，就去调用隐藏下拉头的任务
      225. new HideHeaderTask().execute();
      226. }
      227. break;
      228. }
      229. // 时刻记得更新下拉头中的信息
      230. if (currentStatus == STATUS_PULL_TO_REFRESH
      231. || currentStatus == STATUS_RELEASE_TO_REFRESH) {
      232. updateHeaderView();
      233. // 当前正处于下拉或释放状态，要让ListView失去焦点，否则被点击的那一项会一直处于选中状态
      234. listView.setPressed(false);
      235. listView.setFocusable(false);
      236. listView.setFocusableInTouchMode(false);
      237. lastStatus = currentStatus;
      238. // 当前正处于下拉或释放状态，通过返回true屏蔽掉ListView的滚动事件
      239. return true;
      240. }
      241. }
      242. return false;
      243. }
      245. /**
      246. * 给下拉刷新控件注册一个监听器。
      247. *
      248. * @param listener
      249. * 监听器的实现。
      250. * @param id
      251. * 为了防止不同界面的下拉刷新在上次更新时间上互相有冲突， 请不同界面在注册下拉刷新监听器时一定要传入不同的id。
      252. */
      253. public void setOnRefreshListener(PullToRefreshListener listener, int id) {
      254. mListener = listener;
      255. mId = id;
      256. }
      258. /**
      259. * 当所有的刷新逻辑完成后，记录调用一下，否则你的ListView将一直处于正在刷新状态。
      260. */
      261. public void finishRefreshing() {
      262. currentStatus = STATUS_REFRESH_FINISHED;
      263. preferences.edit().putLong(UPDATED_AT + mId, System.currentTimeMillis()).commit();
      264. new HideHeaderTask().execute();
      265. }
      267. /**
      268. * 根据当前ListView的滚动状态来设定 {@link #ableToPull}
      269. * 的值，每次都需要在onTouch中第一个执行，这样可以判断出当前应该是滚动ListView，还是应该进行下拉。
      270. *
      271. * @param event
      272. */
      273. private void setIsAbleToPull(MotionEvent event) {
      274. View firstChild = listView.getChildAt(0);
      275. if (firstChild != null) {
      276. int firstVisiblePos = listView.getFirstVisiblePosition();
      277. if (firstVisiblePos == 0 && firstChild.getTop() == 0) {
      278. if (!ableToPull) {
      279. yDown = event.getRawY();
      280. }
      281. // 如果首个元素的上边缘，距离父布局值为0，就说明ListView滚动到了最顶部，此时应该允许下拉刷新
      282. ableToPull = true;
      283. } else {
      284. if (headerLayoutParams.topMargin != hideHeaderHeight) {
      285. headerLayoutParams.topMargin = hideHeaderHeight;
      286. header.setLayoutParams(headerLayoutParams);
      287. }
      288. ableToPull = false;
      289. }
      290. } else {
      291. // 如果ListView中没有元素，也应该允许下拉刷新
      292. ableToPull = true;
      293. }
      294. }
      296. /**
      297. * 更新下拉头中的信息。
      298. */
      299. private void updateHeaderView() {
      300. if (lastStatus != currentStatus) {
      301. if (currentStatus == STATUS_PULL_TO_REFRESH) {
      302. description.setText(getResources().getString(R.string.pull_to_refresh));
      303. arrow.setVisibility(View.VISIBLE);
      304. progressBar.setVisibility(View.GONE);
      305. rotateArrow();
      306. } else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
      307. description.setText(getResources().getString(R.string.release_to_refresh));
      308. arrow.setVisibility(View.VISIBLE);
      309. progressBar.setVisibility(View.GONE);
      310. rotateArrow();
      311. } else if (currentStatus == STATUS_REFRESHING) {
      312. description.setText(getResources().getString(R.string.refreshing));
      313. progressBar.setVisibility(View.VISIBLE);
      314. arrow.clearAnimation();
      315. arrow.setVisibility(View.GONE);
      316. }
      317. refreshUpdatedAtValue();
      318. }
      319. }
      321. /**
      322. * 根据当前的状态来旋转箭头。
      323. */
      324. private void rotateArrow() {
      325. float pivotX = arrow.getWidth() / 2f;
      326. float pivotY = arrow.getHeight() / 2f;
      327. float fromDegrees = 0f;
      328. float toDegrees = 0f;
      329. if (currentStatus == STATUS_PULL_TO_REFRESH) {
      330. fromDegrees = 180f;
      331. toDegrees = 360f;
      332. } else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
      333. fromDegrees = 0f;
      334. toDegrees = 180f;
      335. }
      336. RotateAnimation animation = new RotateAnimation(fromDegrees, toDegrees, pivotX, pivotY);
      337. animation.setDuration(100);
      338. animation.setFillAfter(true);
      339. arrow.startAnimation(animation);
      340. }
      342. /**
      343. * 刷新下拉头中上次更新时间的文字描述。
      344. */
      345. private void refreshUpdatedAtValue() {
      346. lastUpdateTime = preferences.getLong(UPDATED_AT + mId, -1);
      347. long currentTime = System.currentTimeMillis();
      348. long timePassed = currentTime - lastUpdateTime;
      349. long timeIntoFormat;
      350. String updateAtValue;
      351. if (lastUpdateTime == -1) {
      352. updateAtValue = getResources().getString(R.string.not_updated_yet);
      353. } else if (timePassed < 0) {
      354. updateAtValue = getResources().getString(R.string.time_error);
      355. } else if (timePassed < ONE_MINUTE) {
      356. updateAtValue = getResources().getString(R.string.updated_just_now);
      357. } else if (timePassed < ONE_HOUR) {
      358. timeIntoFormat = timePassed / ONE_MINUTE;
      359. String value = timeIntoFormat + "分钟";
      360. updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
      361. } else if (timePassed < ONE_DAY) {
      362. timeIntoFormat = timePassed / ONE_HOUR;
      363. String value = timeIntoFormat + "小时";
      364. updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
      365. } else if (timePassed < ONE_MONTH) {
      366. timeIntoFormat = timePassed / ONE_DAY;
      367. String value = timeIntoFormat + "天";
      368. updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
      369. } else if (timePassed < ONE_YEAR) {
      370. timeIntoFormat = timePassed / ONE_MONTH;
      371. String value = timeIntoFormat + "个月";
      372. updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
      373. } else {
      374. timeIntoFormat = timePassed / ONE_YEAR;
      375. String value = timeIntoFormat + "年";
      376. updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
      377. }
      378. updateAt.setText(updateAtValue);
      379. }
      381. /**
      382. * 正在刷新的任务，在此任务中会去回调注册进来的下拉刷新监听器。
      383. *
      384. * @author guolin
      385. */
      386. class RefreshingTask extends AsyncTask {
      388. @Override
      389. protected Void doInBackground(Void... params) {
      390. int topMargin = headerLayoutParams.topMargin;
      391. while (true) {
      392. topMargin = topMargin + SCROLL_SPEED;
      393. if (topMargin <= 0) {
      394. topMargin = 0;
      395. break;
      396. }
      397. publishProgress(topMargin);
      398. sleep(10);
      399. }
      400. currentStatus = STATUS_REFRESHING;
      401. publishProgress(0);
      402. if (mListener != null) {
      403. mListener.onRefresh();
      404. }
      405. return null;
      406. }
      408. @Override
      409. protected void onProgressUpdate(Integer... topMargin) {
      410. updateHeaderView();
      411. headerLayoutParams.topMargin = topMargin[0];
      412. header.setLayoutParams(headerLayoutParams);
      413. }
      415. }
      417. /**
      418. * 隐藏下拉头的任务，当未进行下拉刷新或下拉刷新完成后，此任务将会使下拉头重新隐藏。
      419. *
      420. * @author guolin
      421. */
      422. class HideHeaderTask extends AsyncTask {
      424. @Override
      425. protected Integer doInBackground(Void... params) {
      426. int topMargin = headerLayoutParams.topMargin;
      427. while (true) {
      428. topMargin = topMargin + SCROLL_SPEED;
      429. if (topMargin <= hideHeaderHeight) {
      430. topMargin = hideHeaderHeight;
      431. break;
      432. }
      433. publishProgress(topMargin);
      434. sleep(10);
      435. }
      436. return topMargin;
      437. }
      439. @Override
      440. protected void onProgressUpdate(Integer... topMargin) {
      441. headerLayoutParams.topMargin = topMargin[0];
      442. header.setLayoutParams(headerLayoutParams);
      443. }
      445. @Override
      446. protected void onPostExecute(Integer topMargin) {
      447. headerLayoutParams.topMargin = topMargin;
      448. header.setLayoutParams(headerLayoutParams);
      449. currentStatus = STATUS_REFRESH_FINISHED;
      450. }
      451. }
      453. /**
      454. * 使当前线程睡眠指定的毫秒数。
      455. *
      456. * @param time
      457. * 指定当前线程睡眠多久，以毫秒为单位
      458. */
      459. private void sleep(int time) {
      460. try {
      461. Thread.sleep(time);
      462. } catch (InterruptedException e) {
      463. e.printStackTrace();
      464. }
      465. }
      467. /**
      468. * 下拉刷新的监听器，使用下拉刷新的地方应该注册此监听器来获取刷新回调。
      469. *
      470. * @author guolin
      471. */
      472. public interface PullToRefreshListener {
      474. /**
      475. * 刷新时会去回调此方法，在方法内编写具体的刷新逻辑。注意此方法是在子线程中调用的， 你可以不必另开线程来进行耗时操作。
      476. */
      477. void onRefresh();
      479. }
      481. }

        这个类是整个下拉刷新功能中最重要的一个类，注释已经写得比较详细了，我再简单解释一下。首先在RefreshableView的构造函数中动态添加了刚刚定义的pull_to_refresh这个布局作为下拉头，然后在onLayout方法中将下拉头向上偏移出了屏幕，再给ListView注册了touch事件。之后每当手指在ListView上滑动时，onTouch方法就会执行。在onTouch方法中的第一行就调用了setIsAbleToPull方法来判断ListView是否滚动到了最顶部，只有滚动到了最顶部才会执行后面的代码，否则就视为正常的ListView滚动，不做任何处理。当ListView滚动到了最顶部时，如果手指还在向下拖动，就会改变下拉头的偏移值，让下拉头显示出来，下拉的距离设定为手指移动距离的1/2，这样才会有拉力的感觉。如果下拉的距离足够大，在松手的时候就会执行刷新操作，如果距离不够大，就仅仅重新隐藏下拉头。

        具体的刷新操作会在RefreshingTask中进行，其中在doInBackground方法中回调了PullToRefreshListener接口的onRefresh方法，这也是大家在使用RefreshableView时必须要去实现的一个接口，因为具体刷新的逻辑就应该写在onRefresh方法中，后面会演示使用的方法。

        另外每次在下拉的时候都还会调用updateHeaderView方法来改变下拉头中的数据，比如箭头方向的旋转，下拉文字描述的改变等。更加深入的理解请大家仔细去阅读RefreshableView中的代码。
        现在我们已经把下拉刷新的所有功能都完成了，接下来就要看一看如何在项目中引入下拉刷新了。打开或新建activity_main.xml作为程序主界面的布局，加入如下代码： [html] view plaincopy
        1. <relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
        2. xmlns:tools="http://schemas.android.com/tools"
        3. android:layout_width="match_parent"
        4. android:layout_height="match_parent"
        5. tools:context=".MainActivity" >
        7. <com.example.pulltorefreshtest.refreshableview
        8. android:id="@+id/refreshable_view"
        9. android:layout_width="fill_parent"
        10. android:layout_height="fill_parent" >
        12. <listview class="alt"
        13. android:id="@+id/list_view"
        14. android:layout_width="fill_parent"
        15. android:layout_height="fill_parent" >
        19. 可以看到，我们在自定义的RefreshableView中加入了一个ListView，这就意味着给这个ListView加入了下拉刷新的功能，就是这么简单！
          然后我们再来看一下程序的主Activity，打开或新建MainActivity，加入如下代码： [java] view plaincopy
          1. public class MainActivity extends Activity {
          3. RefreshableView refreshableView;
          4. ListView listView;
          5. ArrayAdapter adapter;
          6. String[] items = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L" };
          8. @Override
          9. protected void onCreate(Bundle savedInstanceState) {
          10. super.onCreate(savedInstanceState);
          11. requestWindowFeature(Window.FEATURE_NO_TITLE);
          12. setContentView(R.layout.activity_main);
          13. refreshableView = (RefreshableView) findViewById(R.id.refreshable_view);
          14. listView = (ListView) findViewById(R.id.list_view);
          15. adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, items);
          16. listView.setAdapter(adapter);
          17. refreshableView.setOnRefreshListener(new PullToRefreshListener() {
          18. @Override
          19. public void onRefresh() {
          20. try {
          21. Thread.sleep(3000);
          22. } catch (InterruptedException e) {
          23. e.printStackTrace();
          24. }
          25. refreshableView.finishRefreshing();
          26. }
          27. }, 0);
          28. }
          30. }

            可以看到，我们通过调用RefreshableView的setOnRefreshListener方法注册了一个监听器，当ListView正在刷新时就会回调监听器的onRefresh方法，刷新的具体逻辑就在这里处理。而且这个方法已经自动开启了线程，可以直接在onRefresh方法中进行耗时操作，比如向服务器请求最新数据等，在这里我就简单让线程睡眠3秒钟。另外在onRefresh方法的最后，一定要调用RefreshableView中的finishRefreshing方法，这个方法是用来通知RefreshableView刷新结束了，不然我们的ListView将一直处于正在刷新的状态。
            不知道大家有没有注意到，setOnRefreshListener这个方法其实是有两个参数的，我们刚刚也是传入了一个不起眼的0。那这第二个参数是用来做什么的呢？由于RefreshableView比较智能，它会自动帮我们记录上次刷新完成的时间，然后下拉的时候会在下拉头中显示距上次刷新已过了多久。这是一个非常好用的功能，让我们不用再自己手动去记录和计算时间了，但是却存在一个问题。如果当前我们的项目中有三个地方都使用到了下拉刷新的功能，现在在一处进行了刷新，其它两处的时间也都会跟着改变！因为刷新完成的时间是记录在配置文件中的，由于在一处刷新更改了配置文件，导致在其它两处读取到的配置文件时间已经是更改过的了。那解决方案是什么？就是每个用到下拉刷新的地方，给setOnRefreshListener方法的第二个参数中传入不同的id就行了。这样各处的上次刷新完成时间都是单独记录的，相互之间就不会再有影响。
            好了，全部的代码都在这里了，让我们来运行一下，看看效果吧。

天涯狂人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android下拉刷新，SwipeRefreshLayout的使用
Android_小黑
03-20 858
相信小伙伴在APP里面都使用过下拉刷新这个功能，像微信、QQ等各种APP都有下拉刷新这个功能，那么它究竟是如何实现的呢？来看看！ 效果图先行： 可以看到图中，下拉刷新进行了事件处理，并且下拉刷新的样式比较漂亮（鲜艳。。。） 首先来看看XML布局文件 可以看到，SwipeRefreshLayout是一个根布局，然后里面具体放什么看你需求了！ <?xml version="1.0" encod...
Android中的RecyclerView下拉/上拉刷新数据
m0_62278064的博客
06-07 4575
RecyclerView上拉/下拉刷新数据
2024年安卓最全android下拉刷新——swipeRefresh的使用，2024年最新阿里三面通过率
最新发布
2401_84122917的博客
05-15 369
简历首选内推方式，速度快，效率高啊！然后可以在拉钩，boss，脉脉，大街上看看。简历上写道熟悉什么技术就一定要去熟悉它，不然被问到不会很尴尬！做过什么项目，即使项目体量不大，但也一定要熟悉实现原理！不是你负责的部分，也可以看看同事是怎么实现的，换你来做你会怎么做？做过什么，会什么是广度问题，取决于项目内容。但做过什么，达到怎样一个境界，这是深度问题，和个人学习能力和解决问题的态度有关了。大公司看深度，小公司看广度。大公司面试你会的，小公司面试他们用到的你会不会，也就是岗位匹配度。面试过程一定要有礼貌！
Android RecyclerView 使用大全 - 基础使用，item 动画，下拉刷新等
程序员徐师兄的博客
03-10 2910
是官方在5.0之后新添加的控件，推出用来替代传统的ListView和GridView列表控件。
Android下拉刷新
Maxi的专栏
11-16 1579
app开发中下拉刷新是最常接触到的一个功能，也有很多开源的框架，封装的非常棒。前段时间了解了一下ViewDragHelper，遂用它实现了下拉刷新的功能。 大概和我之前的ViewDragHelper之拖动加载（类似淘宝）这篇代码类似。只是做了相关改动。具体的可以看一下那篇博文了解一下用到的ViewDragHelper的一些知识点。该界面主要是一个LinearLayout，上面的下拉刷新是一个
Android下拉刷新完全解析,教你如何一分钟实现下拉刷新功能(附源码)
09-05
总结来说，实现Android下拉刷新的关键步骤包括： 1. 创建自定义布局，包含下拉头和ListView。 2. 监听ListView的滚动事件，判断是否在顶部并触发下拉刷新。 3. 用户松手时执行刷新操作，并更新界面状态。 4. 数据...
Android SwipeRefreshLayout下拉刷新源码解析
09-01
在Android开发中，SwipeRefreshLayout是谷歌提供的一种便捷的下拉刷新组件，它被引入到support库的v4包中，自v19.1版本开始可用。SwipeRefreshLayout的设计旨在简化应用中列表或网格视图的刷新操作，为用户提供一个...
Android下拉刷新控件SwipeRefreshLayout源码解析
09-01
在Android开发中，`SwipeRefreshLayout` 是一个非常常见的组件，用于实现下拉刷新的功能。它提供了一个简洁的用户界面，允许用户通过向下拖动来刷新内容。本文将深入解析`SwipeRefreshLayout`的源码，帮助开发者更好...
PullToRefresh使用详解
cx983299475的博客
08-21 483
相关文章： http://blog.csdn.net/harvic880925/article/details/17792755 1、《List控件使用--SimpleAdapter使用详解（一）》 2、《List控件使用--SimpleAdapter使用详解（二）》 3、《PullToRefresh使用详解(二)---重写BaseAdapter实现复杂
Android中实现下拉刷新
hyjzcy的专栏
11-13 631
需求：项目中的消息列表界面要求实现类似sina微博的下拉刷新； 思路：一般的消息列表为ListView类型，将list加载到adapter中，再将adapter加载到ListView中，从而实现消息列表的展示。而下拉刷新要求给消息列表加一个头部，其中有图片（向上/向下箭头）和提示字样（下拉刷新/松开刷新），从而我们需要做的事情：1.需要做一个head.xm来实现头部的样式定义；2.需要自定义一个
安卓下拉刷新
12-01
eclipse内制作的一种仿android studio版下拉刷新控件
液体拉动要刷新：:repeat_button:用于抖动的自定义刷新指示器
02-03
提拉液体 一个美丽而自定义的刷新指示器，从获得很大启发。 目录 正在安装 1.依赖它 将此添加到包的pubspec.yaml文件中： dependencies : liquid_pull_to_refresh : ^2.0.0 2.安装 您可以从命令行安装软件包： 与pub ： $ pub get 与Flutter ： $ flutter packages get 3.导入 现在，在Dart代码中，您可以使用： import 'package:liquid_pull_to_refresh/liquid_pull_to_refresh.dart' ; 用法 为了在LiquidPullToRefresh应用程序中添加此自定义刷新指示器，您只需将ListView或GridView包装在LiquidPullToRefresh 。 您还提供了onRefresh参数的值，它是刷新回调。 注意LiquidPullToRefresh仅可用于垂直滚动视图。 例如： LiquidPullToRefresh ( key : _refreshIndicatorKey, /
微信小程序采坑之scroll-view与enablePullDownRefresh（下拉刷新）不可共用
mao871863224的博客
02-10 3576
踩坑踩坑踩坑 以下是正常的顶部下拉刷新数据的步骤以及代码 但是要注意的一点是 html中srcoll-view标签下的页面进行这些操作是无效的 一、onPullDownRefresh回调 onPullDownRefresh: function () { console.log('onPullDownRefresh') this.queryData(id) }, 二、enablePullD...
uni-app开启下拉刷新 以及如何使用setTimeout 以及点击按钮实现刷新
weixin_49393290的博客
12-19 6141
enablePullDownRefresh 在pages.json文件中的页面配置中添加"enablePullDownRefresh"=true这个属性即可 但是这样只会添加一个刷新的样式，您想一下拉也同时刷新页面的内容 并且同时设定一个时间来关闭这个刷新的状态（uni.stopPullDownRefresh） js 刷新前 刷新后 监听下拉刷新，不需要在html写啥，直接加一个就行 onPullDownRefresh(){ ...
PullToRefresh: 简洁易用的下拉刷新库
gitblog_00022的博客
03-18 320
PullToRefresh: 简洁易用的下拉刷新库 如果你正在为你的应用或网站寻找一个优雅的下拉刷新解决方案，那么不妨试试 PullToRefresh。 什么是PullToRefresh？ PullToRefresh是一个轻量级的JavaScript库，它提供了一个简单的API，可以帮助你在任何HTML元素上实现下拉刷新功能。只需几行代码，你就可以在你的应用中添加下拉刷新功能，让你的应用更加生动有...
使用PullToRefresh时停止刷新方法失灵
hello__words的博客
06-15 1537
我们在使用框架：  PullToRefreshListView 实现下拉或者上拉加载时候，可能在上拉 完成时候，调用onRefreshComplete方法去停止 刷新操作，但是，可能无效，测试产生原因，刷新获取数据时候，时间太短，就会出现该问题 我们可以 延迟 1秒左右，在调用onRefreshComplete 方法，可以解决该问题mListView.postDelayed(new Ru
微信小程序 "enablePullDownRefresh" 下拉刷新无效
热门推荐
xiaochun365的博客
05-08 3万+
“enablePullDownRefresh”: “true” 在 Page 中定义 onPullDownRefresh 处理函数，监听该页面用户下拉刷新事件。 需要在 config 的window选项中开启 enablePullDownRefresh。 当处理完数据刷新后，wx.stopPullDownRefresh可以停止当前页面的下拉刷新。这个问题困惑了挺长时间，在群里提问也没能找打答案
Flutter 下拉刷新、上拉加载
yang_6799的博客
12-01 4358
pull_to_refresh的简介与使用
android下拉刷新完全解析,教你如何一分钟实现下拉刷新功能,Android使用recyclerview打造真正的下拉刷新上拉加载效果...
weixin_35973521的博客
05-27 1138
前言前段时间需要用到recyclerview，就想找个封装好的下拉刷新，上拉加载的库，结果愣是没找到，便自己写了一个。注意：我说的是“上拉加载”，不是滑到底部自动加载。 虽然现在自动加载是主流和趋势，但也不排除有时候就需要用到上拉加载啊，毕竟林子大了，什么样的产品经理都有对吧。代码写好后，准备发布到bintray的时候，向同事征求这个项目的名字，同事说：“就叫DZTRecyclerview!” 不...
android 读取实时热点新闻并显示
01-01
5. 下拉刷新和加载更多：为了保持实时性，可以实现下拉刷新和加载更多功能。当用户下拉列表时，可以重新请求最新的新闻数据，并更新列表展示；当用户滑动到列表底部时，可以自动加载更多的新闻数据。 6. 缓存数据：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值