file_path stringlengths 3 280 | file_language stringclasses 66 values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108 values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
app/src/main/java/org/yczbj/ycrefreshview/app/Constant.java | Java | package org.yczbj.ycrefreshview.app;
import org.yczbj.ycrefreshview.R;
/**
* Description:
* Update:
* CreatedTime:2018/01/03
* Author:yc
*/
public class Constant {
public interface viewType{
int typeView = 0; //自定义
int typeBanner = 1; //轮播图
int typeGv = 2; //九宫格
int typeTitle = 3; //标题
int typeMore = 4; //更多
int typeAd = 5; //广告
int typeList2 = 6; //list2
int typeAd2 = 7 ; //广告2
int typeGv3 = 8; //list3
int typeList4 = 9; //list4
int typeGvBottom = 10; //九宫格
int typeList5 = 11; //list4
int typeRecycler = 12; //list4
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/app/SysUtils.java | Java | package org.yczbj.ycrefreshview.app;
import android.app.Activity;
import android.content.Context;
import android.content.res.AssetManager;
import android.graphics.Color;
import android.os.Build;
import android.view.Display;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import java.io.IOException;
import java.lang.reflect.Field;
public class SysUtils {
public static int Dp2Px(Context context, float dp) {
if (context==null){
//避免空指针异常
context = BaseApp.getApp();
}
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dp * scale + 0.5f);
}
public static int getScreenWidth(Activity activity){
int width = 0;
WindowManager windowManager = activity.getWindowManager();
Display display = windowManager.getDefaultDisplay();
width=display.getWidth();
return width;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/collapsing/EightCollapsingActivity.java | Java | package org.yczbj.ycrefreshview.collapsing;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.appcompat.widget.Toolbar;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import com.yc.cn.ycbannerlib.banner.BannerView;
import com.yc.cn.ycbannerlib.banner.adapter.AbsStaticPagerAdapter;
import com.yc.cn.ycbannerlib.banner.hintview.ColorPointHintView;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AdData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import java.util.List;
public class EightCollapsingActivity extends AppCompatActivity {
YCRefreshView recyclerView;
PersonAdapter adapter;
private Handler handler = new Handler();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_collapsing);
setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setAdapter(adapter = new PersonAdapter(this));
adapter.setMore(R.layout.view_more, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getPersonList(0));
}
}, 1000);
}
});
adapter.addAll(DataProvider.getPersonList(0));
BannerView rollPagerView = findViewById(R.id.rollPagerView);
rollPagerView.setHintView(new ColorPointHintView(this, Color.YELLOW,Color.GRAY));
rollPagerView.setAdapter(new BannerAdapter());
}
private class BannerAdapter extends AbsStaticPagerAdapter {
private List<AdData> list;
public BannerAdapter(){
list = DataProvider.getAdList();
}
@Override
public View getView(ViewGroup container, final int position) {
ImageView imageView = new ImageView(EightCollapsingActivity.this);
imageView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT));
imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
//加载图片
Glide.with(EightCollapsingActivity.this)
.load(list.get(position).getDrawable())
.placeholder(R.drawable.default_image)
.into(imageView);
//点击事件
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
return imageView;
}
@Override
public int getCount() {
return list.size();
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/ChildEntity.java | Java | package org.yczbj.ycrefreshview.cover;
/**
* 子项数据的实体类
*/
public class ChildEntity {
private String child;
public ChildEntity(String child) {
this.child = child;
}
public String getChild() {
return child;
}
public void setChild(String child) {
this.child = child;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/CoverActivity.java | Java | package org.yczbj.ycrefreshview.cover;
import android.content.Intent;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import org.yczbj.ycrefreshview.R;
public class CoverActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_cover);
findViewById(R.id.tv_1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(CoverActivity.this, CoverFirstActivity.class));
}
});
findViewById(R.id.tv_2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(CoverActivity.this, CoverSecondActivity.class));
}
});
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/CoverFirstActivity.java | Java | package org.yczbj.ycrefreshview.cover;
import android.annotation.SuppressLint;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.viewpager.widget.ViewPager;
import androidx.appcompat.app.AppCompatActivity;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.cover.cover.GalleryImageView;
import java.util.ArrayList;
import java.util.List;
public class CoverFirstActivity extends AppCompatActivity {
GalleryImageView scrollGalleryView;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_cover_first);
scrollGalleryView = findViewById(R.id.scroll_gallery_view);
initImage();
}
private void initImage(){
List<Object> picsBeanList = new ArrayList<>();
for (int i=0 ; i<10 ; i++){
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190916/asphpxyzcymmbhcpkkqejspgyzjqvsbs.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/201909/982823160a0693d37768a2c7ae787cef.jpeg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190916/asphpxyzcymmbhcpkkqejspgyzjqvsbs.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/201909/982823160a0693d37768a2c7ae787cef.jpeg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190916/asphpxyzcymmbhcpkkqejspgyzjqvsbs.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/201909/982823160a0693d37768a2c7ae787cef.jpeg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190916/asphpxyzcymmbhcpkkqejspgyzjqvsbs.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/201909/982823160a0693d37768a2c7ae787cef.jpeg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
picsBeanList.add("https://pic1.yilu.cn/20190917/fqlcmvycypjmmgdvdbrhgfzpsiidmjva.jpg");
}
scrollGalleryView
//设置viewPager底部缩略图大小尺寸
//设置是否支持缩放
//设置切换的图片索引
.setPosition(0)
//设置缩放的倍数
//设置是否隐藏底部缩略图，主要是防止后期产品参考懂车帝，又不要底部滑动，非常灵活修改
.hideThumbnails(false)
//添加滑动事件，也可以不用添加
.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@SuppressLint("SetTextI18n")
@Override
public void onPageSelected(int position) {
}
@Override
public void onPageScrollStateChanged(int state) {
}
})
.addUrlToRecyclerView(picsBeanList);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/CoverSecondActivity.java | Java | package org.yczbj.ycrefreshview.cover;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.RecyclerView;
import android.widget.Toast;
import com.ycbjie.adapter.AbsGroupAdapter;
import com.ycbjie.adapter.GroupLayoutManager;
import com.ycbjie.adapter.GroupViewHolder;
import com.ycbjie.adapter.OnChildClickListener;
import com.ycbjie.adapter.OnFooterClickListener;
import com.ycbjie.adapter.OnHeaderClickListener;
import org.yczbj.ycrefreshview.R;
import java.util.ArrayList;
import java.util.List;
public class CoverSecondActivity extends AppCompatActivity {
private GroupedAdapter mAdapter;
private List<GroupEntity> list = new ArrayList<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recycler_view);
RecyclerView mRecyclerView = findViewById(R.id.recycler_view);
mAdapter = new GroupedAdapter(this, list);
mAdapter.setOnHeaderClickListener(new OnHeaderClickListener() {
@Override
public void onHeaderClick(AbsGroupAdapter adapter, GroupViewHolder holder,
int groupPosition) {
Toast.makeText(CoverSecondActivity.this,
"组头：groupPosition = " + groupPosition, Toast.LENGTH_LONG).show();
}
});
mAdapter.setOnFooterClickListener(new OnFooterClickListener() {
@Override
public void onFooterClick(AbsGroupAdapter adapter, GroupViewHolder holder,
int groupPosition) {
Toast.makeText(CoverSecondActivity.this,
"组尾：groupPosition = " + groupPosition, Toast.LENGTH_LONG).show();
GroupEntity groupEntity = list.get(groupPosition);
//设置footer点击后不可见状态
groupEntity.setFooter("");
ArrayList<ChildEntity> children = groupEntity.getChildren();
int size = children.size();
for (int j = 0; j < 10; j++) {
children.add(new ChildEntity("逗比"));
}
mAdapter.notifyChildRangeInserted(groupPosition,size,10);
}
});
mAdapter.setOnChildClickListener(new OnChildClickListener() {
@Override
public void onChildClick(AbsGroupAdapter adapter, GroupViewHolder holder,
int groupPosition, int childPosition) {
Toast.makeText(CoverSecondActivity.this,"子项：groupPosition = " + groupPosition
+ ", childPosition = " + childPosition, Toast.LENGTH_LONG).show();
}
});
mRecyclerView.setAdapter(mAdapter);
//直接使用GroupGridLayoutManager实现子项的Grid效果
GroupLayoutManager gridLayoutManager = new GroupLayoutManager(this, 3, mAdapter){
//重写这个方法 改变子项的SpanSize。
//这个跟重写SpanSizeLookup的getSpanSize方法的使用是一样的。
@Override
public int getChildSpanSize(int groupPosition, int childPosition) {
return super.getChildSpanSize(groupPosition, childPosition);
}
};
mRecyclerView.setLayoutManager(gridLayoutManager);
getData();
}
private void getData() {
ArrayList<GroupEntity> groups = getGroups(10, 8);
list.addAll(groups);
mAdapter.notifyDataSetChanged();
}
/**
* 获取组列表数据
*
* @param groupCount 组数量
* @param childrenCount 每个组里的子项数量
* @return
*/
public static ArrayList<GroupEntity> getGroups(int groupCount, int childrenCount) {
ArrayList<GroupEntity> groups = new ArrayList<>();
for (int i = 0; i < groupCount; i++) {
ArrayList<ChildEntity> children = new ArrayList<>();
for (int j = 0; j < childrenCount; j++) {
children.add(new ChildEntity("第" + (i + 1) + "组第" + (j + 1) + "项"));
}
groups.add(new GroupEntity("第" + (i + 1) + "组头部",
"第" + (i + 1) + "组尾部", children));
}
return groups;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/GroupEntity.java | Java | package org.yczbj.ycrefreshview.cover;
import java.util.ArrayList;
/**
* 组数据的实体类
*/
public class GroupEntity {
private String header;
private String footer;
private ArrayList<ChildEntity> children;
private boolean isExpand;
public GroupEntity(String header, String footer, ArrayList<ChildEntity> children) {
this.header = header;
this.footer = footer;
this.children = children;
}
public GroupEntity(String header, String footer, ArrayList<ChildEntity> children, boolean isExpand) {
this.header = header;
this.footer = footer;
this.children = children;
this.isExpand = isExpand;
}
public String getHeader() {
return header;
}
public void setHeader(String header) {
this.header = header;
}
public String getFooter() {
return footer;
}
public void setFooter(String footer) {
this.footer = footer;
}
public ArrayList<ChildEntity> getChildren() {
return children;
}
public void setChildren(ArrayList<ChildEntity> children) {
this.children = children;
}
public boolean isExpand() {
return isExpand;
}
public void setExpand(boolean expand) {
isExpand = expand;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/GroupedAdapter.java | Java | package org.yczbj.ycrefreshview.cover;
import android.content.Context;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.ycbjie.adapter.AbsGroupAdapter;
import com.ycbjie.adapter.GroupViewHolder;
import org.yczbj.ycrefreshview.R;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/9/18
* desc : 这是普通的分组Adapter 每一个组都有头部、尾部和子项。
* revise:
* </pre>
*/
public class GroupedAdapter extends AbsGroupAdapter {
private List<GroupEntity> mGroups;
public GroupedAdapter(Context context, List<GroupEntity> groups) {
super(context);
mGroups = groups;
}
@Override
public int getGroupCount() {
return mGroups == null ? 0 : mGroups.size();
}
@Override
public int getChildrenCount(int groupPosition) {
if (mGroups!=null){
ArrayList<ChildEntity> children = mGroups.get(groupPosition).getChildren();
return children == null ? 0 : children.size();
}
return 0;
}
@Override
public boolean hasHeader(int groupPosition) {
return true;
}
@Override
public boolean hasFooter(int groupPosition) {
return true;
}
@Override
public int getHeaderLayout(int viewType) {
return R.layout.item_car_picture_header;
}
@Override
public int getFooterLayout(int viewType) {
return R.layout.item_car_picture_footer;
}
@Override
public int getChildLayout(int viewType) {
return R.layout.item_car_picture_view;
}
@Override
public void onBindHeaderViewHolder(GroupViewHolder holder, int groupPosition) {
GroupEntity entity = mGroups.get(groupPosition);
TextView textView = holder.get(R.id.tv_header);
textView.setText(entity.getHeader());
}
@Override
public void onBindFooterViewHolder(GroupViewHolder holder, int groupPosition) {
GroupEntity entity = mGroups.get(groupPosition);
ImageView imageView = holder.get(R.id.iv_image);
TextView tvFooterMore = holder.get(R.id.tv_footer_more);
String footer = entity.getFooter();
if (footer==null || footer.length()==0){
//设置不可见
imageView.setVisibility(View.GONE);
tvFooterMore.setVisibility(View.GONE);
} else {
//设置可见
imageView.setVisibility(View.VISIBLE);
tvFooterMore.setVisibility(View.VISIBLE);
}
}
@Override
public void onBindChildViewHolder(GroupViewHolder holder, int groupPosition, int childPosition) {
ChildEntity entity = mGroups.get(groupPosition).getChildren().get(childPosition);
ImageView imageView = holder.get(R.id.iv_image);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/cover/CoverAdapter.java | Java | package org.yczbj.ycrefreshview.cover.cover;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import org.yczbj.ycrefreshview.R;
import java.util.List;
public class CoverAdapter extends RecyclerView.Adapter<CoverAdapter.ViewHolder> {
private Context mContext;
private List<Object> mPictureList;
private onItemClick clickCb;
public CoverAdapter(Context c) {
mContext = c;
}
public CoverAdapter(Context c, onItemClick cb, List<Object> mPictureListt) {
this.mPictureList = mPictureListt;
mContext = c;
clickCb = cb;
}
@Override
public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View v = LayoutInflater.from(mContext).inflate(R.layout.item_gallery_image_view, parent, false);
return new ViewHolder(v);
}
@Override
public void onBindViewHolder(@NonNull ViewHolder holder, final int position) {
if (position >= mPictureList.size()) {
return;
}
Object item = mPictureList.get(position);
if (item instanceof Integer || item instanceof String){
Glide.with(holder.img.getContext())
.asDrawable()
//注意，这里拉取原始图片
.diskCacheStrategy(DiskCacheStrategy.DATA)
.load(item)
.into(holder.img);
}
holder.img.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (clickCb != null) {
clickCb.clickItem(position);
}
}
});
}
@Override
public int getItemCount() {
return mPictureList==null ? 0 : mPictureList.size();
}
class ViewHolder extends RecyclerView.ViewHolder {
ImageView img;
ViewHolder(View itemView) {
super(itemView);
img = itemView.findViewById(R.id.iv_image);
}
}
public interface onItemClick {
void clickItem(int pos);
}
public void setOnClickLstn(onItemClick cb) {
this.clickCb = cb;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/cover/CoverImageAdapter.java | Java | package org.yczbj.ycrefreshview.cover.cover;
import android.content.Context;
import android.graphics.drawable.Drawable;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.viewpager.widget.PagerAdapter;
import android.view.View;
import android.view.ViewGroup;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.target.SimpleTarget;
import com.bumptech.glide.request.transition.Transition;
import com.ycbjie.zoomimagelib.view.ZoomImageView;
import java.util.List;
public class CoverImageAdapter extends PagerAdapter {
private List<Object> imageUrls;
private Context mContext;
public CoverImageAdapter(List<Object> imageUrls, Context mContext) {
this.imageUrls = imageUrls;
this.mContext = mContext;
}
@NonNull
@Override
public Object instantiateItem(@NonNull ViewGroup container, int position) {
Object image = imageUrls.get(position);
final ZoomImageView photoView = new ZoomImageView(mContext);
if (image instanceof Integer || image instanceof String){
Glide.with(photoView.getContext())
.asDrawable()
//注意，这里拉取原始图片
.diskCacheStrategy(DiskCacheStrategy.DATA)
.load(image)
.into(new SimpleTarget<Drawable>() {
@Override
public void onResourceReady(Drawable resource, @Nullable Transition<? super Drawable> transition) {
if (resource!=null){
photoView.setImageDrawable(resource);
}
}
@Override
public void onLoadFailed(@Nullable Drawable errorDrawable) {
super.onLoadFailed(errorDrawable);
}
});
}
container.addView(photoView);
return photoView;
}
@Override
public int getCount() {
return imageUrls != null ? imageUrls.size() : 0;
}
@Override
public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
return view == object;
}
@Override
public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
container.removeView((View) object);
}
@Override
public int getItemPosition(@NonNull Object object) {
return POSITION_NONE;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/cover/GalleryImageView.java | Java | package org.yczbj.ycrefreshview.cover.cover;
import android.content.Context;
import androidx.viewpager.widget.ViewPager;
import androidx.recyclerview.widget.RecyclerView;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.LinearLayout;
import com.yc.cover.CoverLayoutManger;
import com.yc.cover.CoverRecyclerView;
import org.yczbj.ycrefreshview.R;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/05/30
* desc : 支持滑动viewpager图片浏览控件
* revise: https://github.com/yangchong211/YCGallery
* </pre>
*/
public class GalleryImageView extends LinearLayout {
private Context context;
private CoverImageAdapter pagerAdapter;
/**
* url图片
*/
private List<Object> mPictureList;
private int thumbnailSize;
private int thumbnailHeightSize;
private GalleryViewPager viewPager;
private CoverRecyclerView recyclerView;
private int position = 0;
public GalleryImageView(Context context, AttributeSet attrs) {
super(context, attrs);
this.context = context;
init();
}
private void init() {
mPictureList = new ArrayList<>();
setOrientation(VERTICAL);
LayoutInflater inflater = LayoutInflater.from(context);
inflater.inflate(R.layout.view_scroll_gallery, this, true);
recyclerView = findViewById(R.id.recycler_view);
viewPager = findViewById(R.id.viewPager);
recyclerView.setVisibility(VISIBLE);
initializeViewPager();
}
public GalleryViewPager getViewPager() {
return viewPager;
}
public int getCurrentItem() {
return viewPager.getCurrentItem();
}
public GalleryImageView addOnPageChangeListener(final ViewPager.OnPageChangeListener listener) {
viewPager.clearOnPageChangeListeners();
viewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
listener.onPageScrolled(position, positionOffset, positionOffsetPixels);
}
@Override
public void onPageSelected(int position) {
if (recyclerView.getVisibility()==View.VISIBLE){
if(recyclerView.getCoverFlowLayout()!=null){
recyclerView.getCoverFlowLayout().smoothScrollToPosition(recyclerView,
new RecyclerView.State(), position);
}
}
listener.onPageSelected(position);
}
@Override
public void onPageScrollStateChanged(int state) {
listener.onPageScrollStateChanged(state);
}
});
return this;
}
public GalleryImageView addUrlToRecyclerView(List<Object> url){
if (url == null){
throw new NullPointerException("url may not be null!");
}
recyclerView.setVisibility(VISIBLE);
mPictureList.addAll(url);
initRecyclerView(mPictureList);
if (viewPager!=null){
viewPager.setCurrentItem(position);
}
pagerAdapter.notifyDataSetChanged();
return this;
}
public GalleryImageView setCurrentItem(int i) {
viewPager.setCurrentItem(i, false);
return this;
}
public GalleryImageView setThumbnailSize(int thumbnailSize,int thumbnailHeightSize) {
this.thumbnailSize = thumbnailSize;
this.thumbnailHeightSize = thumbnailHeightSize;
return this;
}
public GalleryImageView setPosition(int position) {
this.position = position;
return this;
}
public GalleryImageView hideThumbnails(boolean thumbnailsHiddenEnabled) {
if (thumbnailsHiddenEnabled){
recyclerView.setVisibility(GONE);
} else {
recyclerView.setVisibility(VISIBLE);
}
return this;
}
private void initializeViewPager() {
pagerAdapter = new CoverImageAdapter(mPictureList,context);
viewPager.setAdapter(pagerAdapter);
viewPager.setCurrentItem(position);
}
private void initRecyclerView(final List<Object> mPictureList) {
CoverAdapter adapter = new CoverAdapter(context, null, mPictureList);
recyclerView.setAdapter(adapter);
recyclerView.setAlphaItem(true);
recyclerView.setFlatFlow(true);
recyclerView.setIntervalRatio(1.05f);
recyclerView.getCoverFlowLayout().scrollToPosition(position);
recyclerView.setOnItemSelectedListener(new CoverLayoutManger.OnSelected() {
@Override
public void onItemSelected(int position) {
if (position < mPictureList.size() && position>=0) {
setCurrentItem(position);
}
}
});
adapter.setOnClickLstn(new CoverAdapter.onItemClick() {
@Override
public void clickItem(int pos) {
if (mPictureList.size()>pos && pos>=0){
setCurrentItem(pos);
}
}
});
}
public RecyclerView getRecyclerView() {
return recyclerView;
}
private OnPhotoClickListener onPhotoClickListener;
public interface OnPhotoClickListener{
/**
* 点击事件
*/
void onClick();
}
/**
* 设置点击事件
* @param onPhotoClickListener listener
*/
public void setOnPhotoClickListener(OnPhotoClickListener onPhotoClickListener) {
this.onPhotoClickListener = onPhotoClickListener;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/cover/cover/GalleryViewPager.java | Java | package org.yczbj.ycrefreshview.cover.cover;
import android.content.Context;
import androidx.viewpager.widget.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2017/05/30
* desc : 自定义ViewPager
* revise:
* </pre>
*/
public class GalleryViewPager extends ViewPager {
private boolean isLocked;
public GalleryViewPager(Context context) {
super(context);
isLocked = false;
}
public GalleryViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
isLocked = false;
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
if(!isLocked) {
try {
return super.onInterceptTouchEvent(ev);
} catch (IllegalArgumentException e) {
e.printStackTrace();
return false;
}
}
return false;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
return !isLocked && super.onTouchEvent(ev);
}
public void setLocked(boolean isLocked) {
this.isLocked = isLocked;
}
public boolean isLocked() {
return isLocked;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/data/AdData.java | Java | package org.yczbj.ycrefreshview.data;
public class AdData {
private String image;
private int drawable;
public AdData(){}
public String getImage() {
return image;
}
public void setImage(String image) {
this.image = image;
}
public int getDrawable() {
return drawable;
}
public void setDrawable(int drawable) {
this.drawable = drawable;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/data/AppUtils.java | Java | package org.yczbj.ycrefreshview.data;
import android.content.Context;
import android.content.res.Resources;
import android.util.DisplayMetrics;
public class AppUtils {
public static float convertDpToPixel(float dp, Context context){
Resources resources = context.getResources();
DisplayMetrics metrics = resources.getDisplayMetrics();
float px = dp * (metrics.densityDpi / 160f);
return px;
}
public static float convertPixelsToDp(float px, Context context){
Resources resources = context.getResources();
DisplayMetrics metrics = resources.getDisplayMetrics();
float dp = px / (metrics.densityDpi / 160f);
return dp;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/data/DataProvider.java | Java | package org.yczbj.ycrefreshview.data;
import android.content.res.TypedArray;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.app.BaseApp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class DataProvider {
private static ArrayList<Integer> getData(){
ArrayList<Integer> data = new ArrayList<>();
TypedArray bannerImage = BaseApp.getApp().getResources().obtainTypedArray(R.array.image_girls);
for (int i = 0; i < 30 ; i++) {
int image = bannerImage.getResourceId(i, R.drawable.girl2);
data.add(image);
}
bannerImage.recycle();
return data;
}
private static ArrayList<Integer> getData2(){
ArrayList<Integer> data = new ArrayList<>();
TypedArray bannerImage = BaseApp.getApp().getResources().obtainTypedArray(R.array.data_narrow_Image);
for (int i = 0; i < 30 ; i++) {
int image = bannerImage.getResourceId(i, R.drawable.girl2);
data.add(image);
}
bannerImage.recycle();
return data;
}
public static List<PersonData> getPersonList(int size){
if (size==0){
size = 16;
}
ArrayList<PersonData> arr = new ArrayList<>();
ArrayList<Integer> data = getData();
for (int i=0 ; i< size ; i++){
PersonData person = new PersonData();
person.setName("小杨逗比"+i);
person.setImage(data.get(i));
person.setSign("杨充"+i);
arr.add(person);
}
return arr;
}
public static List<PersonData> getList(int size){
if (size==0){
size = 16;
}
ArrayList<PersonData> arr = new ArrayList<>();
ArrayList<Integer> data = getData2();
for (int i=0 ; i< size ; i++){
PersonData person = new PersonData();
person.setName("小杨逗比"+i);
person.setImage(data.get(i));
person.setSign("杨充"+i);
arr.add(person);
}
return arr;
}
public static List<AdData> getAdList(){
ArrayList<AdData> arr = new ArrayList<>();
ArrayList<Integer> data = getData();
for (int i=0 ; i<data.size() ; i++){
AdData ad = new AdData();
ad.setDrawable(data.get(i));
arr.add(ad);
}
return arr;
}
public static List<Object> getPersonWithAds(int page){
ArrayList<Object> arrAll = new ArrayList<>();
List<AdData> arrAd = getAdList();
int index = 0;
for (PersonData person : getPersonList(page)) {
arrAll.add(person);
//按比例混合广告
if (Math.random()<0.2){
arrAll.add(arrAd.get(index%arrAd.size()));
index++;
}
}
return arrAll;
}
private static final PictureData[] VIRTUAL_PICTURE = {
new PictureData(566,800,R.drawable.girl2),
new PictureData(2126,1181,R.drawable.girl11),
new PictureData(1142,800,R.drawable.girl12),
new PictureData(550,778,R.drawable.girl3),
new PictureData(1085,755,R.drawable.girl4),
new PictureData(656,550,R.drawable.girl5),
new PictureData(1920,938,R.drawable.girl6),
new PictureData(1024,683,R.drawable.girl7),
new PictureData(723,1000,R.drawable.girl9),
new PictureData(2000,1667,R.drawable.girl10),
new PictureData(723,1000,R.drawable.girl13),
new PictureData(2000,1667,R.drawable.girl14),
};
public static ArrayList<PictureData> getPictures(){
ArrayList<PictureData> arrayList = new ArrayList<>();
arrayList.addAll(Arrays.asList(VIRTUAL_PICTURE));
return arrayList;
}
public static final int[] NARROW_IMAGE = {
R.drawable.bg_small_autumn_tree_min,
R.drawable.bg_small_kites_min,
R.drawable.bg_small_lake_min,
R.drawable.bg_small_leaves_min,
R.drawable.bg_small_magnolia_trees_min,
R.drawable.bg_small_solda_min,
R.drawable.bg_small_tree_min,
R.drawable.bg_small_tulip_min,
R.drawable.bg_small_kites_min,
};
public static ArrayList<Integer> getNarrowImage(int page){
ArrayList<Integer> arrayList = new ArrayList<>();
if (page == 4) {
return arrayList;
}
for (int i = 0; i < NARROW_IMAGE.length; i++) {
arrayList.add(NARROW_IMAGE[i]);
}
return arrayList;
}
public static ArrayList<String> getTag(){
ArrayList<String> list = new ArrayList<>();
list.add("杨充");
list.add("小样逗比");
list.add("你过得怎样");
list.add("996加班");
list.add("工作太辛苦");
list.add("潇湘剑雨");
list.add("充哥");
list.add("GitHub");
list.add("你是个傻逼");
list.add("逗比哈");
list.add("为什么这样");
list.add("工作太辛苦");
list.add("潇湘剑雨");
list.add("充哥");
list.add("GitHub");
list.add("你过得怎样");
list.add("996加班");
list.add("工作太辛苦");
list.add("潇湘剑雨");
list.add("充哥");
list.add("GitHub");
return list;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/data/PersonData.java | Java | package org.yczbj.ycrefreshview.data;
public class PersonData {
private String name;
private int image;
private String sign;
public PersonData(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSign() {
return sign;
}
public void setSign(String sign) {
this.sign = sign;
}
public int getImage() {
return image;
}
public void setImage(int image) {
this.image = image;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/data/PictureData.java | Java | package org.yczbj.ycrefreshview.data;
public class PictureData {
private int width;
private int height;
private int image;
public PictureData(int width, int height, int image) {
this.width = width;
this.height = height;
this.image = image;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getImage() {
return image;
}
public void setImage(int image) {
this.image = image;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/delete/DeleteAdapter.java | Java | package org.yczbj.ycrefreshview.delete;
import android.content.Context;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.swipe.OnSwipeMenuListener;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class DeleteAdapter extends RecyclerArrayAdapter<PersonData> {
public DeleteAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
private OnSwipeMenuListener listener;
public void setOnSwipeMenuListener(OnSwipeMenuListener listener) {
this.listener = listener;
}
public class PersonViewHolder extends BaseViewHolder<PersonData> {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
private Button btn_del;
private Button btn_top;
PersonViewHolder(ViewGroup parent) {
super(parent, R.layout.item_news_del);
iv_news_image = getView(R.id.iv_news_image);
tv_title = getView(R.id.tv_title);
tv_content = getView(R.id.tv_content);
btn_del = getView(R.id.btn_del);
btn_top = getView(R.id.btn_top);
addOnClickListener(R.id.iv_news_image);
addOnClickListener(R.id.tv_title);
}
@Override
public void setData(final PersonData person){
Log.i("ViewHolder","position"+getDataPosition());
tv_title.setText(person.getName());
tv_content.setText(person.getSign());
Glide.with(getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(iv_news_image);
View.OnClickListener clickListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btn_del:
if (null != listener) {
listener.toDelete(getAdapterPosition());
}
break;
case R.id.btn_top:
if (null != listener) {
listener.toTop(getAdapterPosition());
}
break;
default:
break;
}
}
};
btn_del.setOnClickListener(clickListener);
btn_top.setOnClickListener(clickListener);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/delete/DeleteAndTopActivity.java | Java | package org.yczbj.ycrefreshview.delete;
import android.annotation.SuppressLint;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.yc.cn.ycbannerlib.LibUtils;
import com.yc.cn.ycbannerlib.banner.BannerView;
import com.yc.cn.ycbannerlib.banner.hintview.ColorPointHintView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.header.BannerAdapter;
import org.yczbj.ycrefreshview.header.NarrowImageAdapter;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.InterItemView;
import org.yczbj.ycrefreshviewlib.inter.OnItemChildClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
import org.yczbj.ycrefreshviewlib.swipe.OnSwipeMenuListener;
public class DeleteAndTopActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private DeleteAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setAdapter(adapter = new DeleteAdapter(this));
final LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(linearLayoutManager);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9),
LibUtils.dip2px(this,0.5f),
LibUtils.dip2px(this,72),0);
itemDecoration.setDrawLastItem(true);
itemDecoration.setDrawHeaderFooter(true);
recyclerView.addItemDecoration(itemDecoration);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
1, this.getResources().getColor(R.color.colorAccent));
recyclerView.addItemDecoration(line);
recyclerView.setRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
adapter.addAll(DataProvider.getPersonList(0));
}
},1500);
}
});
adapter.addAll(DataProvider.getPersonList(0));
adapter.setOnItemChildClickListener(new OnItemChildClickListener() {
@Override
public void onItemChildClick(View view, int position) {
switch (view.getId()){
case R.id.iv_news_image:
Toast.makeText(DeleteAndTopActivity.this,"点击图片了",Toast.LENGTH_SHORT).show();
break;
case R.id.tv_title:
Toast.makeText(DeleteAndTopActivity.this,"点击标题",Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
});
adapter.setOnSwipeMenuListener(new OnSwipeMenuListener() {
//删除功能
@Override
public void toDelete(int position) {
if(adapter.getAllData().size()>position && position>-1){
//移除数据
//adapter.getAllData().remove(position);
//推荐用这个，刷新adapter
//adapter.notifyItemRemoved(position);
//这一步，就已经做了上面的两步操作
adapter.remove(position);
}
}
//置顶功能
@Override
public void toTop(int position) {
//先移除那个位置的数据，然后将其添加到索引为0的位置，然后刷新数据
if (position > 0 && adapter.getAllData().size()>position) {
PersonData person = adapter.getAllData().get(position);
adapter.getAllData().remove(person);
adapter.notifyItemInserted(0);
adapter.getAllData().add(0, person);
adapter.notifyItemRemoved(position + 1);
if (linearLayoutManager.findFirstVisibleItemPosition() == 0) {
recyclerView.scrollToPosition(0);
}
}
}
});
}
private void initHeader() {
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
BannerView header = new BannerView(DeleteAndTopActivity.this);
header.setHintView(new ColorPointHintView(DeleteAndTopActivity.this, Color.YELLOW,Color.GRAY));
header.setHintPadding(0, 0, 0, (int) AppUtils.convertDpToPixel(8, DeleteAndTopActivity.this));
header.setPlayDelay(2000);
header.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) AppUtils.convertDpToPixel(200, DeleteAndTopActivity.this)));
header.setAdapter(new BannerAdapter(DeleteAndTopActivity.this));
return header;
}
@Override
public void onBindView(View headerView) {
}
});
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
View inflate = LayoutInflater.from(DeleteAndTopActivity.this).inflate(R.layout.header_view, null);
return inflate;
}
@Override
public void onBindView(View headerView) {
}
});
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
RecyclerView recyclerView = new RecyclerView(parent.getContext()){
//为了不打扰横向RecyclerView的滑动操作，可以这样处理
@SuppressLint("ClickableViewAccessibility")
@Override
public boolean onTouchEvent(MotionEvent event) {
super.onTouchEvent(event);
return true;
}
};
recyclerView.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,(int) AppUtils.convertDpToPixel(300, DeleteAndTopActivity.this)));
final NarrowImageAdapter adapter;
recyclerView.setAdapter(adapter = new NarrowImageAdapter(parent.getContext()));
recyclerView.setLayoutManager(new LinearLayoutManager(parent.getContext(), LinearLayoutManager.HORIZONTAL,false));
recyclerView.addItemDecoration(new SpaceViewItemLine((int)
AppUtils.convertDpToPixel(8,parent.getContext())));
adapter.setMore(R.layout.view_more_horizontal, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getNarrowImage(0));
}
},1000);
}
});
adapter.addAll(DataProvider.getNarrowImage(0));
return recyclerView;
}
@Override
public void onBindView(View headerView) {
//这里的处理别忘了
((ViewGroup)headerView).requestDisallowInterceptTouchEvent(true);
}
});
adapter.addFooter(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
TextView tv = new TextView(DeleteAndTopActivity.this);
tv.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) AppUtils.convertDpToPixel(56,DeleteAndTopActivity.this)));
tv.setGravity(Gravity.CENTER);
tv.setTextSize(TypedValue.COMPLEX_UNIT_SP,16);
tv.setText("(-_-)/~~~死宅真是恶心");
return tv;
}
@Override
public void onBindView(View headerView) {
}
});
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/header/BannerAdapter.java | Java | package org.yczbj.ycrefreshview.header;
import android.content.Context;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import com.yc.cn.ycbannerlib.banner.adapter.AbsStaticPagerAdapter;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AdData;
import java.util.List;
public class BannerAdapter extends AbsStaticPagerAdapter {
private Context ctx;
private List<AdData> list;
public BannerAdapter(Context ctx){
this.ctx = ctx;
list = DataProvider.getAdList();
}
@Override
public View getView(ViewGroup container, final int position) {
ImageView imageView = new ImageView(ctx);
imageView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
//加载图片
Glide.with(ctx)
.load(list.get(position).getImage())
.placeholder(R.drawable.default_image)
.into(imageView);
//点击事件
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
return imageView;
}
@Override
public int getCount() {
return list.size();
}
} | yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/header/HeaderFooterActivity.java | Java | package org.yczbj.ycrefreshview.header;
import android.annotation.SuppressLint;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.yc.cn.ycbannerlib.LibUtils;
import com.yc.cn.ycbannerlib.banner.BannerView;
import com.yc.cn.ycbannerlib.banner.hintview.ColorPointHintView;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.InterItemView;
import org.yczbj.ycrefreshviewlib.inter.OnItemChildClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
public class HeaderFooterActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private PersonAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
adapter = new PersonAdapter(this);
recyclerView.setAdapter(adapter);
final LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(linearLayoutManager);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9),
LibUtils.dip2px(this,0.5f),
LibUtils.dip2px(this,72),0);
itemDecoration.setDrawLastItem(true);
itemDecoration.setDrawHeaderFooter(true);
recyclerView.addItemDecoration(itemDecoration);
final RecycleViewItemLine line = new RecycleViewItemLine(this,
LinearLayout.HORIZONTAL, 1, getResources().getColor(R.color.colorAccent));
recyclerView.addItemDecoration(line);
recyclerView.setRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
adapter.addAll(DataProvider.getPersonList(0));
}
},1500);
}
});
//recyclerView.setRefreshing(true);
recyclerView.setRefreshingColorResources(R.color.colorAccent);
initHeader();
adapter.addAll(DataProvider.getPersonList(0));
adapter.setOnItemChildClickListener(new OnItemChildClickListener() {
@Override
public void onItemChildClick(View view, int position) {
switch (view.getId()){
case R.id.iv_news_image:
Toast.makeText(HeaderFooterActivity.this,
"点击图片了",Toast.LENGTH_SHORT).show();
break;
case R.id.tv_title:
Toast.makeText(HeaderFooterActivity.this,
"点击标题",Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
});
}
private void initHeader() {
adapter.removeAllFooter();
adapter.removeAllHeader();
InterItemView interItemView = new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
BannerView header = new BannerView(HeaderFooterActivity.this);
header.setHintView(new ColorPointHintView(HeaderFooterActivity.this,
Color.YELLOW, Color.GRAY));
header.setHintPadding(0, 0, 0, (int) AppUtils.convertDpToPixel(
8, HeaderFooterActivity.this));
header.setPlayDelay(2000);
header.setLayoutParams(new RecyclerView.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
(int) AppUtils.convertDpToPixel(200, HeaderFooterActivity.this)));
header.setAdapter(new BannerAdapter(HeaderFooterActivity.this));
return header;
}
@Override
public void onBindView(View headerView) {
}
};
adapter.addHeader(interItemView);
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
View inflate = LayoutInflater.from(HeaderFooterActivity.this)
.inflate(R.layout.header_view, null);
return inflate;
}
@Override
public void onBindView(View headerView) {
TextView tvTitle = headerView.findViewById(R.id.tvTitle);
}
});
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
RecyclerView recyclerView = new RecyclerView(parent.getContext()){
//为了不打扰横向RecyclerView的滑动操作，可以这样处理
@SuppressLint("ClickableViewAccessibility")
@Override
public boolean onTouchEvent(MotionEvent event) {
super.onTouchEvent(event);
return true;
}
};
recyclerView.setLayoutParams(new RecyclerView.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
(int) AppUtils.convertDpToPixel(200, HeaderFooterActivity.this)));
final NarrowImageAdapter adapter;
recyclerView.setAdapter(adapter = new NarrowImageAdapter(parent.getContext()));
recyclerView.setLayoutManager(new LinearLayoutManager(parent.getContext(),
LinearLayoutManager.HORIZONTAL,false));
recyclerView.addItemDecoration(new SpaceViewItemLine((int)
AppUtils.convertDpToPixel(8,parent.getContext())));
adapter.setMore(R.layout.view_more_horizontal, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getNarrowImage(0));
}
},1000);
}
});
adapter.addAll(DataProvider.getNarrowImage(0));
return recyclerView;
}
@Override
public void onBindView(View headerView) {
//这里的处理别忘了
((ViewGroup)headerView).requestDisallowInterceptTouchEvent(true);
}
});
adapter.addFooter(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
View inflate = LayoutInflater.from(HeaderFooterActivity.this)
.inflate(R.layout.footer_view, null);
return inflate;
}
@Override
public void onBindView(View headerView) {
}
});
adapter.addFooter(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
TextView tv = new TextView(HeaderFooterActivity.this);
tv.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
(int) AppUtils.convertDpToPixel(56,HeaderFooterActivity.this)));
tv.setGravity(Gravity.CENTER);
tv.setTextSize(TypedValue.COMPLEX_UNIT_SP,16);
tv.setText("这个是底部布局");
return tv;
}
@Override
public void onBindView(View headerView) {
}
});
}
private void test(){
//删除索引处的数据
adapter.remove(0);
//触发清空所有数据
//添加数据，注意这个是在最后索引处添加
adapter.add(new PersonData());
//添加所有数据
adapter.addAll(DataProvider.getPersonList(0));
//插入数据
adapter.insert(new PersonData(),3);
//在某个索引处插入集合数据
adapter.insertAll(DataProvider.getPersonList(0),3);
//获取item索引位置
//adapter.getPosition(data);
//触发清空所有的数据
adapter.clear();
//获取所有的数据
adapter.getAllData();
InterItemView view = adapter.getHeader(0);
//清除所有footer
adapter.removeAllFooter();
//清除所有header
adapter.removeAllHeader();
//添加footerView
adapter.addFooter(view);
//添加headerView
adapter.addHeader(view);
//移除某个headerView
adapter.removeHeader(view);
//移除某个footerView
adapter.removeFooter(view);
//获取某个索引处的headerView
adapter.getHeader(0);
//获取某个索引处的footerView
adapter.getFooter(0);
//获取footer的数量
adapter.getFooterCount();
//获取header的数量
adapter.getHeaderCount();
//设置上拉加载更多的自定义布局和监听
//adapter.setMore(R.layout.view_more,listener);
//设置上拉加载更多的自定义布局和监听
//adapter.setMore(view,listener);
//设置上拉加载没有更多数据布局
adapter.setNoMore(R.layout.view_nomore);
//设置上拉加载没有更多数据布局
//adapter.setNoMore(view);
//设置上拉加载没有更多数据监听
adapter.setNoMore(R.layout.view_nomore,null);
//设置上拉加载异常的布局
adapter.setError(R.layout.view_error);
//设置上拉加载异常的布局
//adapter.setError(view);
//设置上拉加载异常的布局和异常监听
adapter.setError(R.layout.view_error,null);
//暂停上拉加载更多
adapter.pauseMore();
//停止上拉加载更多
adapter.stopMore();
//恢复上拉加载更多
adapter.resumeMore();
//获取上下文
adapter.getContext();
//应该使用这个获取item个数
adapter.getCount();
//设置操作数据[增删改查]后，是否刷新adapter
adapter.setNotifyOnChange(true);
//设置孩子点击事件
adapter.setOnItemChildClickListener(null);
//设置条目点击事件
adapter.setOnItemClickListener(null);
//设置条目长按事件
adapter.setOnItemLongClickListener(null);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/header/NarrowImageAdapter.java | Java | package org.yczbj.ycrefreshview.header;
import android.content.Context;
import android.view.ViewGroup;
import android.widget.ImageView;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class NarrowImageAdapter extends RecyclerArrayAdapter<Integer> {
public NarrowImageAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new NarrowImageViewHolder(parent);
}
private static class NarrowImageViewHolder extends BaseViewHolder<Integer>{
ImageView imgPicture;
NarrowImageViewHolder(ViewGroup parent) {
super(new ImageView(parent.getContext()));
imgPicture = (ImageView) itemView;
imgPicture.setLayoutParams(new ViewGroup.LayoutParams((int)
AppUtils.convertDpToPixel(80.0f,getContext()),
ViewGroup.LayoutParams.MATCH_PARENT));
imgPicture.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
@Override
public void setData(Integer data) {
imgPicture.setImageResource(data);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/horizontal/FourHorizontalActivity.java | Java | package org.yczbj.ycrefreshview.horizontal;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
public class FourHorizontalActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private NarrowImageAdapter adapter;
private Handler handler = new Handler();
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_horizontal);
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setAdapter(adapter = new NarrowImageAdapter(this));
recyclerView.setLayoutManager(new LinearLayoutManager(this,
LinearLayoutManager.HORIZONTAL,false));
recyclerView.addItemDecoration(new SpaceViewItemLine((int)
AppUtils.convertDpToPixel(8,this)));
adapter.setMore(R.layout.view_more_horizontal, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getNarrowImage(0));
}
},1000);
}
});
recyclerView.setRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
adapter.clear();
adapter.addAll(DataProvider.getNarrowImage(0));
}
});
adapter.addAll(DataProvider.getNarrowImage(0));
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/horizontal/NarrowImageAdapter.java | Java | package org.yczbj.ycrefreshview.horizontal;
import android.content.Context;
import android.view.ViewGroup;
import android.widget.ImageView;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class NarrowImageAdapter extends RecyclerArrayAdapter<Integer> {
public NarrowImageAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new NarrowImageViewHolder(parent);
}
private static class NarrowImageViewHolder extends BaseViewHolder<Integer>{
ImageView imgPicture;
public NarrowImageViewHolder(ViewGroup parent) {
super(new ImageView(parent.getContext()));
imgPicture = (ImageView) itemView;
imgPicture.setLayoutParams(new ViewGroup.LayoutParams((int) AppUtils.convertDpToPixel(72f,getContext()), ViewGroup.LayoutParams.MATCH_PARENT));
imgPicture.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
@Override
public void setData(Integer data) {
imgPicture.setImageResource(data);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/insert/ThirdInsertActivity.java | Java | package org.yczbj.ycrefreshview.insert;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.DefaultItemAnimator;
import androidx.recyclerview.widget.LinearLayoutManager;
import android.view.Menu;
import android.view.MenuItem;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import java.util.List;
import java.util.Random;
public class ThirdInsertActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private PersonAdapter adapter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
final LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(linearLayoutManager);
DividerViewItemLine itemDecoration = new
DividerViewItemLine( this.getResources().getColor(R.color.color_f9f9f9)
, LibUtils.dip2px(this, 1f),
LibUtils.dip2px(this, 72), 0);
itemDecoration.setDrawLastItem(false);
recyclerView.addItemDecoration(itemDecoration);
recyclerView.setAdapterWithProgress(adapter = new PersonAdapter(this));
List<PersonData> persons = DataProvider.getPersonList(0);
adapter.addAll(persons.subList(0, 3));
//设置默认的动画模式
DefaultItemAnimator defaultItemAnimator = new DefaultItemAnimator();
recyclerView.setItemAnimator(defaultItemAnimator);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_insert, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Random random = new Random();
int len = adapter.getCount();
if (len > 0) {
int pos = random.nextInt(len);
List<PersonData> persons = DataProvider.getPersonList(0);
PersonData data = persons.get(random.nextInt(persons.size()));
switch (item.getItemId()) {
case R.id.ic_add:
adapter.insert(data, pos);
break;
case R.id.ic_remove:
adapter.remove(pos);
break;
case R.id.ic_refresh:
adapter.update(data, pos);
break;
default:
break;
}
}
return true;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/load/LoadMoreActivity.java | Java | package org.yczbj.ycrefreshview.load;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import java.util.List;
/**
* @author yc
*/
public class LoadMoreActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private LoadMoreAdapter adapter;
private Handler handler = new Handler();
private final int PAGE_COUNT = 10;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initData();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
final LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9)
, LibUtils.dip2px(this,1f),
LibUtils.dip2px(this,30),30);
recyclerView.addItemDecoration(itemDecoration);
adapter = new LoadMoreAdapter(this,false);
recyclerView.setAdapter(adapter);
adapter.setOnClickListener(new OnItemClickListener() {
@Override
public void onItemClick(int position) {
}
});
// 实现上拉加载重要步骤，设置滑动监听器，RecyclerView自带的ScrollListener
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
//用来标记是否正在向上滑动
private boolean isSlidingUpward = false;
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
super.onScrollStateChanged(recyclerView, newState);
// 当不滑动的时候
// 在newState为滑到底部时
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
//获取最后一个完全显示的itemPosition
int lastItemPosition = layoutManager.findLastCompletelyVisibleItemPosition();
int itemCount = layoutManager.getItemCount();
//int itemCount1 = adapter.getItemCount();
// 判断是否滑动到了最后一个item，并且是向上滑动
if (lastItemPosition == (itemCount - 1) && isSlidingUpward) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
updateRecyclerView(adapter.getRealLastPosition(),
adapter.getRealLastPosition() + PAGE_COUNT);
}
}, 2000);
}
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
// 大于0表示正在向上滑动，小于等于0表示停止或向下滑动
isSlidingUpward = dy > 0;
}
});
}
private void initData() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.setData(DataProvider.getPersonList(10));
}
}, 50);
}
private void updateRecyclerView(int fromIndex, int toIndex) {
List<PersonData> newDatas = DataProvider.getPersonList(0);
if (newDatas.size() > 0) {
adapter.updateList(newDatas, true);
} else {
adapter.updateList(null, false);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/load/LoadMoreActivity2.java | Java | package org.yczbj.ycrefreshview.load;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import java.util.List;
/**
* @author yc
*/
public class LoadMoreActivity2 extends AppCompatActivity {
private RecyclerView recyclerView;
private LoadMoreAdapter2 adapter;
private Handler handler = new Handler();
private int lastVisibleItem = 0;
private final int PAGE_COUNT = 10;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initData();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
final GridLayoutManager layoutManager = new GridLayoutManager(this,2);
recyclerView.setLayoutManager(layoutManager);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9)
, LibUtils.dip2px(this,1f),
LibUtils.dip2px(this,30),30);
recyclerView.addItemDecoration(itemDecoration);
adapter = new LoadMoreAdapter2(this,false);
recyclerView.setAdapter(adapter);
adapter.setOnClickListener(new OnItemClickListener() {
@Override
public void onItemClick(int position) {
}
});
// 实现上拉加载重要步骤，设置滑动监听器，RecyclerView自带的ScrollListener
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
super.onScrollStateChanged(recyclerView, newState);
// 在newState为滑到底部时
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
// 如果没有隐藏footView，那么最后一个条目的位置就比我们的getItemCount少1，自己可以算一下
if (!adapter.isFadeTips() && lastVisibleItem + 1 == adapter.getItemCount()) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
updateRecyclerView(adapter.getRealLastPosition(),
adapter.getRealLastPosition() + PAGE_COUNT);
}
}, 2500);
}
// 如果隐藏了提示条，我们又上拉加载时，那么最后一个条目就要比getItemCount要少2
if (adapter.isFadeTips() && lastVisibleItem + 2 == adapter.getItemCount()) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
updateRecyclerView(adapter.getRealLastPosition(),
adapter.getRealLastPosition() + PAGE_COUNT);
}
}, 2500);
}
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
// 在滑动完成后，拿到最后一个可见的item的位置
lastVisibleItem = layoutManager.findLastVisibleItemPosition();
}
});
}
private void initData() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.setData(DataProvider.getPersonList(16));
}
}, 50);
}
private void updateRecyclerView(int fromIndex, int toIndex) {
List<PersonData> newDatas = DataProvider.getPersonList(0);
if (newDatas.size() > 0) {
adapter.updateList(newDatas, true);
} else {
adapter.updateList(null, false);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/load/LoadMoreAdapter.java | Java | package org.yczbj.ycrefreshview.load;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import org.yczbj.ycrefreshviewlib.utils.RefreshLogUtils;
import java.util.ArrayList;
import java.util.List;
public class LoadMoreAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private Context mContext;
private OnItemClickListener listener;
/**
* 第一种ViewType，正常的item
*/
private int normalType = 0;
/**
* 第二种ViewType，底部的提示View
*/
private int footType = 1;
/**
* 变量，是否有更多数据
*/
private boolean hasMore;
/**
* 变量，是否隐藏了底部的提示
*/
private boolean fadeTips = false;
/**
* 获取主线程的Handler
*/
private Handler mHandler = new Handler(Looper.getMainLooper());
public LoadMoreAdapter(Context context,boolean hasMore) {
this.mContext = context;
this.hasMore = hasMore;
}
private List<PersonData> data = new ArrayList<>();
public void setData(List<PersonData> data) {
this.data = data;
notifyDataSetChanged();
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
/**
* 暴露接口，改变fadeTips的方法
*/
public boolean isFadeTips() {
return fadeTips;
}
/**
* 暴露接口，更新数据源，并修改hasMore的值，如果有增加数据，hasMore为true，否则为false
*/
public void updateList(List<PersonData> newDatas, boolean hasMore) {
int size = data.size();
// 在原有的数据之上增加新数据
if (newDatas != null) {
data.addAll(newDatas);
this.hasMore = hasMore;
notifyItemRangeInserted(size,newDatas.size());
}
}
/**
* 自定义方法，获取列表中数据源的最后一个位置，比getItemCount少1，因为不计上footView
*/
public int getRealLastPosition() {
return data.size();
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
RefreshLogUtils.d("Adapter------onCreateViewHolder");
// 根据返回的ViewType，绑定不同的布局文件，这里只有两种
if (viewType == normalType) {
return new MyViewHolder(LayoutInflater.from(mContext)
.inflate(R.layout.item_news, parent,false));
} else {
//这个是上拉加载更多的view
return new FootHolder(LayoutInflater.from(mContext)
.inflate(R.layout.view_more, parent,false));
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
if (holder instanceof MyViewHolder){
PersonData person = data.get(position);
setBindViewHolder((MyViewHolder)holder,person,position);
}else {
setFootBindViewHolder((FootHolder)holder ,position);
}
RefreshLogUtils.d("Adapter------onBindViewHolder---"+position);
}
/**
* 获取条目数量，之所以要加1是因为增加了一条footView
*/
@Override
public int getItemCount() {
return data == null ? 0 : data.size()+1;
}
/**
* 根据条目位置返回ViewType，以供onCreateViewHolder方法内获取不同的Holder
*/
@Override
public int getItemViewType(int position) {
RefreshLogUtils.d("Adapter------getItemViewType---"+position);
if (position == getItemCount() - 1) {
return footType;
} else {
return normalType;
}
}
class MyViewHolder extends RecyclerView.ViewHolder {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
MyViewHolder(final View itemView) {
super(itemView);
RefreshLogUtils.d("Adapter------ViewHolder----getAdapterPosition---"+getAdapterPosition());
tv_title = itemView.findViewById(R.id.tv_title);
iv_news_image = itemView.findViewById(R.id.iv_news_image);
tv_content = itemView.findViewById(R.id.tv_content);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (listener != null) {
listener.onItemClick(getAdapterPosition());
}
}
});
}
}
class FootHolder extends RecyclerView.ViewHolder {
private TextView tv_more;
FootHolder(View itemView) {
super(itemView);
tv_more = itemView.findViewById(R.id.tv_more);
}
}
private void setBindViewHolder(MyViewHolder holder, PersonData person, int position) {
if (person.getName()==null || person.getName().length()==0){
holder.tv_content.setText("小杨逗比"+position);
}else {
holder.tv_title.setText(person.getName());
}
if (person.getSign()==null || person.getSign().length()==0){
holder.tv_content.setText("这个是内容"+position);
}else {
holder.tv_content.setText(person.getSign());
}
Glide.with(holder.iv_news_image.getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(holder.iv_news_image);
}
private void setFootBindViewHolder(final FootHolder holder, int position) {
// 之所以要设置可见，是因为我在没有更多数据时会隐藏了这个footView
holder.tv_more.setVisibility(View.VISIBLE);
// 只有获取数据为空时，hasMore为false，所以当我们拉到底部时基本都会首先显示“正在加载更多...”
if (hasMore) {
// 不隐藏footView提示
fadeTips = false;
if (data.size() > 0) {
// 如果查询数据发现增加之后，就显示正在加载更多
holder.tv_more.setText("逗比，正在加载更多...");
}
} else {
if (data.size() > 0) {
// 如果查询数据发现并没有增加时，就显示没有更多数据了
holder.tv_more.setText("逗比，没有更多数据了");
// 然后通过延时加载模拟网络请求的时间，在500ms后执行
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
// 隐藏提示条
holder.tv_more.setVisibility(View.GONE);
// 将fadeTips设置true
fadeTips = true;
// hasMore设为true是为了让再次拉到底时，会先显示正在加载更多
hasMore = true;
}
}, 500);
}
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/load/LoadMoreAdapter2.java | Java | package org.yczbj.ycrefreshview.load;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import java.util.ArrayList;
import java.util.List;
public class LoadMoreAdapter2 extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private Context mContext;
private OnItemClickListener listener;
/**
* 第一种ViewType，正常的item
*/
private int normalType = 0;
/**
* 第二种ViewType，底部的提示View
*/
private int footType = 1;
/**
* 变量，是否有更多数据
*/
private boolean hasMore;
/**
* 变量，是否隐藏了底部的提示
*/
private boolean fadeTips = false;
/**
* 获取主线程的Handler
*/
private Handler mHandler = new Handler(Looper.getMainLooper());
public LoadMoreAdapter2(Context context, boolean hasMore) {
this.mContext = context;
this.hasMore = hasMore;
}
private List<PersonData> data = new ArrayList<>();
public void setData(List<PersonData> data) {
this.data = data;
notifyDataSetChanged();
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
/**
* 暴露接口，改变fadeTips的方法
*/
public boolean isFadeTips() {
return fadeTips;
}
/**
* 暴露接口，更新数据源，并修改hasMore的值，如果有增加数据，hasMore为true，否则为false
*/
public void updateList(List<PersonData> newDatas, boolean hasMore) {
int start = data.size();
// 在原有的数据之上增加新数据
if (newDatas != null) {
data.addAll(newDatas);
}
int end = data.size();
this.hasMore = hasMore;
notifyItemRangeInserted(start,end);
}
/**
* 自定义方法，获取列表中数据源的最后一个位置，比getItemCount少1，因为不计上footView
*/
public int getRealLastPosition() {
return data.size();
}
@Override
public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
super.onAttachedToRecyclerView(recyclerView);
RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
if (manager instanceof GridLayoutManager) {
final GridLayoutManager gridManager = ((GridLayoutManager) manager);
gridManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
@Override
public int getSpanSize(int position) {
// 如果当前是footer的位置，那么该item占据2个单元格，正常情况下占据1个单元格
return getItemViewType(position) == footType ? gridManager.getSpanCount() : 1;
}
});
}
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
// 根据返回的ViewType，绑定不同的布局文件，这里只有两种
if (viewType == normalType) {
return new MyViewHolder(LayoutInflater.from(mContext)
.inflate(R.layout.item_news, parent,false));
} else {
//这个是上拉加载更多的view
return new FootHolder(LayoutInflater.from(mContext)
.inflate(R.layout.view_more, parent,false));
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
if (holder instanceof MyViewHolder){
PersonData person = data.get(position);
setBindViewHolder((MyViewHolder)holder,person,position);
}else {
setFootBindViewHolder((FootHolder)holder ,position);
}
}
/**
* 获取条目数量，之所以要加1是因为增加了一条footView
*/
@Override
public int getItemCount() {
return data == null ? 0 : data.size()+1;
}
/**
* 根据条目位置返回ViewType，以供onCreateViewHolder方法内获取不同的Holder
*/
@Override
public int getItemViewType(int position) {
if (position == getItemCount() - 1) {
return footType;
} else {
return normalType;
}
}
class MyViewHolder extends RecyclerView.ViewHolder {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
MyViewHolder(final View itemView) {
super(itemView);
tv_title = itemView.findViewById(R.id.tv_title);
iv_news_image = itemView.findViewById(R.id.iv_news_image);
tv_content = itemView.findViewById(R.id.tv_content);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (listener != null) {
listener.onItemClick(getAdapterPosition());
}
}
});
}
}
class FootHolder extends RecyclerView.ViewHolder {
private TextView tv_more;
FootHolder(View itemView) {
super(itemView);
tv_more = itemView.findViewById(R.id.tv_more);
}
}
private void setBindViewHolder(MyViewHolder holder, PersonData person, int position) {
if (person.getName()==null || person.getName().length()==0){
holder.tv_content.setText("小杨逗比"+position);
}else {
holder.tv_title.setText(person.getName());
}
if (person.getSign()==null || person.getSign().length()==0){
holder.tv_content.setText("这个是内容"+position);
}else {
holder.tv_content.setText(person.getSign());
}
Glide.with(holder.iv_news_image.getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(holder.iv_news_image);
}
private void setFootBindViewHolder(final FootHolder holder, int position) {
// 之所以要设置可见，是因为我在没有更多数据时会隐藏了这个footView
holder.tv_more.setVisibility(View.VISIBLE);
// 只有获取数据为空时，hasMore为false，所以当我们拉到底部时基本都会首先显示“正在加载更多...”
if (hasMore) {
// 不隐藏footView提示
fadeTips = false;
if (data.size() > 0) {
// 如果查询数据发现增加之后，就显示正在加载更多
holder.tv_more.setText("逗比，正在加载更多...");
}
} else {
if (data.size() > 0) {
// 如果查询数据发现并没有增加时，就显示没有更多数据了
holder.tv_more.setText("逗比，没有更多数据了");
// 然后通过延时加载模拟网络请求的时间，在500ms后执行
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
// 隐藏提示条
holder.tv_more.setVisibility(View.GONE);
// 将fadeTips设置true
fadeTips = true;
// hasMore设为true是为了让再次拉到底时，会先显示正在加载更多
hasMore = true;
}
}, 500);
}
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/multistyle/FiveMultiStyleActivity.java | Java | package org.yczbj.ycrefreshview.multistyle;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
public class FiveMultiStyleActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private PersonWithAdAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setProgressView(R.layout.view_progress);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9)
, LibUtils.dip2px(this,0.5f),
LibUtils.dip2px(this,72),0);
recyclerView.addItemDecoration(itemDecoration);
adapter = new PersonWithAdAdapter(this);
adapter.addAll(DataProvider.getPersonWithAds(0));
recyclerView.setAdapterWithProgress(adapter);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/multistyle/PersonWithAdAdapter.java | Java | package org.yczbj.ycrefreshview.multistyle;
import android.content.Context;
import android.view.ViewGroup;
import org.yczbj.ycrefreshview.data.AdData;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonViewHolder;
import org.yczbj.ycrefreshview.staggered.AdViewHolder;
import org.yczbj.ycrefreshview.staggered.ImageViewHolder;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import java.security.InvalidParameterException;
public class PersonWithAdAdapter extends RecyclerArrayAdapter<Object> {
public static final int TYPE_INVALID = 0;
public static final int TYPE_AD = 1;
public static final int TYPE_PERSON = 2;
public PersonWithAdAdapter(Context context) {
super(context);
}
@Override
public int getViewType(int position) {
if(getItem(position) instanceof AdData){
return TYPE_AD;
}else if (getItem(position) instanceof PersonData){
return TYPE_PERSON;
}
return TYPE_INVALID;
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType){
case TYPE_PERSON:
return new PersonViewHolder(parent);
case TYPE_AD:
return new AdViewHolder(parent);
case TYPE_INVALID:
return new ImageViewHolder(parent);
default:
throw new InvalidParameterException();
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/normal/NormalRecyclerViewActivity.java | Java | package org.yczbj.ycrefreshview.normal;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.widget.LinearLayout;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
/**
* @author yc
*/
public class NormalRecyclerViewActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private RecyclerArrayAdapter<PersonData> adapter;
private int page = 0;
private boolean hasNetWork = true;
private Handler handler = new Handler();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initData();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int)AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
adapter = new PersonAdapter(this);
recyclerView.setAdapter(adapter);
adapter.setMore(R.layout.view_more, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(page));
page++;
}
}, 2000);
}
});
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.pauseMore();
}
@Override
public void onNoMoreClick() {
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.resumeMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
}
private void initData() {
page = 0;
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(page));
page=1;
}
}, 50);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/normal/SpanModel.java | Java | package org.yczbj.ycrefreshview.normal;
public class SpanModel {
private String name;
private int type;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/normal/SpanRecyclerViewActivity.java | Java | package org.yczbj.ycrefreshview.normal;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
import java.util.ArrayList;
/**
* @author yc
*/
public class SpanRecyclerViewActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private SpanTypeAdapter adapter;
private Handler handler = new Handler();
private ArrayList<SpanModel> mDataList;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initData();
initRecyclerView();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initData() {
mDataList = new ArrayList<>();
for (int i = 0; i < 50; i++) {
SpanModel model = new SpanModel();
model.setName(i + "");
if (i == 0) {
model.setType(1);
} else if (i < 7) {
model.setType(2);
} else if (i>=8 && i<11){
model.setType(3);
} else if (i>=13 && i<16){
model.setType(4);
} else {
model.setType(1);
}
mDataList.add(model);
}
}
/**
* 先是定义了一个6列的网格布局，然后通过GridLayoutManager.SpanSizeLookup这个类来动态的指定某个item应该占多少列
*/
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
GridLayoutManager manager = new GridLayoutManager(this, 6);
manager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
@Override
public int getSpanSize(int position) {
SpanModel model = mDataList.get(position);
if (model.getType() == 1) {
return 6;
} else if(model.getType() == 2){
return 3;
}else if (model.getType() == 3){
return 2;
}else if (model.getType() == 4){
return 2;
} else {
return 1;
}
}
});
recyclerView.setLayoutManager(manager);
SpaceViewItemLine itemDecoration = new SpaceViewItemLine(
(int) AppUtils.convertDpToPixel(8,this));
itemDecoration.setPaddingEdgeSide(true);
itemDecoration.setPaddingStart(true);
recyclerView.addItemDecoration(itemDecoration);
adapter = new SpanTypeAdapter(this);
recyclerView.setAdapter(adapter);
adapter.setData(mDataList);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/normal/SpanTypeAdapter.java | Java | package org.yczbj.ycrefreshview.normal;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.util.SparseArray;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import java.util.ArrayList;
import java.util.List;
public class SpanTypeAdapter extends RecyclerView.Adapter<SpanTypeAdapter.MyViewHolder> {
private Context mContext;
private OnItemClickListener listener;
public SpanTypeAdapter(Context context) {
this.mContext = context;
}
private List<SpanModel> data = new ArrayList<>();
public void setData(List<SpanModel> data) {
this.data = data;
notifyDataSetChanged();
}
public List<SpanModel> getData() {
return data;
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
@NonNull
@Override
public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(mContext).inflate(R.layout.item_news_content, parent, false);
return new MyViewHolder(view);
}
@Override
public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
SpanModel person = data.get(position);
if (person.getName()==null || person.getName().length()==0){
holder.tvContent.setText("小杨逗比"+position);
}else {
holder.tvTitle.setText(person.getName());
}
}
class MyViewHolder extends RecyclerView.ViewHolder {
private SparseArray<View> viewSparseArray;
private TextView tvTitle;
private TextView tvContent;
MyViewHolder(final View itemView) {
super(itemView);
if(viewSparseArray==null){
viewSparseArray = new SparseArray<>();
}
itemView.setBackgroundResource(R.color.colorAccent);
tvTitle = (TextView) viewSparseArray.get(R.id.tv_title);
tvContent = (TextView) viewSparseArray.get(R.id.tv_content);
if (tvTitle == null) {
tvTitle = itemView.findViewById(R.id.tv_title);
viewSparseArray.put(R.id.tv_title, tvTitle);
}
if (tvContent == null) {
tvContent = itemView.findViewById(R.id.tv_content);
viewSparseArray.put(R.id.tv_content, tvContent);
}
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (listener != null) {
listener.onItemClick(getAdapterPosition());
}
}
});
}
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/refresh/PersonAdapter.java | Java | package org.yczbj.ycrefreshview.refresh;
import android.annotation.SuppressLint;
import android.content.Context;
import android.util.Log;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
public class PersonAdapter extends RecyclerArrayAdapter<PersonData> {
private PersonViewHolder viewHolder;
public PersonAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
viewHolder = new PersonViewHolder(parent);
return viewHolder;
}
public PersonViewHolder getViewHolder() {
return viewHolder;
}
public class PersonViewHolder extends BaseViewHolder<PersonData> {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
PersonViewHolder(ViewGroup parent) {
super(parent, R.layout.item_news);
iv_news_image = getView(R.id.iv_news_image);
tv_title = getView(R.id.tv_title);
tv_content = getView(R.id.tv_content);
addOnClickListener(R.id.iv_news_image);
addOnClickListener(R.id.tv_title);
}
@SuppressLint("SetTextI18n")
@Override
public void setData(final PersonData person){
Log.i("ViewHolder","position"+getDataPosition());
if (person.getName()==null || person.getName().length()==0){
tv_content.setText("小杨逗比"+getDataPosition());
}else {
tv_title.setText(person.getName());
}
if (person.getSign()==null || person.getSign().length()==0){
tv_content.setText("这个是内容"+getDataPosition());
}else {
tv_content.setText(person.getSign());
}
Glide.with(getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(iv_news_image);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/refresh/PersonViewHolder.java | Java | package org.yczbj.ycrefreshview.refresh;
import android.util.Log;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class PersonViewHolder extends BaseViewHolder<PersonData> {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
private Button btn_del;
private Button btn_top;
public PersonViewHolder(ViewGroup parent) {
super(parent, R.layout.item_news);
iv_news_image = getView(R.id.iv_news_image);
tv_title = getView(R.id.tv_title);
tv_content = getView(R.id.tv_content);
btn_del = getView(R.id.btn_del);
btn_top = getView(R.id.btn_top);
}
@Override
public void setData(final PersonData person){
Log.i("ViewHolder","position"+getDataPosition());
tv_title.setText(person.getName());
tv_content.setText(person.getSign());
Glide.with(getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.into(iv_news_image);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/refresh/RefreshAndMoreActivity1.java | Java | package org.yczbj.ycrefreshview.refresh;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.LinearLayout;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
public class RefreshAndMoreActivity1 extends AppCompatActivity implements SwipeRefreshLayout.OnRefreshListener{
private YCRefreshView recyclerView;
private FloatingActionButton view;
private RecyclerArrayAdapter<PersonData> adapter;
private Handler handler = new Handler();
private int page = 0;
private boolean hasNetWork = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recyclerview);
initView();
initListener();
onRefresh();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
@Override
public void onRefresh() {
page = 0;
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
page=1;
recyclerView.showRecycler();
}
}, 2000);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
MenuItem item = menu.findItem(R.id.checkbox);
CheckBox box = (CheckBox) item.getActionView();
box.setChecked(true);
box.setText("网络");
box.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
hasNetWork = isChecked;
}
});
return true;
}
private void initView() {
view = findViewById(R.id.top);
recyclerView = findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int)AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
recyclerView.setAdapterWithProgress(adapter = new RecyclerArrayAdapter<PersonData>(this) {
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
});
adapter.setMore(R.layout.view_more, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
page++;
}
}, 2000);
}
});
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.pauseMore();
}
@Override
public void onNoMoreClick() {
Log.e("逗比","没有更多数据了");
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.pauseMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
adapter.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(int position) {
if (adapter.getAllData().size()>position && position>=0){
//处理点击事件逻辑
}
}
});
}
private void initListener() {
recyclerView.setRefreshListener(this);
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
recyclerView.scrollToPosition(0);
}
});
}
private void test(){
//设置加载数据完毕状态
recyclerView.showRecycler();
//设置加载数据为空状态
recyclerView.showEmpty();
//设置加载错误状态
recyclerView.showError();
//设置加载数据中状态
recyclerView.showProgress();
//设置空状态页面自定义布局
recyclerView.setEmptyView(R.layout.view_custom_empty_data);
recyclerView.setEmptyView(view);
//获取空页面自定义布局
View emptyView = recyclerView.getEmptyView();
//设置异常状态页面自定义布局
recyclerView.setErrorView(R.layout.view_custom_data_error);
recyclerView.setErrorView(view);
//设置加载loading状态页面自定义布局
recyclerView.setProgressView(R.layout.view_progress_loading);
recyclerView.setProgressView(view);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/refresh/RefreshAndMoreActivity2.java | Java | package org.yczbj.ycrefreshview.refresh;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.LinearLayout;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
public class RefreshAndMoreActivity2 extends AppCompatActivity implements SwipeRefreshLayout.OnRefreshListener{
private YCRefreshView recyclerView;
private FloatingActionButton top;
private RecyclerArrayAdapter<PersonData> adapter;
private Handler handler = new Handler();
private int page = 0;
private boolean hasNetWork = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recyclerview);
initView();
initListener();
onRefresh();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
@Override
public void onRefresh() {
page = 0;
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.add(new PersonData());
adapter.addAll(DataProvider.getPersonList(10));
page=1;
recyclerView.showRecycler();
}
}, 2000);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
MenuItem item = menu.findItem(R.id.checkbox);
CheckBox box = (CheckBox) item.getActionView();
box.setChecked(true);
box.setText("网络");
box.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
hasNetWork = isChecked;
}
});
return true;
}
private void initView() {
top = findViewById(R.id.top);
recyclerView = findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int)AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_666666));
recyclerView.addItemDecoration(line);
recyclerView.setAdapterWithProgress(adapter = new RecyclerArrayAdapter<PersonData>(this) {
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
});
adapter.setMore(R.layout.view_more2, new OnMoreListener() {
@Override
public void onMoreShow() {
//不做处理
}
@Override
public void onMoreClick() {
//点击触发加载下一页数据
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
page++;
}
}, 200);
}
});
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.pauseMore();
}
@Override
public void onNoMoreClick() {
Log.e("逗比","没有更多数据了");
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.resumeMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
}
private void initListener() {
recyclerView.setRefreshListener(this);
top.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
recyclerView.scrollToPosition(0);
}
});
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/refresh/RefreshAndMoreActivity3.java | Java | package org.yczbj.ycrefreshview.refresh;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.LinearLayout;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
public class RefreshAndMoreActivity3 extends AppCompatActivity implements SwipeRefreshLayout.OnRefreshListener{
private YCRefreshView recyclerView;
private FloatingActionButton top;
private RecyclerArrayAdapter<PersonData> adapter;
private Handler handler = new Handler();
private boolean hasNetWork = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recyclerview);
initView();
initListener();
onRefresh();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
@Override
public void onRefresh() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.add(new PersonData());
adapter.addAll(DataProvider.getPersonList(15));
recyclerView.showRecycler();
}
}, 2000);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
MenuItem item = menu.findItem(R.id.checkbox);
CheckBox box = (CheckBox) item.getActionView();
box.setChecked(true);
box.setText("网络");
box.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
hasNetWork = isChecked;
}
});
return true;
}
private void initView() {
top = findViewById(R.id.top);
recyclerView = findViewById(R.id.recyclerView);
GridLayoutManager layoutManager = new GridLayoutManager(this,2);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int)AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
adapter = new RecyclerArrayAdapter<PersonData>(this) {
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
};
// adapter.setHeaderAndFooterSpan(true);
recyclerView.setAdapterWithProgress(adapter);
adapter.setMore(R.layout.view_more, new OnMoreListener() {
@Override
public void onMoreShow() {
//点击触发加载下一页数据
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
}
}, 2000);
}
@Override
public void onMoreClick() {
}
});
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.pauseMore();
}
@Override
public void onNoMoreClick() {
Log.e("逗比","没有更多数据了");
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.resumeMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
}
private void initListener() {
recyclerView.setRefreshListener(this);
top.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
recyclerView.scrollToPosition(0);
}
});
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/ScrollActivity.java | Java | package org.yczbj.ycrefreshview.scroll;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.RecyclerView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.scroll.inter.OnPagerListener;
import org.yczbj.ycrefreshview.scroll.recycler.PagerLayoutManager;
import org.yczbj.ycrefreshviewlib.utils.RefreshLogUtils;
public class ScrollActivity extends AppCompatActivity {
private RecyclerView recyclerView;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
recyclerView = findViewById(R.id.recyclerView);
initRecyclerView();
}
private void initRecyclerView() {
PagerLayoutManager viewPagerLayoutManager = new PagerLayoutManager(
this, OrientationHelper.VERTICAL);
ScrollAdapter adapter = new ScrollAdapter(this);
recyclerView.setAdapter(adapter);
recyclerView.setLayoutManager(viewPagerLayoutManager);
viewPagerLayoutManager.setOnViewPagerListener(new OnPagerListener() {
@Override
public void onInitComplete() {
System.out.println("OnPagerListener---onInitComplete--"+"初始化完成");
RefreshLogUtils.d("OnPagerListener---onInitComplete--"+"初始化完成");
}
@Override
public void onPageRelease(boolean isNext, int position) {
System.out.println("OnPagerListener---onPageRelease--"+position+"-----"+isNext);
RefreshLogUtils.d("OnPagerListener---onPageRelease--"+position+"-----"+isNext);
}
@Override
public void onPageSelected(int position, boolean isBottom) {
System.out.println("OnPagerListener---onPageSelected--"+position+"-----"+isBottom);
RefreshLogUtils.d("OnPagerListener---onPageSelected--"+position+"-----"+isBottom);
}
});
adapter.setData(DataProvider.getList(30));
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/ScrollAdapter.java | Java | package org.yczbj.ycrefreshview.scroll;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import java.util.ArrayList;
import java.util.List;
public class ScrollAdapter extends RecyclerView.Adapter<ScrollAdapter.MyViewHolder> {
private Context mContext;
private OnItemClickListener listener;
public ScrollAdapter(Context context) {
this.mContext = context;
}
private List<PersonData> data = new ArrayList<>();
public void setData(List<PersonData> data) {
this.data = data;
notifyDataSetChanged();
}
public List<PersonData> getData() {
return data;
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
@NonNull
@Override
public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(mContext).inflate(R.layout.item_image_pager, parent, false);
return new MyViewHolder(view);
}
@Override
public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
holder.imageView.setBackgroundResource(data.get(position).getImage());
}
class MyViewHolder extends RecyclerView.ViewHolder {
ImageView imageView;
MyViewHolder(final View itemView) {
super(itemView);
imageView = itemView.findViewById(R.id.iv_image);
}
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/ScrollPagerActivity.java | Java | package org.yczbj.ycrefreshview.scroll;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.scroll.pager.LayoutViewPager;
import org.yczbj.ycrefreshview.scroll.pager.AbsPagerAdapter;
import org.yczbj.ycrefreshview.scroll.inter.OnPagerListener;
import java.util.List;
public class ScrollPagerActivity extends AppCompatActivity {
private LayoutViewPager vp;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_view_pager);
vp = findViewById(R.id.vp);
initViewPager();
}
private void initViewPager() {
List<PersonData> list = DataProvider.getList(30);
vp.setOffscreenPageLimit(1);
vp.setCurrentItem(0);
BannerPagerAdapter adapter = new BannerPagerAdapter(list);
vp.setAdapter(adapter);
vp.setAnimationDuration(1000);
vp.setOnViewPagerListener(new OnPagerListener() {
@Override
public void onInitComplete() {
}
@Override
public void onPageRelease(boolean isNext, int position) {
}
@Override
public void onPageSelected(int position, boolean isBottom) {
}
});
}
class BannerPagerAdapter extends AbsPagerAdapter {
private List<PersonData> data;
public BannerPagerAdapter(List<PersonData> dataList) {
super(dataList);
this.data = dataList;
}
@Override
public View getView(ViewGroup container, int position) {
View view = LayoutInflater.from(container.getContext()).inflate(
R.layout.item_image_pager, container, false);
ImageView imageView = view.findViewById(R.id.iv_image);
imageView.setImageResource(data.get(position).getImage());
return view;
}
@Override
public int getCount() {
return data.size();
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/inter/OnPagerListener.java | Java | package org.yczbj.ycrefreshview.scroll.inter;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/7/23
* desc : 自定义LinearLayoutManager
* revise:
* </pre>
*/
public interface OnPagerListener {
/**
* 初始化完成
*/
void onInitComplete();
/**
* 释放的监听
* @param isNext 是否下一个，true表示下一个，false表示上一个
* @param position 索引
*/
void onPageRelease(boolean isNext,int position);
/***
* 选中的监听以及判断是否滑动到底部
* @param position 索引
* @param isBottom 是否到了底部
*/
void onPageSelected(int position , boolean isBottom);
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/pager/AbsPagerAdapter.java | Java | package org.yczbj.ycrefreshview.scroll.pager;
import androidx.annotation.NonNull;
import androidx.viewpager.widget.PagerAdapter;
import android.util.SparseArray;
import android.view.View;
import android.view.ViewGroup;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/7/20
* desc : 动态管理的Adapter。
* 每次都会创建新view，销毁旧View。节省内存消耗性能
* revise: 比如使用场景是启动引导页
* </pre>
*/
public abstract class AbsPagerAdapter<T> extends PagerAdapter {
private List<T> mDataList;
private SparseArray<View> mViewSparseArray;
public AbsPagerAdapter(List<T> dataList) {
mDataList = dataList;
mViewSparseArray = new SparseArray<>(dataList.size());
}
@Override
public int getCount() {
if (mDataList == null) {
return 0;
}
return mDataList.size();
}
@Override
public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
return view == object;
}
@NonNull
@Override
public Object instantiateItem(@NonNull ViewGroup container, int position) {
View view = mViewSparseArray.get(position);
if (view == null) {
view = getView(container,position);
mViewSparseArray.put(position, view);
}
container.addView(view);
return view;
}
@Override
public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
container.removeView(mViewSparseArray.get(position));
}
/**
* 子类重写的方法
* @param container container
* @param position 索引
* @return 返回view
*/
public abstract View getView(ViewGroup container, int position);
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/pager/BaseTransformer.java | Java |
package org.yczbj.ycrefreshview.scroll.pager;
import androidx.annotation.NonNull;
import androidx.viewpager.widget.ViewPager.PageTransformer;
import android.view.View;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2019/6/20
* desc : BaseTransformer
* revise:
* </pre>
*/
public abstract class BaseTransformer implements PageTransformer {
/**
* 子类实现
* @param page view
* @param position 索引
*/
protected abstract void onTransform(View page, float position);
@Override
public void transformPage(@NonNull View page, float position) {
onPreTransform(page, position);
onTransform(page, position);
}
protected boolean hideOffscreenPages() {
return true;
}
protected boolean isPagingEnabled() {
return false;
}
protected void onPreTransform(View page, float position) {
final float width = page.getWidth();
page.setRotationX(0);
page.setRotationY(0);
page.setRotation(0);
page.setScaleX(1);
page.setScaleY(1);
page.setPivotX(0);
page.setPivotY(0);
page.setTranslationY(0);
page.setTranslationX(isPagingEnabled() ? 0f : -width * position);
if (hideOffscreenPages()) {
page.setAlpha(position <= -1f || position >= 1f ? 0f : 1f);
} else {
page.setAlpha(1f);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/pager/DefaultTransformer.java | Java |
package org.yczbj.ycrefreshview.scroll.pager;
import android.view.View;
public class DefaultTransformer extends BaseTransformer {
/**
* 参照：https://github.com/ToxicBakery/ViewPagerTransforms
*/
@Override
protected void onTransform(View view, float position) {
}
@Override
public boolean isPagingEnabled() {
return true;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/pager/LayoutViewPager.java | Java | package org.yczbj.ycrefreshview.scroll.pager;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import androidx.viewpager.widget.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.animation.Interpolator;
import android.widget.Scroller;
import org.yczbj.ycrefreshview.scroll.inter.OnPagerListener;
import java.lang.reflect.Field;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2019/6/20
* desc : 自定义ViewPager，主要是处理边界极端情况
* revise:
* </pre>
*/
public class LayoutViewPager extends ViewPager implements ViewPager.OnPageChangeListener {
private boolean scrollable = true;
private long mRecentTouchTime;
private OnPagerListener mOnViewPagerListener;
/**
* 位移，用来判断移动方向
*/
private int mDrift;
/**
* 索引
*/
private int position;
public LayoutViewPager(Context context) {
super(context);
}
public LayoutViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
if(this.scrollable) {
if (getCurrentItem() == 0 && getChildCount() == 0) {
return false;
}
return super.onTouchEvent(ev);
} else {
return false;
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
mRecentTouchTime = System.currentTimeMillis();
if(this.scrollable) {
if (getCurrentItem() == 0 && getChildCount() == 0) {
return false;
}
return super.onInterceptTouchEvent(ev);
} else {
return false;
}
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
this.addOnAttachStateChangeListener(listener);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
this.removeOnAttachStateChangeListener(listener);
}
/**
* 这是为了响应该视图中的内部滚动(即,视图滚动了它自己的内容)。这通常是由于
* {@link #scrollBy(int, int)}或{@link #scrollTo(int, int)}已经存在调用。
* @param l 横向位移
* @param t 竖直方向滑动位移
* @param oldl 之前横向位移
* @param oldt 之前竖直方向滑动位移
*/
@Override
protected void onScrollChanged(int l, int t, int oldl, int oldt) {
super.onScrollChanged(l, t, oldl, oldt);
mDrift = t - oldt;
}
/**
* 设置监听
* @param listener listener
*/
public void setOnViewPagerListener(OnPagerListener listener){
this.mOnViewPagerListener = listener;
}
@Override
public void onPageScrolled(int i, float v, int i1) {
super.onPageScrolled(i, v, i1);
}
@Override
public void onPageSelected(int i) {
this.position = i;
}
@Override
public void onPageScrollStateChanged(int i) {
}
/**
* 设置viewPager滑动动画持续时间
* API>19
*/
@TargetApi(Build.VERSION_CODES.KITKAT)
public void setAnimationDuration(final int during){
try {
// viewPager平移动画事件
Field mField = ViewPager.class.getDeclaredField("mScroller");
mField.setAccessible(true);
// 动画效果与ViewPager的一致
Interpolator interpolator = new Interpolator() {
@Override
public float getInterpolation(float t) {
t -= 1.0f;
return t * t * t * t * t + 1.0f;
}
};
Scroller mScroller = new Scroller(getContext(),interpolator){
final int time = 2000;
@Override
public void startScroll(int x, int y, int dx, int dy, int duration) {
// 如果手工滚动,则加速滚动
if (System.currentTimeMillis() - mRecentTouchTime > time) {
duration = during;
} else {
duration /= 2;
}
super.startScroll(x, y, dx, dy, duration);
}
@Override
public void startScroll(int x, int y, int dx, int dy) {
super.startScroll(x, y, dx, dy,during);
}
};
mField.set(this, mScroller);
} catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
e.printStackTrace();
}
}
/**
* attach状态变化的监听listener
*/
private OnAttachStateChangeListener listener = new OnAttachStateChangeListener() {
@Override
public void onViewAttachedToWindow(View v) {
if (mOnViewPagerListener != null && getChildCount() == 1) {
mOnViewPagerListener.onInitComplete();
}
}
@Override
public void onViewDetachedFromWindow(View v) {
if (mDrift >= 0){
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(true , position);
}
}else {
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(false , position);
}
}
}
};
/**
* 设置是否可以滚动
* @param scrollable 布尔值
*/
public void setScrollable(boolean scrollable) {
this.scrollable = scrollable;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/recycler/PagerLayoutManager.java | Java | package org.yczbj.ycrefreshview.scroll.recycler;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.RecyclerView;
import android.view.Gravity;
import android.view.View;
import org.yczbj.ycrefreshview.scroll.inter.OnPagerListener;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/7/23
* desc : 自定义LinearLayoutManager
* revise:
* </pre>
*/
public class PagerLayoutManager extends LinearLayoutManager {
private RecyclerView mRecyclerView;
private ScrollPageHelper mPagerSnapHelper;
private OnPagerListener mOnViewPagerListener;
private static final int HORIZONTAL = OrientationHelper.HORIZONTAL;
private static final int VERTICAL = OrientationHelper.VERTICAL;
private int mOrientation;
/**
* 位移，用来判断移动方向
*/
private int mDrift;
public PagerLayoutManager(Context context, int orientation) {
super(context, orientation, false);
this.mOrientation = orientation;
init();
}
public PagerLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
this.mOrientation = orientation;
init();
}
/**
* 初始化操作
*/
private void init() {
switch (mOrientation){
case HORIZONTAL:
mPagerSnapHelper = new ScrollPageHelper(Gravity.START,false);
break;
case VERTICAL:
mPagerSnapHelper = new ScrollPageHelper(Gravity.TOP,false);
break;
default:
mPagerSnapHelper = new ScrollPageHelper(Gravity.TOP,false);
break;
}
}
/**
* attach到window窗口时，该方法必须调用
* @param recyclerView recyclerView
*/
@Override
public void onAttachedToWindow(RecyclerView recyclerView) {
if (recyclerView == null) {
throw new IllegalArgumentException("The attach RecycleView must not null!!");
}
super.onAttachedToWindow(recyclerView);
this.mRecyclerView = recyclerView;
if (mPagerSnapHelper==null){
init();
}
mPagerSnapHelper.attachToRecyclerView(mRecyclerView);
mRecyclerView.addOnChildAttachStateChangeListener(mChildAttachStateChangeListener);
}
/**
* 销毁的时候调用该方法，需要移除监听事件
* @param view view
* @param recycler recycler
*/
@Override
public void onDetachedFromWindow(RecyclerView view, RecyclerView.Recycler recycler) {
super.onDetachedFromWindow(view, recycler);
if (mRecyclerView!=null){
mRecyclerView.removeOnChildAttachStateChangeListener(mChildAttachStateChangeListener);
}
}
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
super.onLayoutChildren(recycler, state);
}
/**
* 滑动状态的改变
* 缓慢拖拽-> SCROLL_STATE_DRAGGING
* 快速滚动-> SCROLL_STATE_SETTLING
* 空闲状态-> SCROLL_STATE_IDLE
* @param state 状态
*/
@Override
public void onScrollStateChanged(int state) {
switch (state) {
case RecyclerView.SCROLL_STATE_IDLE:
View viewIdle = mPagerSnapHelper.findSnapView(this);
int positionIdle = 0;
if (viewIdle != null) {
positionIdle = getPosition(viewIdle);
}
int childCount = getChildCount();
if (mOnViewPagerListener != null && childCount == 1) {
mOnViewPagerListener.onPageSelected(positionIdle,
positionIdle == childCount - 1);
}
break;
case RecyclerView.SCROLL_STATE_DRAGGING:
View viewDrag = mPagerSnapHelper.findSnapView(this);
if (viewDrag != null) {
int positionDrag = getPosition(viewDrag);
}
break;
case RecyclerView.SCROLL_STATE_SETTLING:
View viewSettling = mPagerSnapHelper.findSnapView(this);
if (viewSettling != null) {
int positionSettling = getPosition(viewSettling);
}
break;
default:
break;
}
}
/**
* 监听竖直方向的相对偏移量
* @param dy y轴滚动值
* @param recycler recycler
* @param state state滚动状态
* @return int值
*/
@Override
public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (getChildCount() == 0 || dy == 0) {
return 0;
}
this.mDrift = dy;
return super.scrollVerticallyBy(dy, recycler, state);
}
/**
* 监听水平方向的相对偏移量
* @param dx x轴滚动值
* @param recycler recycler
* @param state state滚动状态
* @return int值
*/
@Override
public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (getChildCount() == 0 || dx == 0) {
return 0;
}
this.mDrift = dx;
return super.scrollHorizontallyBy(dx, recycler, state);
}
/**
* 设置监听
* @param listener listener
*/
public void setOnViewPagerListener(OnPagerListener listener){
this.mOnViewPagerListener = listener;
}
private RecyclerView.OnChildAttachStateChangeListener mChildAttachStateChangeListener =
new RecyclerView.OnChildAttachStateChangeListener() {
/**
* 第一次进入界面的监听，可以做初始化方面的操作
* @param view view
*/
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
if (mOnViewPagerListener != null && getChildCount() == 1) {
mOnViewPagerListener.onInitComplete();
}
}
/**
* 页面销毁的时候调用该方法，可以做销毁方面的操作
* @param view view
*/
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
if (mDrift >= 0){
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(true , getPosition(view));
}
}else {
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(false , getPosition(view));
}
}
}
};
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/scroll/recycler/ScrollPageHelper.java | Java | package org.yczbj.ycrefreshview.scroll.recycler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.PagerSnapHelper;
import androidx.recyclerview.widget.RecyclerView;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.View;
import java.util.Locale;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/3/18
* desc : 自定义SnapHelper，设置左对齐，滑动时候会限制item只滑动一个。可以设置gravity位置对齐
* revise: 关于SnapHelper源码分析可以看我博客：https://blog.csdn.net/m0_37700275/article/details/83901677
* </pre>
*/
public class ScrollPageHelper extends PagerSnapHelper {
private OrientationHelper mHorizontalHelper, mVerticalHelper;
private int gravity;
private boolean snapLastItem;
private boolean isRtlHorizontal;
/**
* 构造方法
* @param gravity 位置
* @param enableSnapLast 最后一个是否按照位置对齐
*/
public ScrollPageHelper(int gravity, boolean enableSnapLast){
this.snapLastItem = enableSnapLast;
this.gravity = gravity;
}
@Override
public void attachToRecyclerView(@Nullable RecyclerView recyclerView)
throws IllegalStateException {
if (recyclerView != null && !(recyclerView.getLayoutManager()
instanceof LinearLayoutManager)) {
throw new IllegalStateException("ScrollPageHelper needs a " +
"RecyclerView with a LinearLayoutManager");
}
if (recyclerView != null) {
//设置fling监听为null
recyclerView.setOnFlingListener(null);
if ((gravity == Gravity.START || gravity == Gravity.END)) {
isRtlHorizontal = isRtl();
}
}
super.attachToRecyclerView(recyclerView);
}
/**
*
* @param layoutManager layoutManager
* @param targetView 目标view
* @return
*/
@Nullable
@Override
public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager,
@NonNull View targetView) {
//创建数组
int[] out = new int[2];
//判断是否是横向方法
if (layoutManager.canScrollHorizontally()) {
if (gravity == Gravity.START) {
out[0] = distanceToStart(targetView, getHorizontalHelper(layoutManager), false);
} else { // END
out[0] = distanceToEnd(targetView, getHorizontalHelper(layoutManager), false);
}
} else {
out[0] = 0;
}
//判断是否是竖直方法
if (layoutManager.canScrollVertically()) {
if (gravity == Gravity.TOP) {
out[1] = distanceToStart(targetView, getVerticalHelper(layoutManager), false);
} else { // BOTTOM
out[1] = distanceToEnd(targetView, getVerticalHelper(layoutManager), false);
}
} else {
out[1] = 0;
}
return out;
}
/**
* 找到当前时刻的SnapView
* @param layoutManager layoutManager
* @return
*/
@Nullable
@Override
public View findSnapView(RecyclerView.LayoutManager layoutManager) {
View snapView = null;
if (layoutManager instanceof LinearLayoutManager) {
switch (gravity) {
case Gravity.START:
snapView = findStartView(layoutManager, getHorizontalHelper(layoutManager));
break;
case Gravity.END:
snapView = findEndView(layoutManager, getHorizontalHelper(layoutManager));
break;
case Gravity.TOP:
snapView = findStartView(layoutManager, getVerticalHelper(layoutManager));
break;
case Gravity.BOTTOM:
snapView = findEndView(layoutManager, getVerticalHelper(layoutManager));
break;
default:
break;
}
}
return snapView;
}
private boolean isRtl() {
return TextUtils.getLayoutDirectionFromLocale(
Locale.getDefault()) == View.LAYOUT_DIRECTION_RTL;
}
@NonNull
private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
if (mVerticalHelper == null) {
mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
}
return mVerticalHelper;
}
@NonNull
private OrientationHelper getHorizontalHelper(
@NonNull RecyclerView.LayoutManager layoutManager) {
if (mHorizontalHelper == null) {
mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
}
return mHorizontalHelper;
}
private int distanceToStart(View targetView, @NonNull OrientationHelper helper, boolean fromEnd) {
if (isRtlHorizontal && !fromEnd) {
return distanceToEnd(targetView, helper, true);
}
return helper.getDecoratedStart(targetView) - helper.getStartAfterPadding();
}
private int distanceToEnd(View targetView, @NonNull OrientationHelper helper, boolean fromStart) {
if (isRtlHorizontal && !fromStart) {
return distanceToStart(targetView, helper, true);
}
return helper.getDecoratedEnd(targetView) - helper.getEndAfterPadding();
}
@Nullable
private View findStartView(RecyclerView.LayoutManager layoutManager,
@NonNull OrientationHelper helper) {
if (layoutManager instanceof LinearLayoutManager) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
boolean reverseLayout = linearLayoutManager.getReverseLayout();
int firstChild = reverseLayout ? linearLayoutManager.findLastVisibleItemPosition()
: linearLayoutManager.findFirstVisibleItemPosition();
int offset = 1;
if (layoutManager instanceof GridLayoutManager) {
offset += ((GridLayoutManager) layoutManager).getSpanCount() - 1;
}
if (firstChild == RecyclerView.NO_POSITION) {
return null;
}
View child = layoutManager.findViewByPosition(firstChild);
float visibleWidth;
if (isRtlHorizontal) {
visibleWidth = (float) (helper.getTotalSpace() - helper.getDecoratedStart(child))
/ helper.getDecoratedMeasurement(child);
} else {
visibleWidth = (float) helper.getDecoratedEnd(child)
/ helper.getDecoratedMeasurement(child);
}
boolean endOfList;
if (!reverseLayout) {
endOfList = ((LinearLayoutManager) layoutManager)
.findLastCompletelyVisibleItemPosition()
== layoutManager.getItemCount() - 1;
} else {
endOfList = ((LinearLayoutManager) layoutManager)
.findFirstCompletelyVisibleItemPosition()
== 0;
}
if (visibleWidth > 0.5f && !endOfList) {
return child;
} else if (snapLastItem && endOfList) {
return child;
} else if (endOfList) {
return null;
} else {
return reverseLayout ? layoutManager.findViewByPosition(firstChild - offset)
: layoutManager.findViewByPosition(firstChild + offset);
}
}
return null;
}
@Nullable
private View findEndView(RecyclerView.LayoutManager layoutManager,
@NonNull OrientationHelper helper) {
if (layoutManager instanceof LinearLayoutManager) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
boolean reverseLayout = linearLayoutManager.getReverseLayout();
int lastChild = reverseLayout ? linearLayoutManager.findFirstVisibleItemPosition()
: linearLayoutManager.findLastVisibleItemPosition();
int offset = 1;
if (layoutManager instanceof GridLayoutManager) {
offset += ((GridLayoutManager) layoutManager).getSpanCount() - 1;
}
if (lastChild == RecyclerView.NO_POSITION) {
return null;
}
View child = layoutManager.findViewByPosition(lastChild);
float visibleWidth;
if (isRtlHorizontal) {
visibleWidth = (float) helper.getDecoratedEnd(child)
/ helper.getDecoratedMeasurement(child);
} else {
visibleWidth = (float) (helper.getTotalSpace() - helper.getDecoratedStart(child))
/ helper.getDecoratedMeasurement(child);
}
boolean startOfList;
if (!reverseLayout) {
startOfList = ((LinearLayoutManager) layoutManager)
.findFirstCompletelyVisibleItemPosition() == 0;
} else {
startOfList = ((LinearLayoutManager) layoutManager)
.findLastCompletelyVisibleItemPosition()
== layoutManager.getItemCount() - 1;
}
if (visibleWidth > 0.5f && !startOfList) {
return child;
} else if (snapLastItem && startOfList) {
return child;
} else if (startOfList) {
return null;
} else {
return reverseLayout ? layoutManager.findViewByPosition(lastChild + offset)
: layoutManager.findViewByPosition(lastChild - offset);
}
}
return null;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/select/SelectFollowActivity.java | Java | package org.yczbj.ycrefreshview.select;
import android.os.Bundle;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import com.yc.selectviewlib.SelectRecyclerView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
import java.util.ArrayList;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2016/03/22
* desc : 关注点页面
* revise: https://github.com/yangchong211/YCRecycleView
* </pre>
*/
public class SelectFollowActivity extends AppCompatActivity implements View.OnClickListener {
FrameLayout llTitleMenu;
TextView toolbarTitle;
TextView tvTitleRight;
SelectRecyclerView selectView;
TextView tvClean;
TextView tvStart;
private SelectFollowAdapter adapter;
private List<SelectPoint> lists = new ArrayList<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_select_follow);
initView();
initListener();
initData();
}
public void initView() {
initFindViewById();
initToolBar();
initRecycleView();
}
private void initFindViewById() {
llTitleMenu = findViewById(R.id.ll_title_menu);
toolbarTitle = findViewById(R.id.toolbar_title);
tvTitleRight = findViewById(R.id.tv_title_right);
selectView = findViewById(R.id.select_view);
tvClean = findViewById(R.id.tv_clean);
tvStart = findViewById(R.id.tv_start);
}
private void initToolBar() {
toolbarTitle.setText("关注点");
tvTitleRight.setVisibility(View.VISIBLE);
tvTitleRight.setText("跳过");
}
public void initListener() {
llTitleMenu.setOnClickListener(this);
tvTitleRight.setOnClickListener(this);
tvClean.setOnClickListener(this);
tvStart.setOnClickListener(this);
adapter.setOnItemClickListener(new SelectFollowAdapter.OnListItemClickListener() {
@Override
public void onItemClick(View view, int position) {
if (adapter.data != null && adapter.data.size() > 0) {
adapter.toggleSelected(position);
}
}
});
}
public void initData() {
List<SelectPoint> list = new ArrayList<>();
String[] titles = this.getResources().getStringArray(R.array.select_follow);
for(int a=0 ; a<titles.length ; a++){
SelectPoint selectPoint = new SelectPoint();
selectPoint.setName(titles[a]);
list.add(selectPoint);
}
refreshData(list);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.ll_title_menu:
break;
case R.id.tv_title_right:
break;
case R.id.tv_clean:
if(adapter!=null && adapter.data!=null){
adapter.clearSelected();
}
break;
default:
break;
}
}
private void initRecycleView() {
selectView.setLayoutManager(new GridLayoutManager(this, 4));
adapter = new SelectFollowAdapter(this, lists);
selectView.setAdapter(adapter);
//下划线
SpaceViewItemLine itemDecoration = new SpaceViewItemLine(10);
itemDecoration.setPaddingEdgeSide(false);
itemDecoration.setPaddingStart(false);
itemDecoration.setPaddingHeaderFooter(false);
selectView.addItemDecoration(itemDecoration);
}
public void refreshData(List<SelectPoint> list) {
lists.clear();
lists.addAll(list);
adapter.notifyDataSetChanged();
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/select/SelectFollowAdapter.java | Java | package org.yczbj.ycrefreshview.select;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.selectviewlib.SelectRecyclerViewAdapter;
import org.yczbj.ycrefreshview.R;
import java.util.List;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2016/03/22
* desc : 关注点页面适配器
* revise:
* </pre>
*/
public class SelectFollowAdapter extends SelectRecyclerViewAdapter<SelectFollowAdapter.MyViewHolder> {
public Activity activity;
public List<SelectPoint> data;
public SelectFollowAdapter(Activity activity, List<SelectPoint> data) {
this.activity = activity;
this.data = data;
}
@Override
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = LayoutInflater.from(activity).inflate(R.layout.tag_select_follow, parent, false);
return new MyViewHolder(view , mItemClickListener);
}
@SuppressLint("MissingSuperCall")
@Override
public void onBindViewHolder(MyViewHolder holder, int position) {
if(data!=null && data.size()>0){
holder.tvName.setText(data.get(position).getName());
if(isIndexSelected(position)){
holder.tvName.setBackgroundResource(R.drawable.shape_btn_color_bg_press);
holder.tvName.setTextColor(activity.getResources().getColor(R.color.colorAccent));
}else {
holder.tvName.setBackgroundResource(R.drawable.shape_btn_color_bg);
holder.tvName.setTextColor(activity.getResources().getColor(R.color.color_666666));
}
}
}
@Override
public int getItemCount() {
return data!=null ? data.size() : 0;
}
class MyViewHolder extends RecyclerView.ViewHolder{
private OnListItemClickListener listener;
TextView tvName;
MyViewHolder(View itemView , OnListItemClickListener mItemClickListener) {
super(itemView);
tvName = itemView.findViewById(R.id.tv_name);
this.listener = mItemClickListener;
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
listener.onItemClick(v,getAdapterPosition());
}
});
}
}
private OnListItemClickListener mItemClickListener;
public void setOnItemClickListener(OnListItemClickListener listener) {
this.mItemClickListener = listener;
}
public interface OnListItemClickListener {
void onItemClick(View view, int position);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/select/SelectPoint.java | Java | package org.yczbj.ycrefreshview.select;
public class SelectPoint {
private int id;
private String name;
private int index;
private String logo;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getLogo() {
return logo;
}
public void setLogo(String logo) {
this.logo = logo;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/slide/HhItemClickListener.java | Java | package org.yczbj.ycrefreshview.slide;
import android.view.View;
public interface HhItemClickListener {
void onItemClick(View view, int position);
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/slide/ItemSlideAdapter.java | Java | package org.yczbj.ycrefreshview.slide;
import android.app.Activity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.slideview.SlideHelper;
import com.yc.slideview.SlideViewHolder;
import org.yczbj.ycrefreshview.R;
import java.util.List;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/7/3
* 描 述：我的项目页面 适配器adapter
* 修订历史：
* ================================================
*/
public class ItemSlideAdapter extends RecyclerView.Adapter {
private Activity activity;
private SlideHelper mISlideHelper = new SlideHelper();
private List<YCBean> mData;
private OnDeleteClickListener mDeleteListener;
ItemSlideAdapter(Activity activity, OnDeleteClickListener mDeleteListener) {
this.activity = activity;
this.mDeleteListener = mDeleteListener;
}
public void setData(List<YCBean> mData) {
this.mData = mData;
notifyDataSetChanged();
}
void slideOpen() {
mISlideHelper.slideOpen();
}
void slideClose() {
mISlideHelper.slideClose();
}
private HhItemClickListener mItemClickListener;
void setOnItemClickListener(HhItemClickListener listener) {
this.mItemClickListener = listener;
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View inflate = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_slide_view, parent, false);
OneSlideViewHolder oneSlideViewHolder = new OneSlideViewHolder(inflate, mItemClickListener, mDeleteListener);
mISlideHelper.add(oneSlideViewHolder);
return oneSlideViewHolder;
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
((OneSlideViewHolder) holder).bind(position);
}
@Override
public int getItemCount() {
return mData == null ? 0 : mData.size();
}
private class OneSlideViewHolder extends SlideViewHolder implements View.OnClickListener {
private OnDeleteClickListener deleteListener;
private HhItemClickListener mListener;
private RelativeLayout rl_item;
private FrameLayout fl_menu;
private TextView item_tv_delete, tv_go_edit, tv_project_title;
private OneSlideViewHolder(View view, final HhItemClickListener mItemClickListener, OnDeleteClickListener mDeleteListener) {
super(view);
this.mListener = mItemClickListener;
this.deleteListener = mDeleteListener;
rl_item = (RelativeLayout) view.findViewById(R.id.rl_item);
fl_menu = (FrameLayout) view.findViewById(R.id.fl_menu);
item_tv_delete = (TextView) view.findViewById(R.id.item_tv_delete);
tv_go_edit = (TextView) view.findViewById(R.id.tv_go_edit);
tv_project_title = (TextView) view.findViewById(R.id.tv_project_title);
view.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (mListener != null) {
mListener.onItemClick(view, getAdapterPosition());
}
}
});
item_tv_delete.setOnClickListener(this);
tv_go_edit.setOnClickListener(this);
fl_menu.setVisibility(View.GONE);
}
@Override
public void doAnimationSet(int offset, float fraction) {
rl_item.scrollTo(offset, 0);
}
@Override
public void onBindSlideClose(int state) {
fl_menu.setVisibility(View.VISIBLE);
}
@Override
public void doAnimationSetOpen(int state) {
fl_menu.setVisibility(View.VISIBLE);
}
void bind(int position) {
setOffset(70);
onBindSlide(rl_item);
tv_project_title.setText(mData.get(position).getName());
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.item_tv_delete:
if (deleteListener != null) {
deleteListener.onEditDeleteClick(view, item_tv_delete, getAdapterPosition());
}
break;
case R.id.tv_go_edit:
break;
default:
break;
}
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/slide/OnDeleteClickListener.java | Java | package org.yczbj.ycrefreshview.slide;
import android.view.View;
import android.widget.TextView;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/7/3
* 描 述：item侧滑后，点击删除接口
* 修订历史：
* ================================================
*/
public interface OnDeleteClickListener {
void onEditDeleteClick(View view, TextView textView, int position);
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/slide/SlideViewActivity.java | Java | package org.yczbj.ycrefreshview.slide;
import android.graphics.Color;
import android.os.Bundle;
import androidx.appcompat.app.ActionBar;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.DefaultItemAnimator;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.appcompat.widget.Toolbar;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import java.util.ArrayList;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/6/21
* 描 述：新芽项目的小案例
* 修订历史：
* ================================================
*/
public class SlideViewActivity extends AppCompatActivity implements View.OnClickListener {
private FrameLayout ll_title_menu;
private TextView toolbar_title;
private TextView tv_title_right;
private Toolbar toolbar;
private RecyclerView recyclerView;
private OnDeleteClickListener mDeleteListener;
private ItemSlideAdapter adapter;
private ArrayList<YCBean> list = new ArrayList<>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_slide_view);
initViewId();
initToolBar();
initDeleteListener();
initRecycleView();
initListener();
}
@Override
protected void onDestroy() {
super.onDestroy();
if ("取消编辑".equals(tv_title_right.getText().toString())) {
tv_title_right.setText("编辑");
adapter.slideClose();
}
}
private void initViewId() {
ll_title_menu = (FrameLayout) findViewById(R.id.ll_title_menu);
toolbar_title = (TextView) findViewById(R.id.toolbar_title);
tv_title_right = (TextView) findViewById(R.id.tv_title_right);
toolbar = (Toolbar) findViewById(R.id.toolbar);
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
}
private void initToolBar() {
toolbar_title.setText("我的项目");
setSupportActionBar(toolbar);
ActionBar actionBar = getSupportActionBar();
if (actionBar != null) {
//去除默认Title显示
actionBar.setDisplayShowTitleEnabled(false);
}
tv_title_right.setVisibility(View.VISIBLE);
tv_title_right.setText("编辑");
}
private void initListener() {
ll_title_menu.setOnClickListener(this);
tv_title_right.setOnClickListener(this);
adapter.setOnItemClickListener(new HhItemClickListener() {
@Override
public void onItemClick(View view, int position) {
if ("取消编辑".equals(tv_title_right.getText().toString())) {
tv_title_right.setText("编辑");
adapter.slideClose();
}
Toast.makeText(SlideViewActivity.this,"条目点击事件"+position,Toast.LENGTH_SHORT).show();
}
});
}
private void initDeleteListener() {
mDeleteListener = new OnDeleteClickListener() {
@Override
public void onEditDeleteClick(View view, TextView textView, int position) {
Toast.makeText(SlideViewActivity.this,"条目删除事件"+position,Toast.LENGTH_SHORT).show();
if (position > -1) {
list.remove(position);
adapter.notifyItemRemoved(position);
}
}
};
}
private void initRecycleView() {
for(int a=0 ; a<20 ; a++){
YCBean bean;
if(a==3||a==8||a==14||a==16){
bean = new YCBean("",2,"修改","","杨充"+a,"2000","美元","北京","你好");
}else {
bean = new YCBean("",2,"完成","","杨充"+a,"2000","美元","北京","你好");
}
list.add(bean);
}
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setHasFixedSize(true); // 如果Item够简单，高度是确定的，打开FixSize将提高性能。
recyclerView.setItemAnimator(new DefaultItemAnimator()); // 设置Item默认动画，加也行，不加也行。
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
20, Color.parseColor("#f5f5f7"));
recyclerView.addItemDecoration(line);// 添加分割线。
adapter = new ItemSlideAdapter(this, mDeleteListener);
recyclerView.setAdapter(adapter);
adapter.setData(list);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.ll_title_menu:
finish();
break;
case R.id.tv_title_right:
if ("编辑".equals(tv_title_right.getText().toString())) {
tv_title_right.setText("取消编辑");
adapter.slideOpen();
} else if ("取消编辑".equals(tv_title_right.getText().toString())) {
tv_title_right.setText("编辑");
adapter.slideClose();
}
break;
default:
break;
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/slide/YCBean.java | Java | package org.yczbj.ycrefreshview.slide;
/**
* Created by PC on 2017/12/14.
* 作者：PC
*/
public class YCBean {
private String oid;
private int id;
private String status;
private String logo;
private String name;
private String round;
private String amt;
private String currency;
private String fname;
public YCBean(String oid, int id, String status, String logo, String name, String round, String amt, String currency, String fname) {
this.oid = oid;
this.id = id;
this.status = status;
this.logo = logo;
this.name = name;
this.round = round;
this.amt = amt;
this.currency = currency;
this.fname = fname;
}
public String getOid() {
return oid;
}
public void setOid(String oid) {
this.oid = oid;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getLogo() {
return logo;
}
public void setLogo(String logo) {
this.logo = logo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRound() {
return round;
}
public void setRound(String round) {
this.round = round;
}
public String getAmt() {
return amt;
}
public void setAmt(String amt) {
this.amt = amt;
}
public String getCurrency() {
return currency;
}
public void setCurrency(String currency) {
this.currency = currency;
}
public String getFname() {
return fname;
}
public void setFname(String fname) {
this.fname = fname;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/AdViewHolder.java | Java | package org.yczbj.ycrefreshview.staggered;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.AdData;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class AdViewHolder extends BaseViewHolder<AdData> {
public AdViewHolder(ViewGroup parent) {
super(new ImageView(parent.getContext()));
ImageView imageView = (ImageView) itemView;
imageView.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) AppUtils.convertDpToPixel(156,getContext())));
imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
@Override
public void setData(final AdData data) {
ImageView imageView = (ImageView) itemView;
Glide.with(getContext())
.load(data.getImage())
.placeholder(R.drawable.default_image)
.into(imageView);
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/ImageAdapter.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.content.Context;
import android.view.ViewGroup;
import org.yczbj.ycrefreshview.data.PictureData;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class ImageAdapter extends RecyclerArrayAdapter<PictureData> {
public ImageAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new ImageViewHolder(parent);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/ImageStageredAdapter.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.content.Context;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PictureData;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class ImageStageredAdapter extends RecyclerArrayAdapter<PictureData> {
public ImageStageredAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new ImageViewHolder(parent);
}
public class ImageViewHolder extends BaseViewHolder<PictureData> {
ImageView imgPicture;
public ImageViewHolder(ViewGroup parent) {
super(new ImageView(parent.getContext()));
imgPicture = (ImageView) itemView;
imgPicture.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT));
imgPicture.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
@Override
public void setData(PictureData data) {
ViewGroup.LayoutParams params = imgPicture.getLayoutParams();
int setHeight = getAdapterPosition()%5;
//计算View的高度
int height = 300;
switch (setHeight){
case 0:
height = 500;
break;
case 1:
height = 750;
break;
case 2:
height = 880;
break;
case 3:
height = 360;
break;
case 4:
height = 660;
break;
default:
break;
}
params.height = height;
imgPicture.setLayoutParams(params);
Glide.with(getContext())
.load(data.getImage())
.placeholder(R.drawable.bg_small_tree_min)
.into(imgPicture);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/ImageViewHolder.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PictureData;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
public class ImageViewHolder extends BaseViewHolder<PictureData> {
ImageView imgPicture;
public ImageViewHolder(ViewGroup parent) {
super(new ImageView(parent.getContext()));
imgPicture = (ImageView) itemView;
imgPicture.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT));
imgPicture.setScaleType(ImageView.ScaleType.CENTER_CROP);
}
@Override
public void setData(PictureData data) {
ViewGroup.LayoutParams params = imgPicture.getLayoutParams();
//计算View的高度
int height = 300;
params.height = height;
imgPicture.setLayoutParams(params);
imgPicture.setImageResource(data.getImage());
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/SevenStaggeredActivity.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.graphics.Color;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.StaggeredGridLayoutManager;
import android.view.View;
import android.view.ViewGroup;
import com.yc.cn.ycbannerlib.banner.BannerView;
import com.yc.cn.ycbannerlib.banner.hintview.ColorPointHintView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.header.BannerAdapter;
import org.yczbj.ycrefreshviewlib.inter.InterItemView;
import org.yczbj.ycrefreshviewlib.inter.OnMoreListener;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
public class SevenStaggeredActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private ImageStageredAdapter adapter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
adapter = new ImageStageredAdapter(this);
recyclerView.setAdapter(adapter);
StaggeredGridLayoutManager staggeredGridLayoutManager =
new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
recyclerView.setLayoutManager(staggeredGridLayoutManager);
SpaceViewItemLine itemDecoration = new SpaceViewItemLine(20);
recyclerView.addItemDecoration(itemDecoration);
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
BannerView header = new BannerView(SevenStaggeredActivity.this);
header.setHintView(new ColorPointHintView(SevenStaggeredActivity.this, Color.YELLOW,Color.GRAY));
header.setHintPadding(0, 0, 0, (int) AppUtils.convertDpToPixel(8, SevenStaggeredActivity.this));
header.setPlayDelay(2000);
header.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) AppUtils.convertDpToPixel(200, SevenStaggeredActivity.this)));
header.setAdapter(new BannerAdapter(SevenStaggeredActivity.this));
return header;
}
@Override
public void onBindView(View headerView) {
}
});
adapter.setMore(R.layout.view_more, new OnMoreListener() {
@Override
public void onMoreShow() {
addData();
}
@Override
public void onMoreClick() {
}
});
adapter.setNoMore(R.layout.view_nomore);
recyclerView.setRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
adapter.addAll(DataProvider.getPictures());
}
},1000);
}
});
addData();
}
private void addData(){
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getPictures());
}
},300);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/SevenStaggeredGridActivity.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.graphics.Color;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import com.yc.cn.ycbannerlib.banner.BannerView;
import com.yc.cn.ycbannerlib.banner.hintview.ColorPointHintView;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.header.BannerAdapter;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.inter.InterItemView;
import org.yczbj.ycrefreshviewlib.inter.OnMoreListener;
import org.yczbj.ycrefreshviewlib.item.SpaceViewItemLine;
public class SevenStaggeredGridActivity extends AppCompatActivity {
private YCRefreshView recyclerView;
private ImageAdapter adapter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_refresh_view);
recyclerView = findViewById(R.id.recyclerView);
adapter = new ImageAdapter(this);
recyclerView.setAdapter(adapter);
GridLayoutManager gridLayoutManager = new GridLayoutManager(this,3);
gridLayoutManager.setSpanSizeLookup(adapter.obtainGridSpanSizeLookUp(3));
recyclerView.setLayoutManager(gridLayoutManager);
SpaceViewItemLine itemDecoration = new SpaceViewItemLine(20);
recyclerView.addItemDecoration(itemDecoration);
adapter.addHeader(new InterItemView() {
@Override
public View onCreateView(ViewGroup parent) {
BannerView header = new BannerView(SevenStaggeredGridActivity.this);
header.setHintView(new ColorPointHintView(SevenStaggeredGridActivity.this, Color.YELLOW,Color.GRAY));
header.setHintPadding(0, 0, 0, (int) AppUtils.convertDpToPixel(8, SevenStaggeredGridActivity.this));
header.setPlayDelay(2000);
header.setLayoutParams(new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) AppUtils.convertDpToPixel(200, SevenStaggeredGridActivity.this)));
header.setAdapter(new BannerAdapter(SevenStaggeredGridActivity.this));
return header;
}
@Override
public void onBindView(View headerView) {
}
});
adapter.setMore(R.layout.view_more, new OnMoreListener() {
@Override
public void onMoreShow() {
addData();
}
@Override
public void onMoreClick() {
}
});
adapter.setNoMore(R.layout.view_nomore);
recyclerView.setRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
adapter.addAll(DataProvider.getPictures());
}
},1000);
}
});
addData();
}
private void addData(){
recyclerView.postDelayed(new Runnable() {
@Override
public void run() {
adapter.addAll(DataProvider.getPictures());
}
},300);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/StageredLoadMoreActivity.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.StaggeredGridLayoutManager;
import android.view.View;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.utils.RefreshLogUtils;
import java.util.List;
/**
* @author yc
*/
public class StageredLoadMoreActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private StageredLoadMoreAdapter adapter;
private Handler handler = new Handler();
private int lastVisibleItem = 0;
private final int PAGE_COUNT = 10;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initData();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
final StaggeredGridLayoutManager staggeredGridLayoutManager =
new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
recyclerView.setLayoutManager(staggeredGridLayoutManager);
/*recyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
@Override
public void getItemOffsets(@NonNull Rect outRect, @NonNull View view,
@NonNull RecyclerView parent, @NonNull RecyclerView.State state) {
super.getItemOffsets(outRect, view, parent, state);
int position = parent.getChildAdapterPosition(view);
int spanCount = 0;
int spanIndex = 0;
RecyclerView.Adapter adapter = parent.getAdapter();
RecyclerView.LayoutManager layoutManager = parent.getLayoutManager();
if (adapter==null || layoutManager==null){
return;
}
if (layoutManager instanceof StaggeredGridLayoutManager){
spanCount = ((StaggeredGridLayoutManager) layoutManager).getSpanCount();
spanIndex = ((StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams()).getSpanIndex();
}
//普通Item的尺寸
//TODO 会出现错位的问题
int itemCount = adapter.getItemCount();
int childCount = layoutManager.getChildCount();
RefreshLogUtils.d("SpaceViewItemLine--count--"+itemCount + "-----"+childCount+"---索引--"+position+"---"+spanIndex);
if (position<itemCount && spanCount==2) {
if (childCount % 2 == 0){
//这个是右边item
outRect.left = 5;
outRect.right = 20;
} else {
//这个是左边item
outRect.left = 20;
outRect.right = 5;
}
if (childCount==1 || childCount==2){
outRect.top = 0;
} else {
outRect.top = 20;
}
RefreshLogUtils.d("SpaceViewItemLine--间距--"+childCount+"----"+outRect.left+"-----"+outRect.right);
}
}
});*/
recyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
@Override
public void getItemOffsets(@NonNull Rect outRect, @NonNull View view,
@NonNull RecyclerView parent, @NonNull RecyclerView.State state) {
super.getItemOffsets(outRect, view, parent, state);
int position = parent.getChildAdapterPosition(view);
int spanCount = 0;
int spanIndex = 0;
RecyclerView.Adapter adapter = parent.getAdapter();
RecyclerView.LayoutManager layoutManager = parent.getLayoutManager();
if (adapter==null || layoutManager==null){
return;
}
if (layoutManager instanceof StaggeredGridLayoutManager){
spanCount = ((StaggeredGridLayoutManager) layoutManager).getSpanCount();
spanIndex = ((StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams()).getSpanIndex();
}
//普通Item的尺寸
//TODO 会出现错位的问题
int itemCount = adapter.getItemCount();
int childCount = layoutManager.getChildCount();
RefreshLogUtils.d("SpaceViewItemLine--count--"+itemCount + "-----"+childCount+"---索引--"+position+"---"+spanIndex);
if (position<itemCount && spanCount==2) {
if (spanIndex != GridLayoutManager.LayoutParams.INVALID_SPAN_ID) {
//getSpanIndex方法不管控件高度如何，始终都是左右左右返回index
if (spanIndex % 2 == 0) {
//这个是左边item
outRect.left = 20;
outRect.right = 5;
} else {
//这个是右边item
outRect.left = 5;
outRect.right = 20;
}
if (childCount==1 || childCount==2){
outRect.top = 0;
} else {
outRect.top = 20;
}
}
//outRect.top = space;
RefreshLogUtils.d("SpaceViewItemLine--间距--"+spanIndex+"----"+outRect.left+"-----"+outRect.right);
}
}
});
adapter = new StageredLoadMoreAdapter(this,false);
recyclerView.setAdapter(adapter);
// 实现上拉加载重要步骤，设置滑动监听器，RecyclerView自带的ScrollListener
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
super.onScrollStateChanged(recyclerView, newState);
// 在newState为滑到底部时
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
// 如果没有隐藏footView，那么最后一个条目的位置就比我们的getItemCount少1，自己可以算一下
if (!adapter.isFadeTips() && lastVisibleItem + 1 == adapter.getItemCount()) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
updateRecyclerView(adapter.getRealLastPosition(),
adapter.getRealLastPosition() + PAGE_COUNT);
}
}, 2500);
}
// 如果隐藏了提示条，我们又上拉加载时，那么最后一个条目就要比getItemCount要少2
if (adapter.isFadeTips() && lastVisibleItem + 2 == adapter.getItemCount()) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
updateRecyclerView(adapter.getRealLastPosition(),
adapter.getRealLastPosition() + PAGE_COUNT);
}
}, 2500);
}
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
// 在滑动完成后，拿到最后一个可见的item的位置
int positions[] = staggeredGridLayoutManager.findLastVisibleItemPositions(null);
for(int pos : positions){
if(pos > lastVisibleItem){
lastVisibleItem = pos;//得到最后一个可见的item的position
}
}
}
});
}
private void initData() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.setData(DataProvider.getPersonList(16));
}
}, 50);
}
private void updateRecyclerView(int fromIndex, int toIndex) {
List<PersonData> newDatas = DataProvider.getPersonList(0);
if (newDatas.size() > 0) {
adapter.updateList(newDatas, true);
} else {
adapter.updateList(null, false);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/staggered/StageredLoadMoreAdapter.java | Java | package org.yczbj.ycrefreshview.staggered;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.StaggeredGridLayoutManager;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import java.util.ArrayList;
import java.util.List;
public class StageredLoadMoreAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private Context mContext;
private OnItemClickListener listener;
/**
* 第一种ViewType，正常的item
*/
private int normalType = 0;
/**
* 第二种ViewType，底部的提示View
*/
private int footType = 1;
/**
* 变量，是否有更多数据
*/
private boolean hasMore;
/**
* 变量，是否隐藏了底部的提示
*/
private boolean fadeTips = false;
/**
* 获取主线程的Handler
*/
private Handler mHandler = new Handler(Looper.getMainLooper());
public StageredLoadMoreAdapter(Context context, boolean hasMore) {
this.mContext = context;
this.hasMore = hasMore;
}
private List<PersonData> data = new ArrayList<>();
public void setData(List<PersonData> data) {
this.data = data;
notifyDataSetChanged();
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
/**
* 暴露接口，改变fadeTips的方法
*/
public boolean isFadeTips() {
return fadeTips;
}
/**
* 暴露接口，更新数据源，并修改hasMore的值，如果有增加数据，hasMore为true，否则为false
*/
public void updateList(List<PersonData> newDatas, boolean hasMore) {
int size = data.size();
// 在原有的数据之上增加新数据
if (newDatas != null) {
data.addAll(newDatas);
this.hasMore = hasMore;
notifyItemRangeInserted(size,newDatas.size());
}
}
/**
* 自定义方法，获取列表中数据源的最后一个位置，比getItemCount少1，因为不计上footView
*/
public int getRealLastPosition() {
return data.size();
}
@Override
public void onViewAttachedToWindow(RecyclerView.ViewHolder holder) {
super.onViewAttachedToWindow(holder);
ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
if (layoutParams != null && layoutParams instanceof StaggeredGridLayoutManager.LayoutParams) {
StaggeredGridLayoutManager.LayoutParams params = (StaggeredGridLayoutManager.LayoutParams) layoutParams;
int position = holder.getLayoutPosition();
//如果是上拉加载更多类型，则设置setFullSpan为true，那么它就会占一行
if (getItemViewType(position) == footType) {
params.setFullSpan(true);
}
}
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
// 根据返回的ViewType，绑定不同的布局文件，这里只有两种
if (viewType == normalType) {
return new MyViewHolder(LayoutInflater.from(mContext)
.inflate(R.layout.item_image, parent,false));
} else {
//这个是上拉加载更多的view
return new FootHolder(LayoutInflater.from(mContext)
.inflate(R.layout.view_more, parent,false));
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
if (holder instanceof MyViewHolder){
PersonData person = data.get(position);
setBindViewHolder((MyViewHolder)holder,person,position);
}else {
setFootBindViewHolder((FootHolder)holder ,position);
}
}
/**
* 获取条目数量，之所以要加1是因为增加了一条footView
*/
@Override
public int getItemCount() {
return data == null ? 0 : data.size()+1;
}
/**
* 根据条目位置返回ViewType，以供onCreateViewHolder方法内获取不同的Holder
*/
@Override
public int getItemViewType(int position) {
if (position == getItemCount() - 1) {
return footType;
} else {
return normalType;
}
}
class MyViewHolder extends RecyclerView.ViewHolder {
private ImageView iv_news_image;
MyViewHolder(final View itemView) {
super(itemView);
iv_news_image = itemView.findViewById(R.id.iv_news_image);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (listener != null) {
listener.onItemClick(getAdapterPosition());
}
}
});
}
}
class FootHolder extends RecyclerView.ViewHolder {
private TextView tv_more;
FootHolder(View itemView) {
super(itemView);
tv_more = itemView.findViewById(R.id.tv_more);
}
}
private void setBindViewHolder(MyViewHolder holder, PersonData person, int position) {
ViewGroup.LayoutParams params = holder.iv_news_image.getLayoutParams();
int setHeight = position%5;
//计算View的高度
int height = 300;
switch (setHeight){
case 0:
height = 500;
break;
case 1:
height = 750;
break;
case 2:
height = 880;
break;
case 3:
height = 360;
break;
case 4:
height = 660;
break;
default:
break;
}
params.height = height;
holder.iv_news_image.setLayoutParams(params);
Glide.with(holder.iv_news_image.getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(holder.iv_news_image);
}
private void setFootBindViewHolder(final FootHolder holder, int position) {
// 之所以要设置可见，是因为我在没有更多数据时会隐藏了这个footView
holder.tv_more.setVisibility(View.VISIBLE);
// 只有获取数据为空时，hasMore为false，所以当我们拉到底部时基本都会首先显示“正在加载更多...”
if (hasMore) {
// 不隐藏footView提示
fadeTips = false;
if (data.size() > 0) {
// 如果查询数据发现增加之后，就显示正在加载更多
holder.tv_more.setText("逗比，正在加载更多...");
}
} else {
if (data.size() > 0) {
// 如果查询数据发现并没有增加时，就显示没有更多数据了
holder.tv_more.setText("逗比，没有更多数据了");
// 然后通过延时加载模拟网络请求的时间，在500ms后执行
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
// 隐藏提示条
holder.tv_more.setVisibility(View.GONE);
// 将fadeTips设置true
fadeTips = true;
// hasMore设为true是为了让再次拉到底时，会先显示正在加载更多
hasMore = true;
}
}, 500);
}
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/AppBarLayoutBehavior.java | Java | package org.yczbj.ycrefreshview.sticky;
import android.content.Context;
import androidx.coordinatorlayout.widget.CoordinatorLayout;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.OverScroller;
import com.google.android.material.appbar.AppBarLayout;
import java.lang.reflect.Field;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/03/13
* desc : 自定义Behavior
* revise: 解决appbarLayout若干问题
* 1）快速滑动appbarLayout会出现回弹
* 2）快速滑动appbarLayout到折叠状态下，立马下滑，会出现抖动的问题
* 3）滑动appbarLayout，无法通过手指按下让其停止滑动
* </pre>
*/
public class AppBarLayoutBehavior extends AppBarLayout.Behavior {
private static final String TAG = "AppbarLayoutBehavior";
private static final int TYPE_FLING = 1;
/**
* 记录是否有fling
*/
private boolean isFlinging;
/**
* 记录是否
*/
private boolean shouldBlockNestedScroll;
public AppBarLayoutBehavior(Context context, AttributeSet attrs) {
super(context, attrs);
}
/**
* 是否拦截触摸事件
* @param parent CoordinatorLayout
* @param child AppBarLayout
* @param ev ev
* @return
*/
@Override
public boolean onInterceptTouchEvent(CoordinatorLayout parent, AppBarLayout child, MotionEvent ev) {
LogUtil.d(TAG, "onInterceptTouchEvent:" + child.getTotalScrollRange());
shouldBlockNestedScroll = isFlinging;
switch (ev.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
//手指触摸屏幕的时候停止fling事件
stopAppbarLayoutFling(child);
break;
default:
break;
}
return super.onInterceptTouchEvent(parent, child, ev);
}
/**
* 反射获取私有的flingRunnable 属性，考虑support 28以后变量名修改的问题
* @return Field
* @throws NoSuchFieldException
*/
private Field getFlingRunnableField() throws NoSuchFieldException {
Class<?> superclass = this.getClass().getSuperclass();
try {
// support design 27及一下版本
Class<?> headerBehaviorType = null;
if (superclass != null) {
String name = superclass.getName();
LogUtil.d("AppBarLayout.Behavior父类",name);
headerBehaviorType = superclass.getSuperclass();
}
if (headerBehaviorType != null) {
String name = headerBehaviorType.getName();
LogUtil.d("AppBarLayout.Behavior父类的父类1",name);
return headerBehaviorType.getDeclaredField("mFlingRunnable");
}else {
return null;
}
} catch (NoSuchFieldException e) {
e.printStackTrace();
// 可能是28及以上版本
Class<?> headerBehaviorType = superclass.getSuperclass().getSuperclass();
if (headerBehaviorType != null) {
String name = headerBehaviorType.getName();
LogUtil.d("AppBarLayout.Behavior父类的父类2",name);
return headerBehaviorType.getDeclaredField("flingRunnable");
} else {
return null;
}
}
}
/**
* 反射获取私有的scroller 属性，考虑support 28以后变量名修改的问题
* @return Field
* @throws NoSuchFieldException
*/
private Field getScrollerField() throws NoSuchFieldException {
Class<?> superclass = this.getClass().getSuperclass();
try {
// support design 27及一下版本
Class<?> headerBehaviorType = null;
if (superclass != null) {
headerBehaviorType = superclass.getSuperclass();
}
if (headerBehaviorType != null) {
return headerBehaviorType.getDeclaredField("mScroller");
}else {
return null;
}
} catch (NoSuchFieldException e) {
e.printStackTrace();
// 可能是28及以上版本
Class<?> headerBehaviorType = superclass.getSuperclass().getSuperclass();
if (headerBehaviorType != null) {
return headerBehaviorType.getDeclaredField("scroller");
}else {
return null;
}
}
}
/**
* 停止appbarLayout的fling事件
* @param appBarLayout
*/
private void stopAppbarLayoutFling(AppBarLayout appBarLayout) {
//通过反射拿到HeaderBehavior中的flingRunnable变量
try {
Field flingRunnableField = getFlingRunnableField();
Field scrollerField = getScrollerField();
if (flingRunnableField != null) {
flingRunnableField.setAccessible(true);
}
if (scrollerField != null) {
scrollerField.setAccessible(true);
}
Runnable flingRunnable = null;
if (flingRunnableField != null) {
flingRunnable = (Runnable) flingRunnableField.get(this);
}
OverScroller overScroller = null;
if (scrollerField != null) {
overScroller = (OverScroller) scrollerField.get(this);
}
//下面是关键点
if (flingRunnable != null) {
LogUtil.d(TAG, "存在flingRunnable");
appBarLayout.removeCallbacks(flingRunnable);
flingRunnableField.set(this, null);
}
if (overScroller != null && !overScroller.isFinished()) {
overScroller.abortAnimation();
}
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 嵌套滑动开始（ACTION_DOWN），确定Behavior是否要监听此次事件
*/
@Override
public boolean onStartNestedScroll(CoordinatorLayout parent, AppBarLayout child,
View directTargetChild, View target,
int nestedScrollAxes, int type) {
LogUtil.d(TAG, "onStartNestedScroll");
stopAppbarLayoutFling(child);
return super.onStartNestedScroll(parent, child, directTargetChild, target,
nestedScrollAxes, type);
}
/**
* 嵌套滑动进行中，要监听的子 View将要滑动，滑动事件即将被消费（但最终被谁消费，可以通过代码控制）
*/
@Override
public void onNestedPreScroll(CoordinatorLayout coordinatorLayout,
AppBarLayout child, View target,
int dx, int dy, int[] consumed, int type) {
LogUtil.d(TAG, "onNestedPreScroll:" + child.getTotalScrollRange()
+ " ,dx:" + dx + " ,dy:" + dy + " ,type:" + type);
//type返回1时，表示当前target处于非touch的滑动，
//该bug的引起是因为appbar在滑动时，CoordinatorLayout内的实现NestedScrollingChild2接口的滑动
//子类还未结束其自身的fling
//所以这里监听子类的非touch时的滑动，然后block掉滑动事件传递给AppBarLayout
if (type == TYPE_FLING) {
isFlinging = true;
}
if (!shouldBlockNestedScroll) {
super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
}
}
/**
* 嵌套滑动进行中，要监听的子 View的滑动事件已经被消费
*/
@Override
public void onNestedScroll(CoordinatorLayout coordinatorLayout, AppBarLayout child,
View target, int dxConsumed, int dyConsumed, int
dxUnconsumed, int dyUnconsumed, int type) {
LogUtil.d(TAG, "onNestedScroll: target:" + target.getClass() + " ,"
+ child.getTotalScrollRange() + " ,dxConsumed:"
+ dxConsumed + " ,dyConsumed:" + dyConsumed + " " + ",type:" + type);
if (!shouldBlockNestedScroll) {
super.onNestedScroll(coordinatorLayout, child, target, dxConsumed,
dyConsumed, dxUnconsumed, dyUnconsumed, type);
}
}
/**
* 嵌套滑动结束（ACTION_UP或ACTION_CANCEL）
*/
@Override
public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, AppBarLayout abl,
View target, int type) {
LogUtil.d(TAG, "onStopNestedScroll");
super.onStopNestedScroll(coordinatorLayout, abl, target, type);
isFlinging = false;
shouldBlockNestedScroll = false;
}
private static class LogUtil{
static void d(String tag, String string){
Log.d(tag,string);
}
}
} | yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/SixStickyHeaderActivity.java | Java | package org.yczbj.ycrefreshview.sticky;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonViewHolder;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import org.yczbj.ycrefreshviewlib.item.StickyHeaderItemLine;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import java.util.ArrayList;
public class SixStickyHeaderActivity extends AppCompatActivity implements OnLoadMoreListener, SwipeRefreshLayout.OnRefreshListener {
private YCRefreshView recyclerView;
private FloatingActionButton top;
private RecyclerArrayAdapter<PersonData> adapter;
private Handler handler = new Handler();
private boolean hasNetWork = true;
private ArrayList<Integer> list;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recyclerview);
top = findViewById(R.id.top);
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9),
LibUtils.dip2px(this, 1f),
LibUtils.dip2px(this, 72), 0);
itemDecoration.setDrawLastItem(false);
recyclerView.addItemDecoration(itemDecoration);
recyclerView.setAdapterWithProgress(adapter = new RecyclerArrayAdapter<PersonData>(this) {
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
});
adapter.setMore(R.layout.view_more, this);
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.resumeMore();
}
@Override
public void onNoMoreClick() {
adapter.resumeMore();
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.resumeMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
// StickyHeader
StickyHeaderItemLine decoration = new StickyHeaderItemLine(
new StickyHeaderAdapter(this));
decoration.setIncludeHeader(true);
recyclerView.addItemDecoration(decoration);
top.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
recyclerView.scrollToPosition(0);
}
});
recyclerView.setRefreshListener(this);
onRefresh();
}
//第四页会返回空,意为数据加载结束
@Override
public void onLoadMore() {
Log.i("EasyRecyclerView", "onLoadMore");
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
}
}, 2000);
}
@Override
public void onRefresh() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
}
}, 2000);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
MenuItem item = menu.findItem(R.id.checkbox);
CheckBox box = (CheckBox) item.getActionView();
box.setChecked(true);
box.setText("网络");
box.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
hasNetWork = isChecked;
}
});
return true;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/SixStickyNormalActivity.java | Java | package org.yczbj.ycrefreshview.sticky;
import android.os.Bundle;
import android.os.Handler;
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonViewHolder;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import org.yczbj.ycrefreshviewlib.view.YCRefreshView;
import java.util.ArrayList;
public class SixStickyNormalActivity extends AppCompatActivity implements OnLoadMoreListener, SwipeRefreshLayout.OnRefreshListener {
private YCRefreshView recyclerView;
private FloatingActionButton top;
private RecyclerArrayAdapter<PersonData> adapter;
private Handler handler = new Handler();
private int page = 0;
private boolean hasNetWork = true;
private ArrayList<Integer> list;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recyclerview);
top = findViewById(R.id.top);
recyclerView = findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9),
LibUtils.dip2px(this, 1f),
LibUtils.dip2px(this, 72), 0);
itemDecoration.setDrawLastItem(false);
recyclerView.addItemDecoration(itemDecoration);
recyclerView.setAdapterWithProgress(adapter = new RecyclerArrayAdapter<PersonData>(this) {
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
// StickyHeader
StickyNormalItemLine decoration = new StickyNormalItemLine(
new StickyNormalAdapter(this));
recyclerView.addItemDecoration(decoration);
top.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
recyclerView.scrollToPosition(0);
}
});
recyclerView.setRefreshListener(this);
onRefresh();
}
//第四页会返回空,意为数据加载结束
@Override
public void onLoadMore() {
Log.i("EasyRecyclerView", "onLoadMore");
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(page));
page++;
}
}, 2000);
}
@Override
public void onRefresh() {
page = 0;
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(page));
page = 1;
}
}, 2000);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_main, menu);
MenuItem item = menu.findItem(R.id.checkbox);
CheckBox box = (CheckBox) item.getActionView();
box.setChecked(true);
box.setText("网络");
box.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
hasNetWork = isChecked;
}
});
return true;
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/SixStickyViewActivity.java | Java | package org.yczbj.ycrefreshview.sticky;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.coordinatorlayout.widget.CoordinatorLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.widget.LinearLayout;
import com.google.android.material.appbar.AppBarLayout;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.inter.OnErrorListener;
import org.yczbj.ycrefreshviewlib.inter.OnItemLongClickListener;
import org.yczbj.ycrefreshviewlib.inter.OnLoadMoreListener;
import org.yczbj.ycrefreshviewlib.inter.OnNoMoreListener;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.utils.RefreshLogUtils;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
public class SixStickyViewActivity extends AppCompatActivity {
private CoordinatorLayout coordinator;
private AppBarLayout appbar;
private RecyclerView recyclerView;
private RecyclerArrayAdapter<PersonData> adapter;
private boolean hasNetWork = true;
private Handler handler = new Handler();
@Retention(RetentionPolicy.SOURCE)
public @interface STATES{
int EXPANDED = 3;
int COLLAPSED = 2;
int INTERMEDIATE = 1;
}
private int state;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sticky_header);
coordinator = findViewById(R.id.coordinator);
appbar = findViewById(R.id.appbar);
recyclerView = findViewById(R.id.recyclerView);
initCoordinator();
initRecyclerView();
initData();
}
private void initCoordinator() {
appbar.addOnOffsetChangedListener(listener);
}
private AppBarLayout.OnOffsetChangedListener listener = new AppBarLayout.OnOffsetChangedListener() {
@Override
public void onOffsetChanged(AppBarLayout appBarLayout, int verticalOffset) {
int totalScrollRange = appBarLayout.getTotalScrollRange();
if (verticalOffset == 0) {
if (state != STATES.EXPANDED) {
//修改状态标记为展开
state = STATES.EXPANDED;
RefreshLogUtils.e("OnOffsetChangedListener"+ "修改状态标记为展开");
}
} else if (Math.abs(verticalOffset) >= totalScrollRange) {
if (state != STATES.COLLAPSED) {
//修改状态标记为折叠
state = STATES.COLLAPSED;
RefreshLogUtils.e("OnOffsetChangedListener"+ "修改状态标记为折叠");
}
} else {
if (state != STATES.INTERMEDIATE) {
//修改状态标记为中间
state = STATES.INTERMEDIATE;
//代码设置是否拦截事件
RefreshLogUtils.e("OnOffsetChangedListener"+ "修改状态标记为中间");
}
}
}
};
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int)AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
adapter = new PersonAdapter(this);
recyclerView.setAdapter(adapter);
adapter.setMore(R.layout.view_more, new OnLoadMoreListener() {
@Override
public void onLoadMore() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
}
}, 2000);
}
});
adapter.setNoMore(R.layout.view_nomore, new OnNoMoreListener() {
@Override
public void onNoMoreShow() {
adapter.pauseMore();
}
@Override
public void onNoMoreClick() {
}
});
adapter.setOnItemLongClickListener(new OnItemLongClickListener() {
@Override
public boolean onItemLongClick(int position) {
adapter.remove(position);
return true;
}
});
adapter.setError(R.layout.view_error, new OnErrorListener() {
@Override
public void onErrorShow() {
adapter.resumeMore();
}
@Override
public void onErrorClick() {
adapter.resumeMore();
}
});
}
private void initData() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.clear();
//刷新
if (!hasNetWork) {
adapter.pauseMore();
return;
}
adapter.addAll(DataProvider.getPersonList(10));
}
}, 50);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/StickyHeaderAdapter.java | Java |
package org.yczbj.ycrefreshview.sticky;
import android.content.Context;
import androidx.recyclerview.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshviewlib.item.StickyHeaderItemLine;
/**
* @author yc
*/
public class StickyHeaderAdapter implements
StickyHeaderItemLine.IStickyHeaderAdapter<StickyHeaderAdapter.HeaderHolder> {
private LayoutInflater mInflater;
public StickyHeaderAdapter(Context context) {
mInflater = LayoutInflater.from(context);
}
@Override
public long getHeaderId(int position) {
Log.d("getHeaderId---",position+"");
return position / 3;
}
@Override
public HeaderHolder onCreateHeaderViewHolder(ViewGroup parent) {
final View view = mInflater.inflate(R.layout.header_item, parent, false);
return new HeaderHolder(view);
}
@Override
public void onBindHeaderViewHolder(HeaderHolder viewholder, int position) {
viewholder.header.setText("第"+getHeaderId(position)+"组");
Log.d("getHeaderId---","第"+getHeaderId(position)+"组");
}
class HeaderHolder extends RecyclerView.ViewHolder {
TextView header;
HeaderHolder(View itemView) {
super(itemView);
header = (TextView) itemView;
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/StickyNormalAdapter.java | Java |
package org.yczbj.ycrefreshview.sticky;
import android.content.Context;
import androidx.recyclerview.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import org.yczbj.ycrefreshview.R;
/**
* @author yc
*/
public class StickyNormalAdapter implements
StickyNormalItemLine.IStickyHeaderAdapter<StickyNormalAdapter.HeaderHolder> {
private LayoutInflater mInflater;
public StickyNormalAdapter(Context context) {
mInflater = LayoutInflater.from(context);
}
@Override
public long getHeaderId(int position) {
Log.d("getHeaderId---",position+"");
return position / 3;
}
@Override
public HeaderHolder onCreateHeaderViewHolder(ViewGroup parent) {
final View view = mInflater.inflate(R.layout.header_item, parent, false);
return new HeaderHolder(view);
}
@Override
public void onBindHeaderViewHolder(HeaderHolder viewholder, int position) {
viewholder.header.setText("第"+getHeaderId(position)+"组");
Log.d("getHeaderId---","第"+getHeaderId(position)+"组");
}
class HeaderHolder extends RecyclerView.ViewHolder {
TextView header;
HeaderHolder(View itemView) {
super(itemView);
header = (TextView) itemView;
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/sticky/StickyNormalItemLine.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 org.yczbj.ycrefreshview.sticky;
import android.annotation.SuppressLint;
import android.graphics.Canvas;
import android.graphics.Rect;
import androidx.annotation.NonNull;
import androidx.core.view.ViewCompat;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import org.yczbj.ycrefreshviewlib.utils.RefreshLogUtils;
import java.util.HashMap;
import java.util.Map;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2017/5/2
* desc : list条目的分割线【粘贴头部】
* revise:
* </pre>
*/
public class StickyNormalItemLine extends RecyclerView.ItemDecoration {
private static final long NO_HEADER_ID = -1L;
private Map<Long, RecyclerView.ViewHolder> mHeaderCache;
private IStickyHeaderAdapter mAdapter;
private boolean mRenderInline;
public interface IStickyHeaderAdapter<T extends RecyclerView.ViewHolder> {
long getHeaderId(int position);
T onCreateHeaderViewHolder(ViewGroup parent);
void onBindHeaderViewHolder(T viewholder, int position);
}
public StickyNormalItemLine(IStickyHeaderAdapter adapter) {
this(adapter, false);
}
@SuppressLint("UseSparseArrays")
public StickyNormalItemLine(IStickyHeaderAdapter adapter, boolean renderInline) {
mAdapter = adapter;
mHeaderCache = new HashMap<>();
//mHeaderCache = new LongSparseArray<>();
mRenderInline = renderInline;
}
/**
* 调用的是getItemOffsets会被多次调用，在layoutManager每次测量可摆放的view的时候回调用一次，
* 在当前状态下需要摆放多少个view这个方法就会回调多少次。
* @param outRect 核心参数，这个rect相当于item摆放的时候设置的margin，
* rect的left相当于item的marginLeft，
* rect的right相当于item的marginRight
* @param view 当前绘制的view，可以用来获取它在adapter中的位置
* @param parent recyclerView
* @param state 状态，用的很少
*/
@Override
public void getItemOffsets(@NonNull Rect outRect, @NonNull View view,
@NonNull RecyclerView parent, @NonNull RecyclerView.State state) {
int position = parent.getChildAdapterPosition(view);
int headerHeight = 0;
//判断是否有header
boolean hasHeader = hasHeader(position);
boolean showHeaderAboveItem = showHeaderAboveItem(position);
if (position != RecyclerView.NO_POSITION && hasHeader && showHeaderAboveItem) {
View header = getHeader(parent, position).itemView;
headerHeight = getHeaderHeightForLayout(header);
}
RefreshLogUtils.d("StickyNormalItemLine------headerHeight---"+headerHeight);
outRect.set(0, headerHeight, 0, 0);
}
private boolean showHeaderAboveItem(int itemAdapterPosition) {
if (itemAdapterPosition == 0) {
return true;
}
return mAdapter.getHeaderId(itemAdapterPosition - 1)
!= mAdapter.getHeaderId(itemAdapterPosition);
}
public void clearHeaderCache() {
mHeaderCache.clear();
}
public View findHeaderViewUnder(float x, float y) {
for (RecyclerView.ViewHolder holder : mHeaderCache.values()) {
final View child = holder.itemView;
final float translationX = ViewCompat.getTranslationX(child);
final float translationY = ViewCompat.getTranslationY(child);
if (x >= child.getLeft() + translationX && x <= child.getRight() + translationX &&
y >= child.getTop() + translationY && y <= child.getBottom() + translationY) {
return child;
}
}
return null;
}
/**
* 判断是否有header
* @param position 索引
* @return
*/
private boolean hasHeader(int position) {
return mAdapter.getHeaderId(position) != NO_HEADER_ID;
}
private RecyclerView.ViewHolder getHeader(RecyclerView parent, int position) {
final long key = mAdapter.getHeaderId(position);
if (mHeaderCache.containsKey(key)) {
return mHeaderCache.get(key);
} else {
final RecyclerView.ViewHolder holder = mAdapter.onCreateHeaderViewHolder(parent);
final View header = holder.itemView;
//noinspection unchecked
mAdapter.onBindHeaderViewHolder(holder, position);
int widthSpec = View.MeasureSpec.makeMeasureSpec(parent.getMeasuredWidth(),
View.MeasureSpec.EXACTLY);
int heightSpec = View.MeasureSpec.makeMeasureSpec(parent.getMeasuredHeight(),
View.MeasureSpec.UNSPECIFIED);
int childWidth = ViewGroup.getChildMeasureSpec(widthSpec,
parent.getPaddingLeft() + parent.getPaddingRight(),
header.getLayoutParams().width);
int childHeight = ViewGroup.getChildMeasureSpec(heightSpec,
parent.getPaddingTop() + parent.getPaddingBottom(),
header.getLayoutParams().height);
//测量
header.measure(childWidth, childHeight);
//布局
header.layout(0, 0, header.getMeasuredWidth(), header.getMeasuredHeight());
mHeaderCache.put(key, holder);
return holder;
}
}
/**
* 绘制分割线
* ItemDecoration的onDrawOver方法是在RecyclerView的draw方法中调用的
* 同样传入的是RecyclerView的canvas，这时候onLayout已经调用，所以此时绘制的内容会覆盖item。
* @param canvas canvas用来绘制的画板
* @param parent recyclerView
* @param state 状态，用的很少
*/
@Override
public void onDrawOver(@NonNull Canvas canvas, @NonNull RecyclerView parent,
@NonNull RecyclerView.State state) {
if (parent.getAdapter() == null){
return;
}
final int count = parent.getChildCount();
long previousHeaderId = -1;
for (int layoutPos = 0; layoutPos < count; layoutPos++) {
final View child = parent.getChildAt(layoutPos);
int adapterPos = parent.getChildAdapterPosition(child);
if (adapterPos != RecyclerView.NO_POSITION && hasHeader(adapterPos)) {
long headerId = mAdapter.getHeaderId(adapterPos);
if (headerId != previousHeaderId) {
previousHeaderId = headerId;
View header = getHeader(parent, adapterPos).itemView;
canvas.save();
final int left = child.getLeft();
final int top = getHeaderTop(parent, child, header, adapterPos, layoutPos);
canvas.translate(left, top);
header.setTranslationX(left);
header.setTranslationY(top);
header.draw(canvas);
canvas.restore();
}
}
}
}
private int getHeaderTop(RecyclerView parent, View child, View header,
int adapterPos, int layoutPos) {
int headerHeight = getHeaderHeightForLayout(header);
int top = ((int) child.getY()) - headerHeight;
if (layoutPos == 0) {
final int count = parent.getChildCount();
final long currentId = mAdapter.getHeaderId(adapterPos);
// find next view with header and compute the offscreen push if needed
for (int i = 1; i < count; i++) {
int adapterPosHere = parent.getChildAdapterPosition(parent.getChildAt(i));
if (adapterPosHere != RecyclerView.NO_POSITION) {
long nextId = mAdapter.getHeaderId(adapterPosHere);
if (nextId != currentId) {
final View next = parent.getChildAt(i);
final int offset = ((int) next.getY()) - (headerHeight +
getHeader(parent, adapterPosHere).itemView.getHeight());
if (offset < 0) {
return offset;
} else {
break;
}
}
}
}
top = Math.max(0, top);
}
return top;
}
private int getHeaderHeightForLayout(View header) {
return mRenderInline ? 0 : header.getHeight();
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/tag/TagRecyclerViewActivity.java | Java | package org.yczbj.ycrefreshview.tag;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Paint;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.ViewGroup;
import android.widget.TextView;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.app.SysUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshviewlib.adapter.RecyclerArrayAdapter;
import org.yczbj.ycrefreshviewlib.holder.BaseViewHolder;
/**
* @author yc
*/
public class TagRecyclerViewActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
}
private void initRecyclerView() {
RecyclerView recyclerView = findViewById(R.id.recyclerView);
recyclerView.setHasFixedSize(true);
//画笔用来计算文字的宽度
final Paint mSearchHistoryPaint = new Paint();
mSearchHistoryPaint.setTextSize(SysUtils.Dp2Px(this,12));
final int width = SysUtils.getScreenWidth(this);
final int mPaddingSize = SysUtils.Dp2Px(this,40);
GridLayoutManager gridLayoutManager = new GridLayoutManager(this, width);
gridLayoutManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
@Override
public int getSpanSize(int position) {
//就是这里 需要测量文字的宽度，加上左右内边距
int textWidth = (int) mSearchHistoryPaint.measureText(DataProvider.getTag().get(position))
+ mPaddingSize;
//如果文字的宽度超过屏幕的宽度，那么我们就设置为屏幕宽度
return textWidth > width ? width : textWidth;
}
});
recyclerView.setLayoutManager(gridLayoutManager);
PersonAdapter adapter = new PersonAdapter(this);
recyclerView.setAdapter(adapter);
adapter.addAll(DataProvider.getTag());
}
public class PersonAdapter extends RecyclerArrayAdapter<String> {
PersonAdapter(Context context) {
super(context);
}
@Override
public BaseViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) {
return new PersonViewHolder(parent);
}
public class PersonViewHolder extends BaseViewHolder<String> {
private TextView tv;
PersonViewHolder(ViewGroup parent) {
super(parent, R.layout.item_tag);
tv = getView(R.id.tv);
}
@SuppressLint("SetTextI18n")
@Override
public void setData(final String string){
tv.setText(string);
}
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/touchmove/NightTouchMoveActivity.java | Java | package org.yczbj.ycrefreshview.touchmove;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.ItemTouchHelper;
import android.widget.LinearLayout;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.touch.ItemTouchHelpCallback;
import java.util.Collections;
import java.util.List;
/**
* Created by yc on 2018/2/9.
*/
public class NightTouchMoveActivity extends AppCompatActivity{
private RecyclerView recyclerView;
private PersonAdapter adapter;
private List<PersonData> personList;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initCallBack();
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int) AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
recyclerView.setAdapter(adapter = new PersonAdapter(this));
personList = DataProvider.getPersonList(0);
adapter.addAll(personList);
adapter.notifyDataSetChanged();
}
private void initCallBack() {
ItemTouchHelpCallback callback = new ItemTouchHelpCallback(
new ItemTouchHelpCallback.OnItemTouchCallbackListener() {
@Override
public void onSwiped(int adapterPosition) {
// 滑动删除的时候，从数据库、数据源移除，并刷新UI
if (personList != null) {
//adapter.remove(adapterPosition);
//1、删除数据
personList.remove(adapterPosition);
//2、刷新
adapter.notifyItemRemoved(adapterPosition);
}
}
@Override
public boolean onMove(int srcPosition, int targetPosition) {
if (personList != null) {
// 更换数据源中的数据Item的位置
Collections.swap(personList, srcPosition, targetPosition);
// 更新UI中的Item的位置，主要是给用户看到交互效果
adapter.notifyItemMoved(srcPosition, targetPosition);
return true;
}
return true;
}
});
callback.setDragEnable(true);
callback.setSwipeEnable(true);
callback.setColor(this.getResources().getColor(R.color.colorAccent));
//创建helper对象，callback监听recyclerView item 的各种状态
ItemTouchHelper itemTouchHelper = new ItemTouchHelper(callback);
//关联recyclerView，一个helper对象只能对应一个recyclerView
itemTouchHelper.attachToRecyclerView(recyclerView);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/touchmove/NightTouchMoveActivity2.java | Java | package org.yczbj.ycrefreshview.touchmove;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.ItemTouchHelper;
import android.widget.LinearLayout;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.AppUtils;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshview.refresh.PersonAdapter;
import org.yczbj.ycrefreshviewlib.item.RecycleViewItemLine;
import org.yczbj.ycrefreshviewlib.touch.ItemTouchHelpCallback;
import java.util.Collections;
import java.util.List;
/**
* Created by yc on 2018/2/9.
*/
public class NightTouchMoveActivity2 extends AppCompatActivity{
private RecyclerView recyclerView;
private PersonAdapter adapter;
private List<PersonData> personList;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initCallBack();
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
GridLayoutManager layoutManager = new GridLayoutManager(this,3);
recyclerView.setLayoutManager(layoutManager);
final RecycleViewItemLine line = new RecycleViewItemLine(this, LinearLayout.HORIZONTAL,
(int) AppUtils.convertDpToPixel(1,this),
this.getResources().getColor(R.color.color_f9f9f9));
recyclerView.addItemDecoration(line);
recyclerView.setAdapter(adapter = new PersonAdapter(this));
personList = DataProvider.getPersonList(0);
adapter.addAll(personList);
adapter.notifyDataSetChanged();
}
private void initCallBack() {
ItemTouchHelpCallback callback = new ItemTouchHelpCallback(
new ItemTouchHelpCallback.OnItemTouchCallbackListener() {
@Override
public void onSwiped(int adapterPosition) {
// 滑动删除的时候，从数据库、数据源移除，并刷新UI
if (personList != null) {
//adapter.remove(adapterPosition);
//1、删除数据
personList.remove(adapterPosition);
//2、刷新
adapter.notifyItemRemoved(adapterPosition);
}
}
@Override
public boolean onMove(int srcPosition, int targetPosition) {
if (personList != null) {
// 更换数据源中的数据Item的位置
Collections.swap(personList, srcPosition, targetPosition);
// 更新UI中的Item的位置，主要是给用户看到交互效果
adapter.notifyItemMoved(srcPosition, targetPosition);
return true;
}
return true;
}
});
callback.setDragEnable(true);
callback.setSwipeEnable(true);
// callback.setColor(this.getResources().getColor(R.color.colorAccent));
//创建helper对象，callback监听recyclerView item 的各种状态
ItemTouchHelper itemTouchHelper = new ItemTouchHelper(callback);
//关联recyclerView，一个helper对象只能对应一个recyclerView
itemTouchHelper.attachToRecyclerView(recyclerView);
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/type/TypeActivity.java | Java | package org.yczbj.ycrefreshview.type;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.ItemTouchHelper;
import android.view.View;
import com.yc.cn.ycbannerlib.LibUtils;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.DataProvider;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import org.yczbj.ycrefreshviewlib.item.DividerViewItemLine;
import org.yczbj.ycrefreshviewlib.touch.ItemTouchHelpCallback;
import java.util.Collections;
/**
* @author yc
*/
public class TypeActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private TypeAdapter adapter;
private Handler handler = new Handler();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_recyclerview);
initRecyclerView();
initData();
initCallBack();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (handler!=null){
handler.removeCallbacksAndMessages(null);
handler = null;
}
}
private void initRecyclerView() {
recyclerView = findViewById(R.id.recyclerView);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
DividerViewItemLine itemDecoration = new DividerViewItemLine(
this.getResources().getColor(R.color.color_f9f9f9)
, LibUtils.dip2px(this,1f),
LibUtils.dip2px(this,30),30);
RVItemDecoration itemDecoration1 = new RVItemDecoration(this);
recyclerView.addItemDecoration(itemDecoration1);
adapter = new TypeAdapter(this);
recyclerView.setAdapter(adapter);
adapter.setOnClickListener(new OnItemClickListener() {
@Override
public void onItemClick(int position) {
}
});
}
private void initData() {
handler.postDelayed(new Runnable() {
@Override
public void run() {
adapter.setData(DataProvider.getPersonList(0));
}
}, 50);
}
private void initCallBack() {
ItemTouchHelpCallback callback = new ItemTouchHelpCallback(
new ItemTouchHelpCallback.OnItemTouchCallbackListener() {
@Override
public void onSwiped(int adapterPosition) {
// 滑动删除的时候，从数据库、数据源移除，并刷新UI
if (adapter.getData() != null) {
//1、删除数据
adapter.getData().remove(adapterPosition);
//2、刷新
adapter.notifyItemRemoved(adapterPosition);
}
}
@Override
public boolean onMove(int srcPosition, int targetPosition) {
if (adapter.getData() != null) {
// 更换数据源中的数据Item的位置
Collections.swap(adapter.getData(), srcPosition, targetPosition);
// 更新UI中的Item的位置，主要是给用户看到交互效果
adapter.notifyItemMoved(srcPosition, targetPosition);
return true;
}
return true;
}
});
callback.setDragEnable(true);
callback.setSwipeEnable(true);
//创建helper对象，callback监听recyclerView item 的各种状态
ItemTouchHelper itemTouchHelper = new ItemTouchHelper(callback);
//关联recyclerView，一个helper对象只能对应一个recyclerView
itemTouchHelper.attachToRecyclerView(recyclerView);
}
private class RVItemDecoration extends RecyclerView.ItemDecoration {
private Drawable mDrawable;
private int marginLeft = 20;
private int lineSize = 10;
private Paint mPaint;
public RVItemDecoration(Context context) {
mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setColor(Color.RED);
mDrawable = new ColorDrawable(ContextCompat.getColor(getApplicationContext(),
android.R.color.holo_blue_light));
}
@Override
public void onDraw(@NonNull Canvas canvas, @NonNull RecyclerView parent,
RecyclerView.State state) {
canvas.save();
int childCount = parent.getChildCount();
for (int i = 0; i < childCount; i++) {
View child = parent.getChildAt(i);
int pos = parent.getChildAdapterPosition(child);
if (pos == 0) {
//画一半长度的线。上半部缺失。
mDrawable.setBounds(marginLeft, (child.getTop() + child.getBottom()) / 2,
marginLeft + lineSize, child.getBottom());
mDrawable.draw(canvas);
} else if (pos == parent.getAdapter().getItemCount() - 1) {
//画一半长度的线。下半部缺失。
mDrawable.setBounds(marginLeft, child.getTop(), marginLeft + lineSize,
(child.getTop() + child.getBottom()) / 2);
mDrawable.draw(canvas);
} else {
//画普通的线。
mDrawable.setBounds(marginLeft, child.getTop(),
marginLeft + lineSize, child.getBottom());
mDrawable.draw(canvas);
}
//后画覆盖在线上的圆球。
canvas.drawCircle(marginLeft + lineSize / 2, (child.getTop() +
child.getBottom()) / 2, (lineSize + marginLeft) / 2, mPaint);
}
canvas.restore();
}
@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
RecyclerView.State state) {
outRect.set((marginLeft + lineSize) * 2, 0, 0, 0);
}
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/org/yczbj/ycrefreshview/type/TypeAdapter.java | Java | package org.yczbj.ycrefreshview.type;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import org.yczbj.ycrefreshview.R;
import org.yczbj.ycrefreshview.data.PersonData;
import org.yczbj.ycrefreshviewlib.inter.OnItemClickListener;
import java.util.ArrayList;
import java.util.List;
public class TypeAdapter extends RecyclerView.Adapter<TypeAdapter.MyViewHolder> {
private Context mContext;
private OnItemClickListener listener;
public TypeAdapter(Context context) {
this.mContext = context;
}
private List<PersonData> data = new ArrayList<>();
public void setData(List<PersonData> data) {
this.data = data;
notifyDataSetChanged();
}
public List<PersonData> getData() {
return data;
}
public void setOnClickListener(OnItemClickListener listener) {
this.listener = listener;
}
@NonNull
@Override
public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(mContext).inflate(R.layout.item_news, parent, false);
return new MyViewHolder(view);
}
@Override
public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
PersonData person = data.get(position);
if (person.getName()==null || person.getName().length()==0){
holder.tv_content.setText("小杨逗比"+position);
}else {
holder.tv_title.setText(person.getName());
}
if (person.getSign()==null || person.getSign().length()==0){
holder.tv_content.setText("这个是内容"+position);
}else {
holder.tv_content.setText(person.getSign());
}
Glide.with(holder.iv_news_image.getContext())
.load(person.getImage())
.error(R.drawable.bg_small_tree_min)
.placeholder(R.drawable.bg_small_tree_min)
.into(holder.iv_news_image);
}
class MyViewHolder extends RecyclerView.ViewHolder {
private TextView tv_title;
private ImageView iv_news_image;
private TextView tv_content;
MyViewHolder(final View itemView) {
super(itemView);
tv_title = itemView.findViewById(R.id.tv_title);
iv_news_image = itemView.findViewById(R.id.iv_news_image);
tv_content = itemView.findViewById(R.id.tv_content);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (listener != null) {
listener.onItemClick(getAdapterPosition());
}
}
});
}
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
build.gradle | Gradle | // Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
google()
jcenter()
maven {
url 'https://maven.google.com/'
name 'Google'
}
maven { url 'https://jitpack.io' }
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
//jitpack
classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1'
}
}
allprojects {
repositories {
google()
jcenter()
maven {
url 'https://maven.google.com/'
name 'Google'
}
maven { url 'https://jitpack.io' }
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
settings.gradle | Gradle | include ':app', ':RefreshViewLib'
include ':SlideViewLib'
include ':PhotoCoverLib'
include ':ShopCatLib'
include ':SelectViewLib'
include ':EastAdapterLib'
| yangchong211/YCRefreshView | 455 | 自定义支持上拉加载更多，下拉刷新，可以自定义头部和底部，可以添加多个headerView，使用一个原生recyclerView就可以搞定复杂界面。支持自由切换状态【加载中，加载成功，加载失败，没网络等状态】的控件，可以自定义状态视图View。拓展功能【支持长按拖拽，侧滑删除】，轻量级，可以选择性添加 。持续更新…… | Java | yangchong211 | 杨充 | Tencent |
PagerLib/build.gradle | Gradle | apply plugin: 'com.android.library'
apply plugin: 'com.github.dcendents.android-maven'
android {
compileSdkVersion 29
defaultConfig {
minSdkVersion 17
targetSdkVersion 29
versionCode 4
versionName "1.0.4"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.recyclerview:recyclerview:1.0.0'
} | yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/pager/DirectionalViewPager.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 com.yc.pagerlib.pager;
import java.lang.reflect.Field;
import java.util.ArrayList;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import androidx.annotation.NonNull;
import androidx.core.os.ParcelableCompat;
import androidx.core.os.ParcelableCompatCreatorCallbacks;
import androidx.core.view.MotionEventCompat;
import androidx.core.view.VelocityTrackerCompat;
import androidx.core.view.ViewConfigurationCompat;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.animation.Interpolator;
import android.widget.Scroller;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2019/6/20
* desc : 参考JakeWharton大神的代码
* revise:
* </pre>
*/
public class DirectionalViewPager extends ViewPager implements ViewPager.OnPageChangeListener{
private static final String TAG = "DirectionalViewPager";
private static final boolean DEBUG = true;
private static final boolean USE_CACHE = false;
public static final int HORIZONTAL = 0;
public static final int VERTICAL = 1;
static class ItemInfo {
Object object;
int position;
boolean scrolling;
}
private final ArrayList<ItemInfo> mItems = new ArrayList<>();
private PagerAdapter mAdapter;
private int mCurItem;
private int mRestoredCurItem = -1;
private Parcelable mRestoredAdapterState = null;
private ClassLoader mRestoredClassLoader = null;
private Scroller mScroller;
private PagerObserver mObserver;
private int mChildWidthMeasureSpec;
private int mChildHeightMeasureSpec;
private boolean mInLayout;
private boolean mScrollingCacheEnabled;
private boolean mPopulatePending;
private boolean mScrolling;
private boolean mIsBeingDragged;
private boolean mIsUnableToDrag;
private int mTouchSlop;
private float mInitialMotion;
/**
* Position of the last motion event.
*/
private float mLastMotionX;
private float mLastMotionY;
private int mOrientation = HORIZONTAL;
/**
* ID of the active pointer. This is used to retain consistency during
* drags/flings if multiple pointers are used.
*/
private int mActivePointerId = INVALID_POINTER;
/**
* Sentinel value for no current active pointer.
* Used by {@link #mActivePointerId}.
*/
private static final int INVALID_POINTER = -1;
/**
* Determines speed during touch scrolling
*/
private VelocityTracker mVelocityTracker;
private int mMinimumVelocity;
private int mMaximumVelocity;
private OnPageChangeListener mOnPageChangeListener;
private int mScrollState = SCROLL_STATE_IDLE;
private long mRecentTouchTime;
public DirectionalViewPager(Context context) {
super(context);
initViewPager();
}
public DirectionalViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
initViewPager();
}
void initViewPager() {
setWillNotDraw(false);
mScroller = new Scroller(getContext());
final ViewConfiguration configuration = ViewConfiguration.get(getContext());
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
}
/**
* 设置viewPager滑动动画持续时间
* API>19
*/
@TargetApi(Build.VERSION_CODES.KITKAT)
public void setAnimationDuration(final int during){
try {
// viewPager平移动画事件
Field mField = ViewPager.class.getDeclaredField("mScroller");
mField.setAccessible(true);
// 动画效果与ViewPager的一致
Interpolator interpolator = new Interpolator() {
@Override
public float getInterpolation(float t) {
t -= 1.0f;
return t * t * t * t * t + 1.0f;
}
};
FixedSpeedScroller scroller = new FixedSpeedScroller(getContext(),
interpolator, mRecentTouchTime);
scroller.setDuration(during);
mField.set(this, scroller);
} catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
e.printStackTrace();
}
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
if (mAdapter != null) {
populate();
}
}
/**
* 在viewpager滑动过程中执行，并且会被调用很多次。
* 需要注意的是，position的值使用等于屏幕最左侧暴露出来的view的position，即使该view已经快看不见了。
* 第二个参数positionOffset：从左向右滑动时该值从1---0 变化，从右向左滑动时该值从0---1变化。
* 第三个参数positionOffsetPixels：这个参数是viewpager滑动偏移量的具体值
* 比如屏幕宽度值是1080px而viewpager的宽度等于屏幕宽度，则这个值就会在0-1080之间变化。
* @param i 索引
* @param v 判断滑动方向
* @param i1 滑动偏移量
*/
@Override
public void onPageScrolled(int i, float v, int i1) {
super.onPageScrolled(i, v, i1);
}
/**
* 这个方法会在viewpager快要成功切换的时候调用。怎么理解这句话呢
* 当我们滑动距离很小的时候，viewpager会自动回弹到当前页，也就是不进行页面切换，
* 此时该方法不会被调用，因为页面并没有被成功切换；当我们滑动距离很大的时候，
* viewpager会自动帮我们滑动到下一页，此时手指抬起，viewpager判断即将成功切换到下一页，
* 那么该方法就会被调用，并且position的值等于即将切换过去的页面的下标。
* @param i 索引
*/
@Override
public void onPageSelected(int i) {
}
/**
* 主要用来监测viewpager的滑动状态：
* 当我们手指按下时 state=1，
* 当我们手指抬起时 state=2，
* 当viewpager处于空闲状态时 state=0；
* 所以我们完全可以在state=0时 去加载或者处理我们的事情，因为这时候滑动已经结束。
* @param i 状态
*/
@Override
public void onPageScrollStateChanged(int i) {
}
private void setScrollState(int newState) {
if (mScrollState == newState) {
return;
}
mScrollState = newState;
if (mOnPageChangeListener != null) {
mOnPageChangeListener.onPageScrollStateChanged(newState);
}
}
@Override
public void setAdapter(PagerAdapter adapter) {
mAdapter = adapter;
if (mAdapter != null) {
if (mObserver == null) {
mObserver = new PagerObserver();
}
mAdapter.registerDataSetObserver(mObserver);
mPopulatePending = false;
if (mRestoredCurItem >= 0) {
mAdapter.restoreState(mRestoredAdapterState, mRestoredClassLoader);
setCurrentItemInternal(mRestoredCurItem, false, true);
mRestoredCurItem = -1;
mRestoredAdapterState = null;
mRestoredClassLoader = null;
} else {
populate();
}
}
}
@Override
public PagerAdapter getAdapter() {
return mAdapter;
}
/**
* 这个方法是设置滚动的
* @param item 索引
*/
@Override
public void setCurrentItem(int item) {
mPopulatePending = false;
setCurrentItemInternal(item, true, false);
}
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
if (mAdapter == null || mAdapter.getCount() <= 0) {
setScrollingCacheEnabled(false);
return;
}
if (!always && mCurItem == item && mItems.size() != 0) {
setScrollingCacheEnabled(false);
return;
}
if (item < 0) {
item = 0;
} else if (item >= mAdapter.getCount()) {
item = mAdapter.getCount() - 1;
}
if (item > (mCurItem+1) || item < (mCurItem-1)) {
// We are doing a jump by more than one page. To avoid
// glitches, we want to keep all current pages in the view
// until the scroll ends.
for (int i=0; i<mItems.size(); i++) {
mItems.get(i).scrolling = true;
}
}
final boolean dispatchSelected = mCurItem != item;
mCurItem = item;
populate();
if (smoothScroll) {
if (mOrientation == HORIZONTAL) {
smoothScrollTo(getWidth()*item, 0);
} else {
smoothScrollTo(0, getHeight()*item);
}
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
} else {
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
completeScroll();
if (mOrientation == HORIZONTAL) {
scrollTo(getWidth()*item, 0);
} else {
scrollTo(0, getHeight()*item);
}
}
}
public void setOnPageChangeListener(OnPageChangeListener listener) {
mOnPageChangeListener = listener;
}
/**
* 这个方法是控制滚动效果的
* @param x x
* @param y y
*/
void smoothScrollTo(int x, int y) {
if (getChildCount() == 0) {
// Nothing to do.
setScrollingCacheEnabled(false);
return;
}
int sx = getScrollX();
int sy = getScrollY();
int dx = x - sx;
int dy = y - sy;
if (dx == 0 && dy == 0) {
completeScroll();
return;
}
setScrollingCacheEnabled(true);
mScrolling = true;
setScrollState(SCROLL_STATE_SETTLING);
mScroller.startScroll(sx, sy, dx, dy);
invalidate();
}
void addNewItem(int position, int index) {
ItemInfo ii = new ItemInfo();
ii.position = position;
ii.object = mAdapter.instantiateItem(this, position);
if (index < 0) {
mItems.add(ii);
} else {
mItems.add(index, ii);
}
}
void dataSetChanged() {
boolean needPopulate = mItems.isEmpty() && mAdapter.getCount() > 0;
int newCurrItem = -1;
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
mAdapter.destroyItem(this, ii.position, ii.object);
needPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0, Math.min(mCurItem, mAdapter.getCount() - 1));
}
continue;
}
if (ii.position != newPos) {
if (ii.position == mCurItem) {
// Our current item changed position. Follow it.
newCurrItem = newPos;
}
ii.position = newPos;
needPopulate = true;
}
}
if (newCurrItem >= 0) {
setCurrentItemInternal(newCurrItem, false, true);
needPopulate = true;
}
if (needPopulate) {
populate();
requestLayout();
}
}
void populate() {
if (mAdapter == null) {
return;
}
// Bail now if we are waiting to populate. This is to hold off
// on creating views from the time the user releases their finger to
// fling to a new position until we have finished the scroll to
// that position, avoiding glitches from happening at that point.
if (mPopulatePending) {
if (DEBUG) {
Log.i(TAG, "populate is pending, skipping for now...");
}
return;
}
// Also, don't populate until we are attached to a window. This is to
// avoid trying to populate before we have restored our view hierarchy
// state and conflicting with what is restored.
if (getWindowToken() == null) {
return;
}
mAdapter.startUpdate(this);
final int startPos = mCurItem > 0 ? mCurItem - 1 : mCurItem;
final int count = mAdapter.getCount();
final int endPos = mCurItem < (count-1) ? mCurItem+1 : count-1;
if (DEBUG) {
Log.v(TAG, "populating: startPos=" + startPos + " endPos=" + endPos);
}
// Add and remove pages in the existing list.
int lastPos = -1;
for (int i=0; i<mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if ((ii.position < startPos || ii.position > endPos) && !ii.scrolling) {
if (DEBUG) {
Log.i(TAG, "removing: " + ii.position + " @ " + i);
}
mItems.remove(i);
i--;
mAdapter.destroyItem(this, ii.position, ii.object);
} else if (lastPos < endPos && ii.position > startPos) {
// The next item is outside of our range, but we have a gap
// between it and the last item where we want to have a page
// shown. Fill in the gap.
lastPos++;
if (lastPos < startPos) {
lastPos = startPos;
}
while (lastPos <= endPos && lastPos < ii.position) {
if (DEBUG) {
Log.i(TAG, "inserting: " + lastPos + " @ " + i);
}
addNewItem(lastPos, i);
lastPos++;
i++;
}
}
lastPos = ii.position;
}
// Add any new pages we need at the end.
lastPos = mItems.size() > 0 ? mItems.get(mItems.size()-1).position : -1;
if (lastPos < endPos) {
lastPos++;
lastPos = lastPos > startPos ? lastPos : startPos;
while (lastPos <= endPos) {
if (DEBUG) {
Log.i(TAG, "appending: " + lastPos);
}
addNewItem(lastPos, -1);
lastPos++;
}
}
if (DEBUG) {
Log.i(TAG, "Current page list:");
for (int i=0; i<mItems.size(); i++) {
Log.i(TAG, "#" + i + ": page " + mItems.get(i).position);
}
}
mAdapter.finishUpdate(this);
}
public static class SavedState extends BaseSavedState {
int position;
Parcelable adapterState;
ClassLoader loader;
public SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(position);
out.writeParcelable(adapterState, flags);
}
@NonNull
@Override
public String toString() {
return "FragmentPager.SavedState{"
+ Integer.toHexString(System.identityHashCode(this))
+ " position=" + position + "}";
}
public static final Parcelable.Creator<SavedState> CREATOR
= ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in, ClassLoader loader) {
return new SavedState(in, loader);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
});
SavedState(Parcel in, ClassLoader loader) {
super(in);
if (loader == null) {
loader = getClass().getClassLoader();
}
position = in.readInt();
adapterState = in.readParcelable(loader);
this.loader = loader;
}
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
ss.position = mCurItem;
ss.adapterState = mAdapter.saveState();
return ss;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState)state;
super.onRestoreInstanceState(ss.getSuperState());
if (mAdapter != null) {
mAdapter.restoreState(ss.adapterState, ss.loader);
setCurrentItemInternal(ss.position, false, true);
} else {
mRestoredCurItem = ss.position;
mRestoredAdapterState = ss.adapterState;
mRestoredClassLoader = ss.loader;
}
}
public void setOrientation(int orientation) {
switch (orientation) {
case HORIZONTAL:
case VERTICAL:
break;
default:
throw new IllegalArgumentException("Only HORIZONTAL and VERTICAL are valid orientations.");
}
if (orientation == mOrientation) {
return;
}
//Complete any scroll we are currently in the middle of
completeScroll();
//Reset values
mInitialMotion = 0;
mLastMotionX = 0;
mLastMotionY = 0;
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
//Adjust scroll for new orientation
mOrientation = orientation;
if (mOrientation == HORIZONTAL) {
scrollTo(mCurItem * getWidth(), 0);
} else {
scrollTo(0, mCurItem * getHeight());
}
requestLayout();
}
@Override
public void addView(View child, int index, ViewGroup.LayoutParams params) {
if (mInLayout) {
addViewInLayout(child, index, params);
child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
} else {
super.addView(child, index, params);
}
if (USE_CACHE) {
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabled(mScrollingCacheEnabled);
} else {
child.setDrawingCacheEnabled(false);
}
}
}
ItemInfo infoForChild(View child) {
for (int i=0; i<mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (mAdapter.isViewFromObject(child, ii.object)) {
return ii;
}
}
return null;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// For simple implementation, or internal size is always 0.
// We depend on the container to specify the layout size of
// our view. We can't really know what it is since we will be
// adding and removing different arbitrary views and do not
// want the layout to change as this happens.
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec),
getDefaultSize(0, heightMeasureSpec));
// Children are just made to fill our space.
mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -
getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY);
mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -
getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY);
// Make sure we have created all fragments that we need to have shown.
mInLayout = true;
populate();
mInLayout = false;
// Make sure all children have been properly measured.
final int size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
if (DEBUG) {
Log.v(TAG, "Measuring #" + i + " " + child
+ ": " + mChildWidthMeasureSpec + " x " + mChildHeightMeasureSpec);
}
child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
}
}
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
// Make sure scroll position is set correctly.
if (mOrientation == HORIZONTAL) {
int scrollPos = mCurItem*w;
if (scrollPos != getScrollX()) {
completeScroll();
scrollTo(scrollPos, getScrollY());
}
} else {
int scrollPos = mCurItem*h;
if (scrollPos != getScrollY()) {
completeScroll();
scrollTo(getScrollX(), scrollPos);
}
}
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
mInLayout = true;
populate();
mInLayout = false;
final int count = getChildCount();
final int size = (mOrientation == HORIZONTAL) ? r-l : b-t;
for (int i = 0; i < count; i++) {
View child = getChildAt(i);
ItemInfo ii;
if (child.getVisibility() != GONE && (ii=infoForChild(child)) != null) {
int off = size*ii.position;
int childLeft = getPaddingLeft();
int childTop = getPaddingTop();
if (mOrientation == HORIZONTAL) {
childLeft += off;
} else {
childTop += off;
}
if (DEBUG) {
Log.v(TAG, "Positioning #" + i + " " + child + " f=" + ii.object
+ ":" + childLeft + "," + childTop + " " + child.getMeasuredWidth()
+ "x" + child.getMeasuredHeight());
}
child.layout(childLeft, childTop,
childLeft + child.getMeasuredWidth(),
childTop + child.getMeasuredHeight());
}
}
}
@Override
public void computeScroll() {
if (DEBUG) {
Log.i(TAG, "computeScroll: finished=" + mScroller.isFinished());
}
if (!mScroller.isFinished()) {
if (mScroller.computeScrollOffset()) {
if (DEBUG) {
Log.i(TAG, "computeScroll: still scrolling");
}
int oldX = getScrollX();
int oldY = getScrollY();
int x = mScroller.getCurrX();
int y = mScroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
}
if (mOnPageChangeListener != null) {
int size;
int value;
if (mOrientation == HORIZONTAL) {
size = getWidth();
value = x;
} else {
size = getHeight();
value = y;
}
final int position = value / size;
final int offsetPixels = value % size;
final float offset = (float) offsetPixels / size;
mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);
}
// Keep on drawing until the animation has finished.
invalidate();
return;
}
}
// Done with scroll, clean up state.
completeScroll();
}
private void completeScroll() {
boolean needPopulate;
if ((needPopulate=mScrolling)) {
// Done with scroll, no longer want to cache view drawing.
setScrollingCacheEnabled(false);
mScroller.abortAnimation();
int oldX = getScrollX();
int oldY = getScrollY();
int x = mScroller.getCurrX();
int y = mScroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
}
setScrollState(SCROLL_STATE_IDLE);
}
mPopulatePending = false;
mScrolling = false;
for (int i=0; i<mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (ii.scrolling) {
needPopulate = true;
ii.scrolling = false;
}
}
if (needPopulate) {
populate();
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
mRecentTouchTime = System.currentTimeMillis();
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
// Always take care of the touch gesture being complete.
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
// Release the drag.
if (DEBUG) {
Log.v(TAG, "Intercept done!");
}
mIsBeingDragged = false;
mIsUnableToDrag = false;
mActivePointerId = INVALID_POINTER;
return false;
}
// Nothing more to do here if we have decided whether or not we
// are dragging.
if (action != MotionEvent.ACTION_DOWN) {
if (mIsBeingDragged) {
if (DEBUG) {
Log.v(TAG, "Intercept returning true!");
}
return true;
}
if (mIsUnableToDrag) {
if (DEBUG) {
Log.v(TAG, "Intercept returning false!");
}
return false;
}
}
switch (action) {
case MotionEvent.ACTION_MOVE: {
/*
* mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
* whether the user has moved far enough from his original down touch.
*/
/*
* Locally do absolute value. mLastMotionY is set to the y value
* of the down event.
*/
final int activePointerId = mActivePointerId;
if (activePointerId == INVALID_POINTER) {
// If we don't have a valid id, the touch down wasn't on content.
break;
}
final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float xDiff = Math.abs(x - mLastMotionX);
final float yDiff = Math.abs(y - mLastMotionY);
float primaryDiff;
float secondaryDiff;
if (mOrientation == HORIZONTAL) {
primaryDiff = xDiff;
secondaryDiff = yDiff;
} else {
primaryDiff = yDiff;
secondaryDiff = xDiff;
}
if (DEBUG) {
Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
}
if (primaryDiff > mTouchSlop && primaryDiff > secondaryDiff) {
if (DEBUG) {
Log.v(TAG, "Starting drag!");
}
mIsBeingDragged = true;
setScrollState(SCROLL_STATE_DRAGGING);
if (mOrientation == HORIZONTAL) {
mLastMotionX = x;
} else {
mLastMotionY = y;
}
setScrollingCacheEnabled(true);
} else {
if (secondaryDiff > mTouchSlop) {
// The finger has moved enough in the vertical
// direction to be counted as a drag... abort
// any attempt to drag horizontally, to work correctly
// with children that have scrolling containers.
if (DEBUG) {
Log.v(TAG, "Starting unable to drag!");
}
mIsUnableToDrag = true;
}
}
break;
}
case MotionEvent.ACTION_DOWN: {
/*
* Remember location of down touch.
* ACTION_DOWN always refers to pointer index 0.
*/
if (mOrientation == HORIZONTAL) {
mLastMotionX = mInitialMotion = ev.getX();
mLastMotionY = ev.getY();
} else {
mLastMotionX = ev.getX();
mLastMotionY = mInitialMotion = ev.getY();
}
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
if (mScrollState == SCROLL_STATE_SETTLING) {
// Let the user 'catch' the pager as it animates.
mIsBeingDragged = true;
mIsUnableToDrag = false;
setScrollState(SCROLL_STATE_DRAGGING);
} else {
completeScroll();
mIsBeingDragged = false;
mIsUnableToDrag = false;
}
if (DEBUG) {
Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY
+ " mIsBeingDragged=" + mIsBeingDragged
+ "mIsUnableToDrag=" + mIsUnableToDrag);
}
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
break;
default:
break;
}
/*
* The only time we want to intercept motion events is if we are in the
* drag mode.
*/
return mIsBeingDragged;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
// Don't handle edge touches immediately -- they may actually belong to one of our
// descendants.
return false;
}
if (mAdapter == null || mAdapter.getCount() == 0) {
// Nothing to present or scroll; nothing to touch.
return false;
}
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
final int action = ev.getAction();
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
/*
* If being flinged and user touches, stop the fling. isFinished
* will be false if being flinged.
*/
completeScroll();
// Remember where the motion event started
if (mOrientation == HORIZONTAL) {
mLastMotionX = mInitialMotion = ev.getX();
} else {
mLastMotionY = mInitialMotion = ev.getY();
}
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
break;
}
case MotionEvent.ACTION_MOVE:
if (!mIsBeingDragged) {
final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float xDiff = Math.abs(x - mLastMotionX);
final float yDiff = Math.abs(y - mLastMotionY);
float primaryDiff;
float secondaryDiff;
if (mOrientation == HORIZONTAL) {
primaryDiff = xDiff;
secondaryDiff = yDiff;
} else {
primaryDiff = yDiff;
secondaryDiff = xDiff;
}
if (DEBUG) {
Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
}
if (primaryDiff > mTouchSlop && primaryDiff > secondaryDiff) {
if (DEBUG) {
Log.v(TAG, "Starting drag!");
}
mIsBeingDragged = true;
if (mOrientation == HORIZONTAL) {
mLastMotionX = x;
} else {
mLastMotionY = y;
}
setScrollState(SCROLL_STATE_DRAGGING);
setScrollingCacheEnabled(true);
}
}
if (mIsBeingDragged) {
// Scroll to follow the motion event
final int activePointerIndex = MotionEventCompat.findPointerIndex(
ev, mActivePointerId);
final float x = MotionEventCompat.getX(ev, activePointerIndex);
final float y = MotionEventCompat.getY(ev, activePointerIndex);
int size;
float scroll;
if (mOrientation == HORIZONTAL) {
size = getWidth();
scroll = getScrollX() + (mLastMotionX - x);
mLastMotionX = x;
} else {
size = getHeight();
scroll = getScrollY() + (mLastMotionY - y);
mLastMotionY = y;
}
final float lowerBound = Math.max(0, (mCurItem - 1) * size);
final float upperBound =
Math.min(mCurItem + 1, mAdapter.getCount() - 1) * size;
if (scroll < lowerBound) {
scroll = lowerBound;
} else if (scroll > upperBound) {
scroll = upperBound;
}
if (mOrientation == HORIZONTAL) {
// Don't lose the rounded component
mLastMotionX += scroll - (int) scroll;
scrollTo((int) scroll, getScrollY());
} else {
// Don't lose the rounded component
mLastMotionY += scroll - (int) scroll;
scrollTo(getScrollX(), (int) scroll);
}
if (mOnPageChangeListener != null) {
final int position = (int) scroll / size;
final int positionOffsetPixels = (int) scroll % size;
final float positionOffset = (float) positionOffsetPixels / size;
mOnPageChangeListener.onPageScrolled(position, positionOffset,
positionOffsetPixels);
}
}
break;
case MotionEvent.ACTION_UP:
if (mIsBeingDragged) {
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity;
float lastMotion;
int sizeOverThree;
if (mOrientation == HORIZONTAL) {
initialVelocity = (int)VelocityTrackerCompat.getXVelocity(
velocityTracker, mActivePointerId);
lastMotion = mLastMotionX;
sizeOverThree = getWidth() / 3;
} else {
initialVelocity = (int)VelocityTrackerCompat.getYVelocity(
velocityTracker, mActivePointerId);
lastMotion = mLastMotionY;
sizeOverThree = getHeight() / 3;
}
mPopulatePending = true;
if ((Math.abs(initialVelocity) > mMinimumVelocity)
|| Math.abs(mInitialMotion-lastMotion) >= sizeOverThree) {
if (lastMotion > mInitialMotion) {
setCurrentItemInternal(mCurItem-1, true, true);
} else {
setCurrentItemInternal(mCurItem+1, true, true);
}
} else {
setCurrentItemInternal(mCurItem, true, true);
}
mActivePointerId = INVALID_POINTER;
endDrag();
}
break;
case MotionEvent.ACTION_CANCEL:
if (mIsBeingDragged) {
setCurrentItemInternal(mCurItem, true, true);
mActivePointerId = INVALID_POINTER;
endDrag();
}
break;
case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
if (mOrientation == HORIZONTAL) {
mLastMotionX = MotionEventCompat.getX(ev, index);
} else {
mLastMotionY = MotionEventCompat.getY(ev, index);
}
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
if (mOrientation == HORIZONTAL) {
mLastMotionX = MotionEventCompat.getX(ev, index);
} else {
mLastMotionY = MotionEventCompat.getY(ev, index);
}
break;
default:
break;
}
return true;
}
private void onSecondaryPointerUp(MotionEvent ev) {
final int pointerIndex = MotionEventCompat.getActionIndex(ev);
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
if (pointerId == mActivePointerId) {
// This was our active pointer going up. Choose a new
// active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
if (mOrientation == HORIZONTAL) {
mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
} else {
mLastMotionY = MotionEventCompat.getY(ev, newPointerIndex);
}
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
}
}
private void endDrag() {
mIsBeingDragged = false;
mIsUnableToDrag = false;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
}
private void setScrollingCacheEnabled(boolean enabled) {
if (mScrollingCacheEnabled != enabled) {
mScrollingCacheEnabled = enabled;
if (USE_CACHE) {
final int size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabled(enabled);
}
}
}
}
}
/**
* 用来实现adapter的notifyDataSetChanged通知变化
*/
private class PagerObserver extends android.database.DataSetObserver {
@Override
public void onChanged() {
dataSetChanged();
}
@Override
public void onInvalidated() {
dataSetChanged();
}
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/pager/FixedSpeedScroller.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 com.yc.pagerlib.pager;
import android.content.Context;
import android.view.animation.Interpolator;
import android.widget.Scroller;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2019/6/20
* desc : 自定义Scroller，控制滚动速率
* revise:
* </pre>
*/
public class FixedSpeedScroller extends Scroller {
private int mDuration = 1500;
private long mRecentTouchTime;
FixedSpeedScroller(Context context, Interpolator interpolator, long touchTime) {
super(context, interpolator);
this.mRecentTouchTime = touchTime;
}
@Override
public void startScroll(int startX, int startY, int dx, int dy, int duration) {
// 如果手工滚动,则加速滚动
int time = 2000;
if (System.currentTimeMillis() - mRecentTouchTime > time) {
duration = mDuration;
} else {
duration /= 2;
}
super.startScroll(startX, startY, dx, dy, duration);
}
@Override
public void startScroll(int startX, int startY, int dx, int dy) {
super.startScroll(startX, startY, dx, dy, mDuration);
}
void setDuration(int time) {
mDuration = time;
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/pager/VerticalViewPager.java | Java | package com.yc.pagerlib.pager;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.SystemClock;
import androidx.core.os.ParcelableCompat;
import androidx.core.os.ParcelableCompatCreatorCallbacks;
import androidx.core.view.AccessibilityDelegateCompat;
import androidx.core.view.MotionEventCompat;
import androidx.core.view.VelocityTrackerCompat;
import androidx.core.view.ViewCompat;
import androidx.core.view.ViewConfigurationCompat;
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
import androidx.core.view.accessibility.AccessibilityRecordCompat;
import androidx.core.widget.EdgeEffectCompat;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.FocusFinder;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SoundEffectConstants;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.accessibility.AccessibilityEvent;
import android.view.animation.Interpolator;
import android.widget.Scroller;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
* <pre>
* @author 杨充
* blog : https://github.com/yangchong211
* time : 2019/6/20
* desc : 竖直方向ViewPager
* revise:
* </pre>
*/
public class VerticalViewPager extends ViewGroup {
private static final String TAG = "ViewPager";
private static final boolean DEBUG = false;
private static final boolean USE_CACHE = false;
private static final int DEFAULT_OFFSCREEN_PAGES = 1;
private static final int MAX_SETTLE_DURATION = 600; // ms
private static final int MIN_DISTANCE_FOR_FLING = 25; // dips
private static final int DEFAULT_GUTTER_SIZE = 16; // dips
private static final int MIN_FLING_VELOCITY = 400; // dips
private final int TYPE_VIEW_SCROLLED = 4096;
private static final int[] LAYOUT_ATTRS = new int[]{
android.R.attr.layout_gravity
};
/**
* Used to track what the expected number of items in the adapter should be.
* If the app changes this when we don't expect it, we'll throw a big obnoxious exception.
*/
private int mExpectedAdapterCount;
static class ItemInfo {
Object object;
int position;
boolean scrolling;
float heightFactor;
float offset;
}
private static final Comparator<ItemInfo> COMPARATOR = new Comparator<ItemInfo>() {
@Override
public int compare(ItemInfo lhs, ItemInfo rhs) {
return lhs.position - rhs.position;
}
};
private static final Interpolator sInterpolator = new Interpolator() {
public float getInterpolation(float t) {
t -= 1.0f;
return t * t * t * t * t + 1.0f;
}
};
private final ArrayList<ItemInfo> mItems = new ArrayList<ItemInfo>();
private final ItemInfo mTempItem = new ItemInfo();
private final Rect mTempRect = new Rect();
private PagerAdapter mAdapter;
private int mCurItem; // Index of currently displayed page.
private int mRestoredCurItem = -1;
private Parcelable mRestoredAdapterState = null;
private ClassLoader mRestoredClassLoader = null;
private Scroller mScroller;
private PagerObserver mObserver;
private int mPageMargin;
private Drawable mMarginDrawable;
private int mLeftPageBounds;
private int mRightPageBounds;
// Offsets of the first and last items, if known.
// Set during population, used to determine if we are at the beginning
// or end of the pager data set during touch scrolling.
private float mFirstOffset = -Float.MAX_VALUE;
private float mLastOffset = Float.MAX_VALUE;
private int mChildWidthMeasureSpec;
private int mChildHeightMeasureSpec;
private boolean mInLayout;
private boolean mScrollingCacheEnabled;
private boolean mPopulatePending;
private int mOffscreenPageLimit = DEFAULT_OFFSCREEN_PAGES;
private boolean mIsBeingDragged;
private boolean mIsUnableToDrag;
private boolean mIgnoreGutter;
private int mDefaultGutterSize;
private int mGutterSize;
private int mTouchSlop;
/**
* Position of the last motion event.
*/
private float mLastMotionX;
private float mLastMotionY;
private float mInitialMotionX;
private float mInitialMotionY;
/**
* ID of the active pointer. This is used to retain consistency during
* drags/flings if multiple pointers are used.
*/
private int mActivePointerId = INVALID_POINTER;
/**
* Sentinel value for no current active pointer.
* Used by {@link #mActivePointerId}.
*/
private static final int INVALID_POINTER = -1;
/**
* Determines speed during touch scrolling
*/
private VelocityTracker mVelocityTracker;
private int mMinimumVelocity;
private int mMaximumVelocity;
private int mFlingDistance;
private int mCloseEnough;
// If the pager is at least this close to its final position, complete the scroll
// on touch down and let the user interact with the content inside instead of
// "catching" the flinging pager.
private static final int CLOSE_ENOUGH = 2; // dp
private boolean mFakeDragging;
private long mFakeDragBeginTime;
private EdgeEffectCompat mTopEdge;
private EdgeEffectCompat mBottomEdge;
private boolean mFirstLayout = true;
private boolean mNeedCalculatePageOffsets = false;
private boolean mCalledSuper;
private int mDecorChildCount;
private ViewPager.OnPageChangeListener mOnPageChangeListener;
private ViewPager.OnPageChangeListener mInternalPageChangeListener;
private OnAdapterChangeListener mAdapterChangeListener;
private ViewPager.PageTransformer mPageTransformer;
private Method mSetChildrenDrawingOrderEnabled;
private static final int DRAW_ORDER_DEFAULT = 0;
private static final int DRAW_ORDER_FORWARD = 1;
private static final int DRAW_ORDER_REVERSE = 2;
private int mDrawingOrder;
private ArrayList<View> mDrawingOrderedChildren;
private static final ViewPositionComparator sPositionComparator = new ViewPositionComparator();
/**
* Indicates that the pager is in an idle, settled state. The current page
* is fully in view and no animation is in progress.
*/
public static final int SCROLL_STATE_IDLE = 0;
/**
* Indicates that the pager is currently being dragged by the user.
*/
public static final int SCROLL_STATE_DRAGGING = 1;
/**
* Indicates that the pager is in the process of settling to a final position.
*/
public static final int SCROLL_STATE_SETTLING = 2;
private final Runnable mEndScrollRunnable = new Runnable() {
public void run() {
setScrollState(SCROLL_STATE_IDLE);
populate();
}
};
private int mScrollState = SCROLL_STATE_IDLE;
/**
* Used internally to monitor when adapters are switched.
*/
interface OnAdapterChangeListener {
public void onAdapterChanged(PagerAdapter oldAdapter, PagerAdapter newAdapter);
}
/**
* Used internally to tag special types of child views that should be added as
* pager decorations by default.
*/
interface Decor {
}
public VerticalViewPager(Context context) {
super(context);
initViewPager();
}
public VerticalViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
initViewPager();
}
void initViewPager() {
setWillNotDraw(false);
setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
setFocusable(true);
final Context context = getContext();
mScroller = new Scroller(context, sInterpolator);
final ViewConfiguration configuration = ViewConfiguration.get(context);
final float density = context.getResources().getDisplayMetrics().density;
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
mMinimumVelocity = (int) (MIN_FLING_VELOCITY * density);
mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
mTopEdge = new EdgeEffectCompat(context);
mBottomEdge = new EdgeEffectCompat(context);
mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);
mCloseEnough = (int) (CLOSE_ENOUGH * density);
mDefaultGutterSize = (int) (DEFAULT_GUTTER_SIZE * density);
ViewCompat.setAccessibilityDelegate(this, new MyAccessibilityDelegate());
if (ViewCompat.getImportantForAccessibility(this)
== ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
ViewCompat.setImportantForAccessibility(this,
ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
}
}
@Override
protected void onDetachedFromWindow() {
removeCallbacks(mEndScrollRunnable);
super.onDetachedFromWindow();
}
private void setScrollState(int newState) {
if (mScrollState == newState) {
return;
}
mScrollState = newState;
if (mPageTransformer != null) {
// PageTransformers can do complex things that benefit from hardware layers.
enableLayers(newState != SCROLL_STATE_IDLE);
}
if (mOnPageChangeListener != null) {
mOnPageChangeListener.onPageScrollStateChanged(newState);
}
}
/**
* Set a PagerAdapter that will supply views for this pager as needed.
*
* @param adapter Adapter to use
*/
public void setAdapter(PagerAdapter adapter) {
if (mAdapter != null) {
mAdapter.unregisterDataSetObserver(mObserver);
mAdapter.startUpdate(this);
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
mAdapter.destroyItem(this, ii.position, ii.object);
}
mAdapter.finishUpdate(this);
mItems.clear();
removeNonDecorViews();
mCurItem = 0;
scrollTo(0, 0);
}
final PagerAdapter oldAdapter = mAdapter;
mAdapter = adapter;
mExpectedAdapterCount = 0;
if (mAdapter != null) {
if (mObserver == null) {
mObserver = new PagerObserver();
}
mAdapter.registerDataSetObserver(mObserver);
mPopulatePending = false;
final boolean wasFirstLayout = mFirstLayout;
mFirstLayout = true;
mExpectedAdapterCount = mAdapter.getCount();
if (mRestoredCurItem >= 0) {
mAdapter.restoreState(mRestoredAdapterState, mRestoredClassLoader);
setCurrentItemInternal(mRestoredCurItem, false, true);
mRestoredCurItem = -1;
mRestoredAdapterState = null;
mRestoredClassLoader = null;
} else if (!wasFirstLayout) {
populate();
} else {
requestLayout();
}
}
if (mAdapterChangeListener != null && oldAdapter != adapter) {
mAdapterChangeListener.onAdapterChanged(oldAdapter, adapter);
}
}
private void removeNonDecorViews() {
for (int i = 0; i < getChildCount(); i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) {
removeViewAt(i);
i--;
}
}
}
/**
* Retrieve the current adapter supplying pages.
*
* @return The currently registered PagerAdapter
*/
public PagerAdapter getAdapter() {
return mAdapter;
}
void setOnAdapterChangeListener(OnAdapterChangeListener listener) {
mAdapterChangeListener = listener;
}
// private int getClientWidth() {
// return getMeasuredWidth() - getPaddingLeft() - getPaddingRight();
// }
private int getClientHeight() {
return getMeasuredHeight() - getPaddingTop() - getPaddingBottom();
}
/**
* Set the currently selected page. If the ViewPager has already been through its first
* layout with its current adapter there will be a smooth animated transition between
* the current item and the specified item.
*
* @param item Item index to select
*/
public void setCurrentItem(int item) {
mPopulatePending = false;
setCurrentItemInternal(item, !mFirstLayout, false);
}
/**
* Set the currently selected page.
*
* @param item Item index to select
* @param smoothScroll True to smoothly scroll to the new item, false to transition immediately
*/
public void setCurrentItem(int item, boolean smoothScroll) {
mPopulatePending = false;
setCurrentItemInternal(item, smoothScroll, false);
}
public int getCurrentItem() {
return mCurItem;
}
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
setCurrentItemInternal(item, smoothScroll, always, 0);
}
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
if (mAdapter == null || mAdapter.getCount() <= 0) {
setScrollingCacheEnabled(false);
return;
}
if (!always && mCurItem == item && mItems.size() != 0) {
setScrollingCacheEnabled(false);
return;
}
if (item < 0) {
item = 0;
} else if (item >= mAdapter.getCount()) {
item = mAdapter.getCount() - 1;
}
final int pageLimit = mOffscreenPageLimit;
if (item > (mCurItem + pageLimit) || item < (mCurItem - pageLimit)) {
// We are doing a jump by more than one page. To avoid
// glitches, we want to keep all current pages in the view
// until the scroll ends.
for (int i = 0; i < mItems.size(); i++) {
mItems.get(i).scrolling = true;
}
}
final boolean dispatchSelected = mCurItem != item;
if (mFirstLayout) {
// We don't have any idea how big we are yet and shouldn't have any pages either.
// Just set things up and let the pending layout handle things.
mCurItem = item;
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
if (dispatchSelected && mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageSelected(item);
}
requestLayout();
} else {
populate(item);
scrollToItem(item, smoothScroll, velocity, dispatchSelected);
}
}
private void scrollToItem(int item, boolean smoothScroll, int velocity,
boolean dispatchSelected) {
final ItemInfo curInfo = infoForPosition(item);
int destY = 0;
if (curInfo != null) {
final int height = getClientHeight();
destY = (int) (height * Math.max(mFirstOffset,
Math.min(curInfo.offset, mLastOffset)));
}
if (smoothScroll) {
smoothScrollTo(0, destY, velocity);
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
if (dispatchSelected && mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageSelected(item);
}
} else {
if (dispatchSelected && mOnPageChangeListener != null) {
mOnPageChangeListener.onPageSelected(item);
}
if (dispatchSelected && mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageSelected(item);
}
completeScroll(false);
scrollTo(0, destY);
pageScrolled(destY);
}
}
/**
* Set a listener that will be invoked whenever the page changes or is incrementally
* scrolled. See {@link ViewPager.OnPageChangeListener}.
*
* @param listener Listener to set
*/
public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
mOnPageChangeListener = listener;
}
/**
* Set a {@link ViewPager.PageTransformer} that will be called for each attached page whenever
* the scroll position is changed. This allows the application to apply custom property
* transformations to each page, overriding the default sliding look and feel.
* <p/>
* <p><em>Note:</em> Prior to Android 3.0 the property animation APIs did not exist.
* As a result, setting a PageTransformer prior to Android 3.0 (API 11) will have no effect.</p>
*
* @param reverseDrawingOrder true if the supplied PageTransformer requires page views
* to be drawn from last to first instead of first to last.
* @param transformer PageTransformer that will modify each page's animation properties
*/
public void setPageTransformer(boolean reverseDrawingOrder, ViewPager.PageTransformer transformer) {
if (Build.VERSION.SDK_INT >= 11) {
final boolean hasTransformer = transformer != null;
final boolean needsPopulate = hasTransformer != (mPageTransformer != null);
mPageTransformer = transformer;
setChildrenDrawingOrderEnabledCompat(hasTransformer);
if (hasTransformer) {
mDrawingOrder = reverseDrawingOrder ? DRAW_ORDER_REVERSE : DRAW_ORDER_FORWARD;
} else {
mDrawingOrder = DRAW_ORDER_DEFAULT;
}
if (needsPopulate) populate();
}
}
void setChildrenDrawingOrderEnabledCompat(boolean enable) {
if (Build.VERSION.SDK_INT >= 7) {
if (mSetChildrenDrawingOrderEnabled == null) {
try {
mSetChildrenDrawingOrderEnabled = ViewGroup.class.getDeclaredMethod(
"setChildrenDrawingOrderEnabled", new Class[]{Boolean.TYPE});
} catch (NoSuchMethodException e) {
Log.e(TAG, "Can't find setChildrenDrawingOrderEnabled", e);
}
}
try {
mSetChildrenDrawingOrderEnabled.invoke(this, enable);
} catch (Exception e) {
Log.e(TAG, "Error changing children drawing order", e);
}
}
}
@Override
protected int getChildDrawingOrder(int childCount, int i) {
final int index = mDrawingOrder == DRAW_ORDER_REVERSE ? childCount - 1 - i : i;
final int result = ((LayoutParams) mDrawingOrderedChildren.get(index).getLayoutParams()).childIndex;
return result;
}
/**
* Set a separate OnPageChangeListener for internal use by the support library.
*
* @param listener Listener to set
* @return The old listener that was set, if any.
*/
ViewPager.OnPageChangeListener setInternalPageChangeListener(ViewPager.OnPageChangeListener listener) {
ViewPager.OnPageChangeListener oldListener = mInternalPageChangeListener;
mInternalPageChangeListener = listener;
return oldListener;
}
/**
* Returns the number of pages that will be retained to either side of the
* current page in the view hierarchy in an idle state. Defaults to 1.
*
* @return How many pages will be kept offscreen on either side
* @see #setOffscreenPageLimit(int)
*/
public int getOffscreenPageLimit() {
return mOffscreenPageLimit;
}
/**
* Set the number of pages that should be retained to either side of the
* current page in the view hierarchy in an idle state. Pages beyond this
* limit will be recreated from the adapter when needed.
* <p/>
* <p>This is offered as an optimization. If you know in advance the number
* of pages you will need to support or have lazy-loading mechanisms in place
* on your pages, tweaking this setting can have benefits in perceived smoothness
* of paging animations and interaction. If you have a small number of pages (3-4)
* that you can keep active all at once, less time will be spent in layout for
* newly created view subtrees as the user pages back and forth.</p>
* <p/>
* <p>You should keep this limit low, especially if your pages have complex layouts.
* This setting defaults to 1.</p>
*
* @param limit How many pages will be kept offscreen in an idle state.
*/
public void setOffscreenPageLimit(int limit) {
if (limit < DEFAULT_OFFSCREEN_PAGES) {
Log.w(TAG, "Requested offscreen page limit " + limit + " too small; defaulting to " +
DEFAULT_OFFSCREEN_PAGES);
limit = DEFAULT_OFFSCREEN_PAGES;
}
if (limit != mOffscreenPageLimit) {
mOffscreenPageLimit = limit;
populate();
}
}
/**
* Set the margin between pages.
*
* @param marginPixels Distance between adjacent pages in pixels
* @see #getPageMargin()
* @see #setPageMarginDrawable(Drawable)
* @see #setPageMarginDrawable(int)
*/
public void setPageMargin(int marginPixels) {
final int oldMargin = mPageMargin;
mPageMargin = marginPixels;
final int height = getHeight();
recomputeScrollPosition(height, height, marginPixels, oldMargin);
requestLayout();
}
/**
* Return the margin between pages.
*
* @return The size of the margin in pixels
*/
public int getPageMargin() {
return mPageMargin;
}
/**
* Set a drawable that will be used to fill the margin between pages.
*
* @param d Drawable to display between pages
*/
public void setPageMarginDrawable(Drawable d) {
mMarginDrawable = d;
if (d != null) refreshDrawableState();
setWillNotDraw(d == null);
invalidate();
}
/**
* Set a drawable that will be used to fill the margin between pages.
*
* @param resId Resource ID of a drawable to display between pages
*/
public void setPageMarginDrawable(int resId) {
setPageMarginDrawable(getContext().getResources().getDrawable(resId));
}
@Override
protected boolean verifyDrawable(Drawable who) {
return super.verifyDrawable(who) || who == mMarginDrawable;
}
@Override
protected void drawableStateChanged() {
super.drawableStateChanged();
final Drawable d = mMarginDrawable;
if (d != null && d.isStateful()) {
d.setState(getDrawableState());
}
}
// We want the duration of the page snap animation to be influenced by the distance that
// the screen has to travel, however, we don't want this duration to be effected in a
// purely linear fashion. Instead, we use this method to moderate the effect that the distance
// of travel has on the overall snap duration.
float distanceInfluenceForSnapDuration(float f) {
f -= 0.5f; // center the values about 0.
f *= 0.3f * Math.PI / 2.0f;
return (float) Math.sin(f);
}
/**
* Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
*
* @param x the number of pixels to scroll by on the X axis
* @param y the number of pixels to scroll by on the Y axis
*/
void smoothScrollTo(int x, int y) {
smoothScrollTo(x, y, 0);
}
/**
* Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
*
* @param x the number of pixels to scroll by on the X axis
* @param y the number of pixels to scroll by on the Y axis
* @param velocity the velocity associated with a fling, if applicable. (0 otherwise)
*/
void smoothScrollTo(int x, int y, int velocity) {
if (getChildCount() == 0) {
// Nothing to do.
setScrollingCacheEnabled(false);
return;
}
int sx = getScrollX();
int sy = getScrollY();
int dx = x - sx;
int dy = y - sy;
if (dx == 0 && dy == 0) {
completeScroll(false);
populate();
setScrollState(SCROLL_STATE_IDLE);
return;
}
setScrollingCacheEnabled(true);
setScrollState(SCROLL_STATE_SETTLING);
final int height = getClientHeight();
final int halfHeight = height / 2;
final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / height);
final float distance = halfHeight + halfHeight *
distanceInfluenceForSnapDuration(distanceRatio);
int duration = 0;
velocity = Math.abs(velocity);
if (velocity > 0) {
duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
} else {
final float pageHeight = height * mAdapter.getPageWidth(mCurItem);
final float pageDelta = (float) Math.abs(dx) / (pageHeight + mPageMargin);
duration = (int) ((pageDelta + 1) * 100);
}
duration = Math.min(duration, MAX_SETTLE_DURATION);
mScroller.startScroll(sx, sy, dx, dy, duration);
ViewCompat.postInvalidateOnAnimation(this);
}
ItemInfo addNewItem(int position, int index) {
ItemInfo ii = new ItemInfo();
ii.position = position;
ii.object = mAdapter.instantiateItem(this, position);
ii.heightFactor = mAdapter.getPageWidth(position);
if (index < 0 || index >= mItems.size()) {
mItems.add(ii);
} else {
mItems.add(index, ii);
}
return ii;
}
void dataSetChanged() {
// This method only gets called if our observer is attached, so mAdapter is non-null.
final int adapterCount = mAdapter.getCount();
mExpectedAdapterCount = adapterCount;
boolean needPopulate = mItems.size() < mOffscreenPageLimit * 2 + 1 &&
mItems.size() < adapterCount;
int newCurrItem = mCurItem;
boolean isUpdating = false;
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
if (!isUpdating) {
mAdapter.startUpdate(this);
isUpdating = true;
}
mAdapter.destroyItem(this, ii.position, ii.object);
needPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0, Math.min(mCurItem, adapterCount - 1));
needPopulate = true;
}
continue;
}
if (ii.position != newPos) {
if (ii.position == mCurItem) {
// Our current item changed position. Follow it.
newCurrItem = newPos;
}
ii.position = newPos;
needPopulate = true;
}
}
if (isUpdating) {
mAdapter.finishUpdate(this);
}
Collections.sort(mItems, COMPARATOR);
if (needPopulate) {
// Reset our known page widths; populate will recompute them.
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) {
lp.heightFactor = 0.f;
}
}
setCurrentItemInternal(newCurrItem, false, true);
requestLayout();
}
}
void populate() {
populate(mCurItem);
}
void populate(int newCurrentItem) {
ItemInfo oldCurInfo = null;
int focusDirection = View.FOCUS_FORWARD;
if (mCurItem != newCurrentItem) {
focusDirection = mCurItem < newCurrentItem ? View.FOCUS_DOWN : View.FOCUS_UP;
oldCurInfo = infoForPosition(mCurItem);
mCurItem = newCurrentItem;
}
if (mAdapter == null) {
sortChildDrawingOrder();
return;
}
// Bail now if we are waiting to populate. This is to hold off
// on creating views from the time the user releases their finger to
// fling to a new position until we have finished the scroll to
// that position, avoiding glitches from happening at that point.
if (mPopulatePending) {
if (DEBUG) Log.i(TAG, "populate is pending, skipping for now...");
sortChildDrawingOrder();
return;
}
// Also, don't populate until we are attached to a window. This is to
// avoid trying to populate before we have restored our view hierarchy
// state and conflicting with what is restored.
if (getWindowToken() == null) {
return;
}
mAdapter.startUpdate(this);
final int pageLimit = mOffscreenPageLimit;
final int startPos = Math.max(0, mCurItem - pageLimit);
final int N = mAdapter.getCount();
final int endPos = Math.min(N - 1, mCurItem + pageLimit);
if (N != mExpectedAdapterCount) {
String resName;
try {
resName = getResources().getResourceName(getId());
} catch (Resources.NotFoundException e) {
resName = Integer.toHexString(getId());
}
throw new IllegalStateException("The application's PagerAdapter changed the adapter's" +
" contents without calling PagerAdapter#notifyDataSetChanged!" +
" Expected adapter item count: " + mExpectedAdapterCount + ", found: " + N +
" Pager id: " + resName +
" Pager class: " + getClass() +
" Problematic adapter: " + mAdapter.getClass());
}
// Locate the currently focused item or add it if needed.
int curIndex = -1;
ItemInfo curItem = null;
for (curIndex = 0; curIndex < mItems.size(); curIndex++) {
final ItemInfo ii = mItems.get(curIndex);
if (ii.position >= mCurItem) {
if (ii.position == mCurItem) curItem = ii;
break;
}
}
if (curItem == null && N > 0) {
curItem = addNewItem(mCurItem, curIndex);
}
// Fill 3x the available width or up to the number of offscreen
// pages requested to either side, whichever is larger.
// If we have no current item we have no work to do.
if (curItem != null) {
float extraHeightTop = 0.f;
int itemIndex = curIndex - 1;
ItemInfo ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
final int clientHeight = getClientHeight();
final float topHeightNeeded = clientHeight <= 0 ? 0 :
2.f - curItem.heightFactor + (float) getPaddingLeft() / (float) clientHeight;
for (int pos = mCurItem - 1; pos >= 0; pos--) {
if (extraHeightTop >= topHeightNeeded && pos < startPos) {
if (ii == null) {
break;
}
if (pos == ii.position && !ii.scrolling) {
mItems.remove(itemIndex);
mAdapter.destroyItem(this, pos, ii.object);
if (DEBUG) {
Log.i(TAG, "populate() - destroyItem() with pos: " + pos +
" view: " + ((View) ii.object));
}
itemIndex--;
curIndex--;
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
}
} else if (ii != null && pos == ii.position) {
extraHeightTop += ii.heightFactor;
itemIndex--;
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
} else {
ii = addNewItem(pos, itemIndex + 1);
extraHeightTop += ii.heightFactor;
curIndex++;
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
}
}
float extraHeightBottom = curItem.heightFactor;
itemIndex = curIndex + 1;
if (extraHeightBottom < 2.f) {
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
final float bottomHeightNeeded = clientHeight <= 0 ? 0 :
(float) getPaddingRight() / (float) clientHeight + 2.f;
for (int pos = mCurItem + 1; pos < N; pos++) {
if (extraHeightBottom >= bottomHeightNeeded && pos > endPos) {
if (ii == null) {
break;
}
if (pos == ii.position && !ii.scrolling) {
mItems.remove(itemIndex);
mAdapter.destroyItem(this, pos, ii.object);
if (DEBUG) {
Log.i(TAG, "populate() - destroyItem() with pos: " + pos +
" view: " + ((View) ii.object));
}
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
}
} else if (ii != null && pos == ii.position) {
extraHeightBottom += ii.heightFactor;
itemIndex++;
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
} else {
ii = addNewItem(pos, itemIndex);
itemIndex++;
extraHeightBottom += ii.heightFactor;
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
}
}
}
calculatePageOffsets(curItem, curIndex, oldCurInfo);
}
if (DEBUG) {
Log.i(TAG, "Current page list:");
for (int i = 0; i < mItems.size(); i++) {
Log.i(TAG, "#" + i + ": page " + mItems.get(i).position);
}
}
mAdapter.setPrimaryItem(this, mCurItem, curItem != null ? curItem.object : null);
mAdapter.finishUpdate(this);
// Check width measurement of current pages and drawing sort order.
// Update LayoutParams as needed.
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
lp.childIndex = i;
if (!lp.isDecor && lp.heightFactor == 0.f) {
// 0 means requery the adapter for this, it doesn't have a valid width.
final ItemInfo ii = infoForChild(child);
if (ii != null) {
lp.heightFactor = ii.heightFactor;
lp.position = ii.position;
}
}
}
sortChildDrawingOrder();
if (hasFocus()) {
View currentFocused = findFocus();
ItemInfo ii = currentFocused != null ? infoForAnyChild(currentFocused) : null;
if (ii == null || ii.position != mCurItem) {
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
if (child.requestFocus(focusDirection)) {
break;
}
}
}
}
}
}
private void sortChildDrawingOrder() {
if (mDrawingOrder != DRAW_ORDER_DEFAULT) {
if (mDrawingOrderedChildren == null) {
mDrawingOrderedChildren = new ArrayList<View>();
} else {
mDrawingOrderedChildren.clear();
}
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
mDrawingOrderedChildren.add(child);
}
Collections.sort(mDrawingOrderedChildren, sPositionComparator);
}
}
private void calculatePageOffsets(ItemInfo curItem, int curIndex, ItemInfo oldCurInfo) {
final int N = mAdapter.getCount();
final int height = getClientHeight();
final float marginOffset = height > 0 ? (float) mPageMargin / height : 0;
// Fix up offsets for later layout.
if (oldCurInfo != null) {
final int oldCurPosition = oldCurInfo.position;
// Base offsets off of oldCurInfo.
if (oldCurPosition < curItem.position) {
int itemIndex = 0;
ItemInfo ii = null;
float offset = oldCurInfo.offset + oldCurInfo.heightFactor + marginOffset;
for (int pos = oldCurPosition + 1;
pos <= curItem.position && itemIndex < mItems.size(); pos++) {
ii = mItems.get(itemIndex);
while (pos > ii.position && itemIndex < mItems.size() - 1) {
itemIndex++;
ii = mItems.get(itemIndex);
}
while (pos < ii.position) {
// We don't have an item populated for this,
// ask the adapter for an offset.
offset += mAdapter.getPageWidth(pos) + marginOffset;
pos++;
}
ii.offset = offset;
offset += ii.heightFactor + marginOffset;
}
} else if (oldCurPosition > curItem.position) {
int itemIndex = mItems.size() - 1;
ItemInfo ii = null;
float offset = oldCurInfo.offset;
for (int pos = oldCurPosition - 1;
pos >= curItem.position && itemIndex >= 0; pos--) {
ii = mItems.get(itemIndex);
while (pos < ii.position && itemIndex > 0) {
itemIndex--;
ii = mItems.get(itemIndex);
}
while (pos > ii.position) {
// We don't have an item populated for this,
// ask the adapter for an offset.
offset -= mAdapter.getPageWidth(pos) + marginOffset;
pos--;
}
offset -= ii.heightFactor + marginOffset;
ii.offset = offset;
}
}
}
// Base all offsets off of curItem.
final int itemCount = mItems.size();
float offset = curItem.offset;
int pos = curItem.position - 1;
mFirstOffset = curItem.position == 0 ? curItem.offset : -Float.MAX_VALUE;
mLastOffset = curItem.position == N - 1 ?
curItem.offset + curItem.heightFactor - 1 : Float.MAX_VALUE;
// Previous pages
for (int i = curIndex - 1; i >= 0; i--, pos--) {
final ItemInfo ii = mItems.get(i);
while (pos > ii.position) {
offset -= mAdapter.getPageWidth(pos--) + marginOffset;
}
offset -= ii.heightFactor + marginOffset;
ii.offset = offset;
if (ii.position == 0) mFirstOffset = offset;
}
offset = curItem.offset + curItem.heightFactor + marginOffset;
pos = curItem.position + 1;
// Next pages
for (int i = curIndex + 1; i < itemCount; i++, pos++) {
final ItemInfo ii = mItems.get(i);
while (pos < ii.position) {
offset += mAdapter.getPageWidth(pos++) + marginOffset;
}
if (ii.position == N - 1) {
mLastOffset = offset + ii.heightFactor - 1;
}
ii.offset = offset;
offset += ii.heightFactor + marginOffset;
}
mNeedCalculatePageOffsets = false;
}
/**
* This is the persistent state that is saved by ViewPager. Only needed
* if you are creating a sublass of ViewPager that must save its own
* state, in which case it should implement a subclass of this which
* contains that state.
*/
public static class SavedState extends BaseSavedState {
int position;
Parcelable adapterState;
ClassLoader loader;
public SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(position);
out.writeParcelable(adapterState, flags);
}
@Override
public String toString() {
return "FragmentPager.SavedState{"
+ Integer.toHexString(System.identityHashCode(this))
+ " position=" + position + "}";
}
public static final Creator<SavedState> CREATOR
= ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in, ClassLoader loader) {
return new SavedState(in, loader);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
});
SavedState(Parcel in, ClassLoader loader) {
super(in);
if (loader == null) {
loader = getClass().getClassLoader();
}
position = in.readInt();
adapterState = in.readParcelable(loader);
this.loader = loader;
}
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
ss.position = mCurItem;
if (mAdapter != null) {
ss.adapterState = mAdapter.saveState();
}
return ss;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
if (mAdapter != null) {
mAdapter.restoreState(ss.adapterState, ss.loader);
setCurrentItemInternal(ss.position, false, true);
} else {
mRestoredCurItem = ss.position;
mRestoredAdapterState = ss.adapterState;
mRestoredClassLoader = ss.loader;
}
}
@Override
public void addView(View child, int index, ViewGroup.LayoutParams params) {
if (!checkLayoutParams(params)) {
params = generateLayoutParams(params);
}
final LayoutParams lp = (LayoutParams) params;
lp.isDecor |= child instanceof Decor;
if (mInLayout) {
if (lp != null && lp.isDecor) {
throw new IllegalStateException("Cannot add pager decor view during layout");
}
lp.needsMeasure = true;
addViewInLayout(child, index, params);
} else {
super.addView(child, index, params);
}
if (USE_CACHE) {
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabled(mScrollingCacheEnabled);
} else {
child.setDrawingCacheEnabled(false);
}
}
}
@Override
public void removeView(View view) {
if (mInLayout) {
removeViewInLayout(view);
} else {
super.removeView(view);
}
}
ItemInfo infoForChild(View child) {
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (mAdapter.isViewFromObject(child, ii.object)) {
return ii;
}
}
return null;
}
ItemInfo infoForAnyChild(View child) {
ViewParent parent;
while ((parent = child.getParent()) != this) {
if (parent == null || !(parent instanceof View)) {
return null;
}
child = (View) parent;
}
return infoForChild(child);
}
ItemInfo infoForPosition(int position) {
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (ii.position == position) {
return ii;
}
}
return null;
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
mFirstLayout = true;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// For simple implementation, our internal size is always 0.
// We depend on the container to specify the layout size of
// our view. We can't really know what it is since we will be
// adding and removing different arbitrary views and do not
// want the layout to change as this happens.
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec),
getDefaultSize(0, heightMeasureSpec));
final int measuredHeight = getMeasuredHeight();
final int maxGutterSize = measuredHeight / 10;
mGutterSize = Math.min(maxGutterSize, mDefaultGutterSize);
// Children are just made to fill our space.
int childWidthSize = getMeasuredWidth() - getPaddingLeft() - getPaddingRight();
int childHeightSize = measuredHeight - getPaddingTop() - getPaddingBottom();
/*
* Make sure all children have been properly measured. Decor views first.
* Right now we cheat and make this less complicated by assuming decor
* views won't intersect. We will pin to edges based on gravity.
*/
int size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (lp != null && lp.isDecor) {
final int hgrav = lp.gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
int widthMode = MeasureSpec.AT_MOST;
int heightMode = MeasureSpec.AT_MOST;
boolean consumeVertical = vgrav == Gravity.TOP || vgrav == Gravity.BOTTOM;
boolean consumeHorizontal = hgrav == Gravity.LEFT || hgrav == Gravity.RIGHT;
if (consumeVertical) {
widthMode = MeasureSpec.EXACTLY;
} else if (consumeHorizontal) {
heightMode = MeasureSpec.EXACTLY;
}
int widthSize = childWidthSize;
int heightSize = childHeightSize;
if (lp.width != LayoutParams.WRAP_CONTENT) {
widthMode = MeasureSpec.EXACTLY;
if (lp.width != LayoutParams.FILL_PARENT) {
widthSize = lp.width;
}
}
if (lp.height != LayoutParams.WRAP_CONTENT) {
heightMode = MeasureSpec.EXACTLY;
if (lp.height != LayoutParams.FILL_PARENT) {
heightSize = lp.height;
}
}
final int widthSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
final int heightSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
child.measure(widthSpec, heightSpec);
if (consumeVertical) {
childHeightSize -= child.getMeasuredHeight();
} else if (consumeHorizontal) {
childWidthSize -= child.getMeasuredWidth();
}
}
}
}
mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(childWidthSize, MeasureSpec.EXACTLY);
mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(childHeightSize, MeasureSpec.EXACTLY);
// Make sure we have created all fragments that we need to have shown.
mInLayout = true;
populate();
mInLayout = false;
// Page views next.
size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
if (DEBUG) Log.v(TAG, "Measuring #" + i + " " + child
+ ": " + mChildWidthMeasureSpec);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (lp != null || !lp.isDecor) {
final int heightSpec = MeasureSpec.makeMeasureSpec(
(int) (childHeightSize * lp.heightFactor), MeasureSpec.EXACTLY);
child.measure(mChildWidthMeasureSpec, heightSpec);
}
}
}
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
// Make sure scroll position is set correctly.
if (h != oldh) {
recomputeScrollPosition(h, oldh, mPageMargin, mPageMargin);
}
}
private void recomputeScrollPosition(int height, int oldHeight, int margin, int oldMargin) {
if (oldHeight > 0 && !mItems.isEmpty()) {
final int heightWithMargin = height - getPaddingTop() - getPaddingBottom() + margin;
final int oldHeightWithMargin = oldHeight - getPaddingTop() - getPaddingBottom()
+ oldMargin;
final int ypos = getScrollY();
final float pageOffset = (float) ypos / oldHeightWithMargin;
final int newOffsetPixels = (int) (pageOffset * heightWithMargin);
scrollTo(getScrollX(), newOffsetPixels);
if (!mScroller.isFinished()) {
// We now return to your regularly scheduled scroll, already in progress.
final int newDuration = mScroller.getDuration() - mScroller.timePassed();
ItemInfo targetInfo = infoForPosition(mCurItem);
mScroller.startScroll(0, newOffsetPixels,
0, (int) (targetInfo.offset * height), newDuration);
}
} else {
final ItemInfo ii = infoForPosition(mCurItem);
final float scrollOffset = ii != null ? Math.min(ii.offset, mLastOffset) : 0;
final int scrollPos = (int) (scrollOffset *
(height - getPaddingTop() - getPaddingBottom()));
if (scrollPos != getScrollY()) {
completeScroll(false);
scrollTo(getScrollX(), scrollPos);
}
}
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
final int count = getChildCount();
int width = r - l;
int height = b - t;
int paddingLeft = getPaddingLeft();
int paddingTop = getPaddingTop();
int paddingRight = getPaddingRight();
int paddingBottom = getPaddingBottom();
final int scrollY = getScrollY();
int decorCount = 0;
// First pass - decor views. We need to do this in two passes so that
// we have the proper offsets for non-decor views later.
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
int childLeft = 0;
int childTop = 0;
if (lp.isDecor) {
final int hgrav = lp.gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
switch (hgrav) {
default:
childLeft = paddingLeft;
break;
case Gravity.LEFT:
childLeft = paddingLeft;
paddingLeft += child.getMeasuredWidth();
break;
case Gravity.CENTER_HORIZONTAL:
childLeft = Math.max((width - child.getMeasuredWidth()) / 2,
paddingLeft);
break;
case Gravity.RIGHT:
childLeft = width - paddingRight - child.getMeasuredWidth();
paddingRight += child.getMeasuredWidth();
break;
}
switch (vgrav) {
default:
childTop = paddingTop;
break;
case Gravity.TOP:
childTop = paddingTop;
paddingTop += child.getMeasuredHeight();
break;
case Gravity.CENTER_VERTICAL:
childTop = Math.max((height - child.getMeasuredHeight()) / 2,
paddingTop);
break;
case Gravity.BOTTOM:
childTop = height - paddingBottom - child.getMeasuredHeight();
paddingBottom += child.getMeasuredHeight();
break;
}
childTop += scrollY;
child.layout(childLeft, childTop,
childLeft + child.getMeasuredWidth(),
childTop + child.getMeasuredHeight());
decorCount++;
}
}
}
final int childHeight = height - paddingTop - paddingBottom;
// Page views. Do this once we have the right padding offsets from above.
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
ItemInfo ii;
if (!lp.isDecor && (ii = infoForChild(child)) != null) {
int toff = (int) (childHeight * ii.offset);
int childLeft = paddingLeft;
int childTop = paddingTop + toff;
if (lp.needsMeasure) {
// This was added during layout and needs measurement.
// Do it now that we know what we're working with.
lp.needsMeasure = false;
final int widthSpec = MeasureSpec.makeMeasureSpec(
(int) (width - paddingLeft - paddingRight),
MeasureSpec.EXACTLY);
final int heightSpec = MeasureSpec.makeMeasureSpec(
(int) (childHeight * lp.heightFactor),
MeasureSpec.EXACTLY);
child.measure(widthSpec, heightSpec);
}
if (DEBUG) Log.v(TAG, "Positioning #" + i + " " + child + " f=" + ii.object
+ ":" + childLeft + "," + childTop + " " + child.getMeasuredWidth()
+ "x" + child.getMeasuredHeight());
child.layout(childLeft, childTop,
childLeft + child.getMeasuredWidth(),
childTop + child.getMeasuredHeight());
}
}
}
mLeftPageBounds = paddingLeft;
mRightPageBounds = width - paddingRight;
mDecorChildCount = decorCount;
if (mFirstLayout) {
scrollToItem(mCurItem, false, 0, false);
}
mFirstLayout = false;
}
@Override
public void computeScroll() {
if (!mScroller.isFinished() && mScroller.computeScrollOffset()) {
int oldX = getScrollX();
int oldY = getScrollY();
int x = mScroller.getCurrX();
int y = mScroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
if (!pageScrolled(y)) {
mScroller.abortAnimation();
scrollTo(x, 0);
}
}
// Keep on drawing until the animation has finished.
ViewCompat.postInvalidateOnAnimation(this);
return;
}
// Done with scroll, clean up state.
completeScroll(true);
}
private boolean pageScrolled(int ypos) {
if (mItems.size() == 0) {
mCalledSuper = false;
onPageScrolled(0, 0, 0);
if (!mCalledSuper) {
throw new IllegalStateException(
"onPageScrolled did not call superclass implementation");
}
return false;
}
final ItemInfo ii = infoForCurrentScrollPosition();
final int height = getClientHeight();
final int heightWithMargin = height + mPageMargin;
final float marginOffset = (float) mPageMargin / height;
final int currentPage = ii.position;
final float pageOffset = (((float) ypos / height) - ii.offset) /
(ii.heightFactor + marginOffset);
final int offsetPixels = (int) (pageOffset * heightWithMargin);
mCalledSuper = false;
onPageScrolled(currentPage, pageOffset, offsetPixels);
if (!mCalledSuper) {
throw new IllegalStateException(
"onPageScrolled did not call superclass implementation");
}
return true;
}
/**
* This method will be invoked when the current page is scrolled, either as part
* of a programmatically initiated smooth scroll or a user initiated touch scroll.
* If you override this method you must call through to the superclass implementation
* (e.g. super.onPageScrolled(position, offset, offsetPixels)) before onPageScrolled
* returns.
*
* @param position Position index of the first page currently being displayed.
* Page position+1 will be visible if positionOffset is nonzero.
* @param offset Value from [0, 1) indicating the offset from the page at position.
* @param offsetPixels Value in pixels indicating the offset from position.
*/
protected void onPageScrolled(int position, float offset, int offsetPixels) {
// Offset any decor views if needed - keep them on-screen at all times.
if (mDecorChildCount > 0) {
final int scrollY = getScrollY();
int paddingTop = getPaddingTop();
int paddingBottom = getPaddingBottom();
final int height = getHeight();
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) continue;
final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
int childTop = 0;
switch (vgrav) {
default:
childTop = paddingTop;
break;
case Gravity.TOP:
childTop = paddingTop;
paddingTop += child.getHeight();
break;
case Gravity.CENTER_VERTICAL:
childTop = Math.max((height - child.getMeasuredHeight()) / 2,
paddingTop);
break;
case Gravity.BOTTOM:
childTop = height - paddingBottom - child.getMeasuredHeight();
paddingBottom += child.getMeasuredHeight();
break;
}
childTop += scrollY;
final int childOffset = childTop - child.getTop();
if (childOffset != 0) {
child.offsetTopAndBottom(childOffset);
}
}
}
if (mOnPageChangeListener != null) {
mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);
}
if (mInternalPageChangeListener != null) {
mInternalPageChangeListener.onPageScrolled(position, offset, offsetPixels);
}
if (mPageTransformer != null) {
final int scrollY = getScrollY();
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (lp.isDecor) continue;
final float transformPos = (float) (child.getTop() - scrollY) / getClientHeight();
mPageTransformer.transformPage(child, transformPos);
}
}
mCalledSuper = true;
}
private void completeScroll(boolean postEvents) {
boolean needPopulate = mScrollState == SCROLL_STATE_SETTLING;
if (needPopulate) {
// Done with scroll, no longer want to cache view drawing.
setScrollingCacheEnabled(false);
mScroller.abortAnimation();
int oldX = getScrollX();
int oldY = getScrollY();
int x = mScroller.getCurrX();
int y = mScroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
}
}
mPopulatePending = false;
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (ii.scrolling) {
needPopulate = true;
ii.scrolling = false;
}
}
if (needPopulate) {
if (postEvents) {
ViewCompat.postOnAnimation(this, mEndScrollRunnable);
} else {
mEndScrollRunnable.run();
}
}
}
private boolean isGutterDrag(float y, float dy) {
return (y < mGutterSize && dy > 0) || (y > getHeight() - mGutterSize && dy < 0);
}
private void enableLayers(boolean enable) {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final int layerType = enable ?
ViewCompat.LAYER_TYPE_HARDWARE : ViewCompat.LAYER_TYPE_NONE;
ViewCompat.setLayerType(getChildAt(i), layerType, null);
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
/*
* This method JUST determines whether we want to intercept the motion.
* If we return true, onMotionEvent will be called and we do the actual
* scrolling there.
*/
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
// Always take care of the touch gesture being complete.
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
// Release the drag.
if (DEBUG) Log.v(TAG, "Intercept done!");
mIsBeingDragged = false;
mIsUnableToDrag = false;
mActivePointerId = INVALID_POINTER;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
return false;
}
// Nothing more to do here if we have decided whether or not we
// are dragging.
if (action != MotionEvent.ACTION_DOWN) {
if (mIsBeingDragged) {
if (DEBUG) Log.v(TAG, "Intercept returning true!");
return true;
}
if (mIsUnableToDrag) {
if (DEBUG) Log.v(TAG, "Intercept returning false!");
return false;
}
}
switch (action) {
case MotionEvent.ACTION_MOVE: {
/*
* mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
* whether the user has moved far enough from his original down touch.
*/
/*
* Locally do absolute value. mLastMotionY is set to the y value
* of the down event.
*/
final int activePointerId = mActivePointerId;
if (activePointerId == INVALID_POINTER) {
// If we don't have a valid id, the touch down wasn't on content.
break;
}
final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float dy = y - mLastMotionY;
final float yDiff = Math.abs(dy);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float xDiff = Math.abs(x - mInitialMotionX);
if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
if (dy != 0 && !isGutterDrag(mLastMotionY, dy) &&
canScroll(this, false, (int) dy, (int) x, (int) y)) {
// Nested view has scrollable area under this point. Let it be handled there.
mLastMotionX = x;
mLastMotionY = y;
mIsUnableToDrag = true;
return false;
}
if (yDiff > mTouchSlop && yDiff * 0.5f > xDiff) {
if (DEBUG) Log.v(TAG, "Starting drag!");
mIsBeingDragged = true;
requestParentDisallowInterceptTouchEvent(true);
setScrollState(SCROLL_STATE_DRAGGING);
mLastMotionY = dy > 0 ? mInitialMotionY + mTouchSlop :
mInitialMotionY - mTouchSlop;
mLastMotionX = x;
setScrollingCacheEnabled(true);
} else if (xDiff > mTouchSlop) {
// The finger has moved enough in the vertical
// direction to be counted as a drag... abort
// any attempt to drag horizontally, to work correctly
// with children that have scrolling containers.
if (DEBUG) Log.v(TAG, "Starting unable to drag!");
mIsUnableToDrag = true;
}
if (mIsBeingDragged) {
// Scroll to follow the motion event
if (performDrag(y)) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
break;
}
case MotionEvent.ACTION_DOWN: {
/*
* Remember location of down touch.
* ACTION_DOWN always refers to pointer index 0.
*/
mLastMotionX = mInitialMotionX = ev.getX();
mLastMotionY = mInitialMotionY = ev.getY();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
mIsUnableToDrag = false;
mScroller.computeScrollOffset();
if (mScrollState == SCROLL_STATE_SETTLING &&
Math.abs(mScroller.getFinalY() - mScroller.getCurrY()) > mCloseEnough) {
// Let the user 'catch' the pager as it animates.
mScroller.abortAnimation();
mPopulatePending = false;
populate();
mIsBeingDragged = true;
requestParentDisallowInterceptTouchEvent(true);
setScrollState(SCROLL_STATE_DRAGGING);
} else {
completeScroll(false);
mIsBeingDragged = false;
}
if (DEBUG) Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY
+ " mIsBeingDragged=" + mIsBeingDragged
+ "mIsUnableToDrag=" + mIsUnableToDrag);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
break;
}
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
/*
* The only time we want to intercept motion events is if we are in the
* drag mode.
*/
return mIsBeingDragged;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
if (mFakeDragging) {
// A fake drag is in progress already, ignore this real one
// but still eat the touch events.
// (It is likely that the user is multi-touching the screen.)
return true;
}
if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
// Don't handle edge touches immediately -- they may actually belong to one of our
// descendants.
return false;
}
if (mAdapter == null || mAdapter.getCount() == 0) {
// Nothing to present or scroll; nothing to touch.
return false;
}
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
final int action = ev.getAction();
boolean needsInvalidate = false;
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
mScroller.abortAnimation();
mPopulatePending = false;
populate();
// Remember where the motion event started
mLastMotionX = mInitialMotionX = ev.getX();
mLastMotionY = mInitialMotionY = ev.getY();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
break;
}
case MotionEvent.ACTION_MOVE:
if (!mIsBeingDragged) {
final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float yDiff = Math.abs(y - mLastMotionY);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float xDiff = Math.abs(x - mLastMotionX);
if (DEBUG)
Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
if (yDiff > mTouchSlop && yDiff > xDiff) {
if (DEBUG) Log.v(TAG, "Starting drag!");
mIsBeingDragged = true;
requestParentDisallowInterceptTouchEvent(true);
mLastMotionY = y - mInitialMotionY > 0 ? mInitialMotionY + mTouchSlop :
mInitialMotionY - mTouchSlop;
mLastMotionX = x;
setScrollState(SCROLL_STATE_DRAGGING);
setScrollingCacheEnabled(true);
// Disallow Parent Intercept, just in case
ViewParent parent = getParent();
if (parent != null) {
parent.requestDisallowInterceptTouchEvent(true);
}
}
}
// Not else! Note that mIsBeingDragged can be set above.
if (mIsBeingDragged) {
// Scroll to follow the motion event
final int activePointerIndex = MotionEventCompat.findPointerIndex(
ev, mActivePointerId);
final float y = MotionEventCompat.getY(ev, activePointerIndex);
needsInvalidate |= performDrag(y);
}
break;
case MotionEvent.ACTION_UP:
if (mIsBeingDragged) {
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(
velocityTracker, mActivePointerId);
mPopulatePending = true;
final int height = getClientHeight();
final int scrollY = getScrollY();
final ItemInfo ii = infoForCurrentScrollPosition();
final int currentPage = ii.position;
final float pageOffset = (((float) scrollY / height) - ii.offset) / ii.heightFactor;
final int activePointerIndex =
MotionEventCompat.findPointerIndex(ev, mActivePointerId);
final float y = MotionEventCompat.getY(ev, activePointerIndex);
final int totalDelta = (int) (y - mInitialMotionY);
int nextPage = determineTargetPage(currentPage, pageOffset, initialVelocity,
totalDelta);
setCurrentItemInternal(nextPage, true, true, initialVelocity);
mActivePointerId = INVALID_POINTER;
endDrag();
needsInvalidate = mTopEdge.onRelease() | mBottomEdge.onRelease();
}
break;
case MotionEvent.ACTION_CANCEL:
if (mIsBeingDragged) {
scrollToItem(mCurItem, true, 0, false);
mActivePointerId = INVALID_POINTER;
endDrag();
needsInvalidate = mTopEdge.onRelease() | mBottomEdge.onRelease();
}
break;
case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
final float y = MotionEventCompat.getY(ev, index);
mLastMotionY = y;
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
mLastMotionY = MotionEventCompat.getY(ev,
MotionEventCompat.findPointerIndex(ev, mActivePointerId));
break;
}
if (needsInvalidate) {
ViewCompat.postInvalidateOnAnimation(this);
}
return true;
}
private void requestParentDisallowInterceptTouchEvent(boolean disallowIntercept) {
final ViewParent parent = getParent();
if (parent != null) {
parent.requestDisallowInterceptTouchEvent(disallowIntercept);
}
}
private boolean performDrag(float y) {
boolean needsInvalidate = false;
final float deltaY = mLastMotionY - y;
mLastMotionY = y;
float oldScrollY = getScrollY();
float scrollY = oldScrollY + deltaY;
final int height = getClientHeight();
float topBound = height * mFirstOffset;
float bottomBound = height * mLastOffset;
boolean topAbsolute = true;
boolean bottomAbsolute = true;
final ItemInfo firstItem = mItems.get(0);
final ItemInfo lastItem = mItems.get(mItems.size() - 1);
if (firstItem.position != 0) {
topAbsolute = false;
topBound = firstItem.offset * height;
}
if (lastItem.position != mAdapter.getCount() - 1) {
bottomAbsolute = false;
bottomBound = lastItem.offset * height;
}
if (scrollY < topBound) {
if (topAbsolute) {
float over = topBound - scrollY;
needsInvalidate = mTopEdge.onPull(Math.abs(over) / height);
}
scrollY = topBound;
} else if (scrollY > bottomBound) {
if (bottomAbsolute) {
float over = scrollY - bottomBound;
needsInvalidate = mBottomEdge.onPull(Math.abs(over) / height);
}
scrollY = bottomBound;
}
// Don't lose the rounded component
mLastMotionX += scrollY - (int) scrollY;
scrollTo(getScrollX(), (int) scrollY);
pageScrolled((int) scrollY);
return needsInvalidate;
}
/**
* @return Info about the page at the current scroll position.
* This can be synthetic for a missing middle page; the 'object' field can be null.
*/
private ItemInfo infoForCurrentScrollPosition() {
final int height = getClientHeight();
final float scrollOffset = height > 0 ? (float) getScrollY() / height : 0;
final float marginOffset = height > 0 ? (float) mPageMargin / height : 0;
int lastPos = -1;
float lastOffset = 0.f;
float lastHeight = 0.f;
boolean first = true;
ItemInfo lastItem = null;
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
float offset;
if (!first && ii.position != lastPos + 1) {
// Create a synthetic item for a missing page.
ii = mTempItem;
ii.offset = lastOffset + lastHeight + marginOffset;
ii.position = lastPos + 1;
ii.heightFactor = mAdapter.getPageWidth(ii.position);
i--;
}
offset = ii.offset;
final float topBound = offset;
final float bottomBound = offset + ii.heightFactor + marginOffset;
if (first || scrollOffset >= topBound) {
if (scrollOffset < bottomBound || i == mItems.size() - 1) {
return ii;
}
} else {
return lastItem;
}
first = false;
lastPos = ii.position;
lastOffset = offset;
lastHeight = ii.heightFactor;
lastItem = ii;
}
return lastItem;
}
private int determineTargetPage(int currentPage, float pageOffset, int velocity, int deltaY) {
int targetPage;
if (Math.abs(deltaY) > mFlingDistance && Math.abs(velocity) > mMinimumVelocity) {
targetPage = velocity > 0 ? currentPage : currentPage + 1;
} else {
final float truncator = currentPage >= mCurItem ? 0.4f : 0.6f;
targetPage = (int) (currentPage + pageOffset + truncator);
}
if (mItems.size() > 0) {
final ItemInfo firstItem = mItems.get(0);
final ItemInfo lastItem = mItems.get(mItems.size() - 1);
// Only let the user target pages we have items for
targetPage = Math.max(firstItem.position, Math.min(targetPage, lastItem.position));
}
return targetPage;
}
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
boolean needsInvalidate = false;
final int overScrollMode = ViewCompat.getOverScrollMode(this);
if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS ||
(overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS &&
mAdapter != null && mAdapter.getCount() > 1)) {
if (!mTopEdge.isFinished()) {
final int restoreCount = canvas.save();
final int height = getHeight();
final int width = getWidth() - getPaddingLeft() - getPaddingRight();
canvas.translate(getPaddingLeft(), mFirstOffset * height);
mTopEdge.setSize(width, height);
needsInvalidate |= mTopEdge.draw(canvas);
canvas.restoreToCount(restoreCount);
}
if (!mBottomEdge.isFinished()) {
final int restoreCount = canvas.save();
final int height = getHeight();
final int width = getWidth() - getPaddingLeft() - getPaddingRight();
canvas.rotate(180);
canvas.translate(-width - getPaddingLeft(), -(mLastOffset + 1) * height);
mBottomEdge.setSize(width, height);
needsInvalidate |= mBottomEdge.draw(canvas);
canvas.restoreToCount(restoreCount);
}
} else {
mTopEdge.finish();
mBottomEdge.finish();
}
if (needsInvalidate) {
// Keep animating
ViewCompat.postInvalidateOnAnimation(this);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
// Draw the margin drawable between pages if needed.
if (mPageMargin > 0 && mMarginDrawable != null && mItems.size() > 0 && mAdapter != null) {
final int scrollY = getScrollY();
final int height = getHeight();
final float marginOffset = (float) mPageMargin / height;
int itemIndex = 0;
ItemInfo ii = mItems.get(0);
float offset = ii.offset;
final int itemCount = mItems.size();
final int firstPos = ii.position;
final int lastPos = mItems.get(itemCount - 1).position;
for (int pos = firstPos; pos < lastPos; pos++) {
while (pos > ii.position && itemIndex < itemCount) {
ii = mItems.get(++itemIndex);
}
float drawAt;
if (pos == ii.position) {
drawAt = (ii.offset + ii.heightFactor) * height;
offset = ii.offset + ii.heightFactor + marginOffset;
} else {
float heightFactor = mAdapter.getPageWidth(pos);
drawAt = (offset + heightFactor) * height;
offset += heightFactor + marginOffset;
}
if (drawAt + mPageMargin > scrollY) {
mMarginDrawable.setBounds(mLeftPageBounds, (int) drawAt,
mRightPageBounds, (int) (drawAt + mPageMargin + 0.5f));
mMarginDrawable.draw(canvas);
}
if (drawAt > scrollY + height) {
break; // No more visible, no sense in continuing
}
}
}
}
/**
* Start a fake drag of the pager.
* <p/>
* <p>A fake drag can be useful if you want to synchronize the motion of the ViewPager
* with the touch scrolling of another view, while still letting the ViewPager
* control the snapping motion and fling behavior. (e.g. parallax-scrolling tabs.)
* Call {@link #fakeDragBy(float)} to simulate the actual drag motion. Call
* {@link #endFakeDrag()} to complete the fake drag and fling as necessary.
* <p/>
* <p>During a fake drag the ViewPager will ignore all touch events. If a real drag
* is already in progress, this method will return false.
*
* @return true if the fake drag began successfully, false if it could not be started.
* @see #fakeDragBy(float)
* @see #endFakeDrag()
*/
public boolean beginFakeDrag() {
if (mIsBeingDragged) {
return false;
}
mFakeDragging = true;
setScrollState(SCROLL_STATE_DRAGGING);
mInitialMotionY = mLastMotionY = 0;
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
} else {
mVelocityTracker.clear();
}
final long time = SystemClock.uptimeMillis();
final MotionEvent ev = MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN, 0, 0, 0);
mVelocityTracker.addMovement(ev);
ev.recycle();
mFakeDragBeginTime = time;
return true;
}
/**
* End a fake drag of the pager.
*
* @see #beginFakeDrag()
* @see #fakeDragBy(float)
*/
public void endFakeDrag() {
if (!mFakeDragging) {
throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first.");
}
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(
velocityTracker, mActivePointerId);
mPopulatePending = true;
final int height = getClientHeight();
final int scrollY = getScrollY();
final ItemInfo ii = infoForCurrentScrollPosition();
final int currentPage = ii.position;
final float pageOffset = (((float) scrollY / height) - ii.offset) / ii.heightFactor;
final int totalDelta = (int) (mLastMotionY - mInitialMotionY);
int nextPage = determineTargetPage(currentPage, pageOffset, initialVelocity,
totalDelta);
setCurrentItemInternal(nextPage, true, true, initialVelocity);
endDrag();
mFakeDragging = false;
}
/**
* Fake drag by an offset in pixels. You must have called {@link #beginFakeDrag()} first.
*
* @param yOffset Offset in pixels to drag by.
* @see #beginFakeDrag()
* @see #endFakeDrag()
*/
public void fakeDragBy(float yOffset) {
if (!mFakeDragging) {
throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first.");
}
mLastMotionY += yOffset;
float oldScrollY = getScrollY();
float scrollY = oldScrollY - yOffset;
final int height = getClientHeight();
float topBound = height * mFirstOffset;
float bottomBound = height * mLastOffset;
final ItemInfo firstItem = mItems.get(0);
final ItemInfo lastItem = mItems.get(mItems.size() - 1);
if (firstItem.position != 0) {
topBound = firstItem.offset * height;
}
if (lastItem.position != mAdapter.getCount() - 1) {
bottomBound = lastItem.offset * height;
}
if (scrollY < topBound) {
scrollY = topBound;
} else if (scrollY > bottomBound) {
scrollY = bottomBound;
}
// Don't lose the rounded component
mLastMotionY += scrollY - (int) scrollY;
scrollTo(getScrollX(), (int) scrollY);
pageScrolled((int) scrollY);
// Synthesize an event for the VelocityTracker.
final long time = SystemClock.uptimeMillis();
final MotionEvent ev = MotionEvent.obtain(mFakeDragBeginTime, time, MotionEvent.ACTION_MOVE,
0, mLastMotionY, 0);
mVelocityTracker.addMovement(ev);
ev.recycle();
}
/**
* Returns true if a fake drag is in progress.
*
* @return true if currently in a fake drag, false otherwise.
* @see #beginFakeDrag()
* @see #fakeDragBy(float)
* @see #endFakeDrag()
*/
public boolean isFakeDragging() {
return mFakeDragging;
}
private void onSecondaryPointerUp(MotionEvent ev) {
final int pointerIndex = MotionEventCompat.getActionIndex(ev);
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
if (pointerId == mActivePointerId) {
// This was our active pointer going up. Choose a new
// active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mLastMotionY = MotionEventCompat.getY(ev, newPointerIndex);
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
}
}
private void endDrag() {
mIsBeingDragged = false;
mIsUnableToDrag = false;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
}
private void setScrollingCacheEnabled(boolean enabled) {
if (mScrollingCacheEnabled != enabled) {
mScrollingCacheEnabled = enabled;
if (USE_CACHE) {
final int size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabled(enabled);
}
}
}
}
}
public boolean internalCanScrollVertically(int direction) {
if (mAdapter == null) {
return false;
}
final int height = getClientHeight();
final int scrollY = getScrollY();
if (direction < 0) {
return (scrollY > (int) (height * mFirstOffset));
} else if (direction > 0) {
return (scrollY < (int) (height * mLastOffset));
} else {
return false;
}
}
/**
* Tests scrollability within child views of v given a delta of dx.
*
* @param v View to test for horizontal scrollability
* @param checkV Whether the view v passed should itself be checked for scrollability (true),
* or just its children (false).
* @param dy Delta scrolled in pixels
* @param x X coordinate of the active touch point
* @param y Y coordinate of the active touch point
* @return true if child views of v can be scrolled by delta of dx.
*/
protected boolean canScroll(View v, boolean checkV, int dy, int x, int y) {
if (v instanceof ViewGroup) {
final ViewGroup group = (ViewGroup) v;
final int scrollX = v.getScrollX();
final int scrollY = v.getScrollY();
final int count = group.getChildCount();
// Count backwards - let topmost views consume scroll distance first.
for (int i = count - 1; i >= 0; i--) {
// TODO: Add versioned support here for transformed views.
// This will not work for transformed views in Honeycomb+
final View child = group.getChildAt(i);
if (y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&
x + scrollX >= child.getLeft() && x + scrollX < child.getRight() &&
canScroll(child, true, dy, x + scrollX - child.getLeft(),
y + scrollY - child.getTop())) {
return true;
}
}
}
return checkV && ViewCompat.canScrollVertically(v, -dy);
}
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
// Let the focused view and/or our descendants get the key first
return super.dispatchKeyEvent(event) || executeKeyEvent(event);
}
/**
* You can call this function yourself to have the scroll view perform
* scrolling from a key event, just as if the event had been dispatched to
* it by the view hierarchy.
*
* @param event The key event to execute.
* @return Return true if the event was handled, else false.
*/
public boolean executeKeyEvent(KeyEvent event) {
boolean handled = false;
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_LEFT:
handled = arrowScroll(FOCUS_LEFT);
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
handled = arrowScroll(FOCUS_RIGHT);
break;
case KeyEvent.KEYCODE_TAB:
if (Build.VERSION.SDK_INT >= 11) {
if (event.hasNoModifiers()) {
handled = this.arrowScroll(2);
} else if (event.hasModifiers(1)) {
handled = this.arrowScroll(1);
}
}
break;
}
}
return handled;
}
public boolean arrowScroll(int direction) {
View currentFocused = findFocus();
if (currentFocused == this) {
currentFocused = null;
} else if (currentFocused != null) {
boolean isChild = false;
for (ViewParent parent = currentFocused.getParent(); parent instanceof ViewGroup;
parent = parent.getParent()) {
if (parent == this) {
isChild = true;
break;
}
}
if (!isChild) {
// This would cause the focus search down below to fail in fun ways.
final StringBuilder sb = new StringBuilder();
sb.append(currentFocused.getClass().getSimpleName());
for (ViewParent parent = currentFocused.getParent(); parent instanceof ViewGroup;
parent = parent.getParent()) {
sb.append(" => ").append(parent.getClass().getSimpleName());
}
Log.e(TAG, "arrowScroll tried to find focus based on non-child " +
"current focused view " + sb.toString());
currentFocused = null;
}
}
boolean handled = false;
View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused,
direction);
if (nextFocused != null && nextFocused != currentFocused) {
if (direction == View.FOCUS_UP) {
// If there is nothing to the left, or this is causing us to
// jump to the right, then what we really want to do is page left.
final int nextTop = getChildRectInPagerCoordinates(mTempRect, nextFocused).top;
final int currTop = getChildRectInPagerCoordinates(mTempRect, currentFocused).top;
if (currentFocused != null && nextTop >= currTop) {
handled = pageUp();
} else {
handled = nextFocused.requestFocus();
}
} else if (direction == View.FOCUS_DOWN) {
// If there is nothing to the right, or this is causing us to
// jump to the left, then what we really want to do is page right.
final int nextDown = getChildRectInPagerCoordinates(mTempRect, nextFocused).bottom;
final int currDown = getChildRectInPagerCoordinates(mTempRect, currentFocused).bottom;
if (currentFocused != null && nextDown <= currDown) {
handled = pageDown();
} else {
handled = nextFocused.requestFocus();
}
}
} else if (direction == FOCUS_UP || direction == FOCUS_BACKWARD) {
// Trying to move left and nothing there; try to page.
handled = pageUp();
} else if (direction == FOCUS_DOWN || direction == FOCUS_FORWARD) {
// Trying to move right and nothing there; try to page.
handled = pageDown();
}
if (handled) {
playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));
}
return handled;
}
private Rect getChildRectInPagerCoordinates(Rect outRect, View child) {
if (outRect == null) {
outRect = new Rect();
}
if (child == null) {
outRect.set(0, 0, 0, 0);
return outRect;
}
outRect.left = child.getLeft();
outRect.right = child.getRight();
outRect.top = child.getTop();
outRect.bottom = child.getBottom();
ViewParent parent = child.getParent();
while (parent instanceof ViewGroup && parent != this) {
final ViewGroup group = (ViewGroup) parent;
outRect.left += group.getLeft();
outRect.right += group.getRight();
outRect.top += group.getTop();
outRect.bottom += group.getBottom();
parent = group.getParent();
}
return outRect;
}
boolean pageUp() {
if (mCurItem > 0) {
setCurrentItem(mCurItem - 1, true);
return true;
}
return false;
}
boolean pageDown() {
if (mAdapter != null && mCurItem < (mAdapter.getCount() - 1)) {
setCurrentItem(mCurItem + 1, true);
return true;
}
return false;
}
/**
* We only want the current page that is being shown to be focusable.
*/
@Override
public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
final int focusableCount = views.size();
final int descendantFocusability = getDescendantFocusability();
if (descendantFocusability != FOCUS_BLOCK_DESCENDANTS) {
for (int i = 0; i < getChildCount(); i++) {
final View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
child.addFocusables(views, direction, focusableMode);
}
}
}
}
// we add ourselves (if focusable) in all cases except for when we are
// FOCUS_AFTER_DESCENDANTS and there are some descendants focusable. this is
// to avoid the focus search finding layouts when a more precise search
// among the focusable children would be more interesting.
if (
descendantFocusability != FOCUS_AFTER_DESCENDANTS ||
// No focusable descendants
(focusableCount == views.size())) {
// Note that we can't call the superclass here, because it will
// add all views in. So we need to do the same thing View does.
if (!isFocusable()) {
return;
}
if ((focusableMode & FOCUSABLES_TOUCH_MODE) == FOCUSABLES_TOUCH_MODE &&
isInTouchMode() && !isFocusableInTouchMode()) {
return;
}
if (views != null) {
views.add(this);
}
}
}
/**
* We only want the current page that is being shown to be touchable.
*/
@Override
public void addTouchables(ArrayList<View> views) {
// Note that we don't call super.addTouchables(), which means that
// we don't call View.addTouchables(). This is okay because a ViewPager
// is itself not touchable.
for (int i = 0; i < getChildCount(); i++) {
final View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
child.addTouchables(views);
}
}
}
}
/**
* We only want the current page that is being shown to be focusable.
*/
@Override
protected boolean onRequestFocusInDescendants(int direction,
Rect previouslyFocusedRect) {
int index;
int increment;
int end;
int count = getChildCount();
if ((direction & FOCUS_FORWARD) != 0) {
index = 0;
increment = 1;
end = count;
} else {
index = count - 1;
increment = -1;
end = -1;
}
for (int i = index; i != end; i += increment) {
View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
if (child.requestFocus(direction, previouslyFocusedRect)) {
return true;
}
}
}
}
return false;
}
@SuppressLint("WrongConstant")
@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
// Dispatch scroll events from this ViewPager.
if (event.getEventType() == TYPE_VIEW_SCROLLED) {
return super.dispatchPopulateAccessibilityEvent(event);
}
// Dispatch all other accessibility events from the current page.
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
final ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem &&
child.dispatchPopulateAccessibilityEvent(event)) {
return true;
}
}
}
return false;
}
@Override
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
return new LayoutParams();
}
@Override
protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
return generateDefaultLayoutParams();
}
@Override
protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
return p instanceof LayoutParams && super.checkLayoutParams(p);
}
@Override
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
return new LayoutParams(getContext(), attrs);
}
class MyAccessibilityDelegate extends AccessibilityDelegateCompat {
@Override
public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
super.onInitializeAccessibilityEvent(host, event);
event.setClassName(ViewPager.class.getName());
final AccessibilityRecordCompat recordCompat = AccessibilityRecordCompat.obtain();
recordCompat.setScrollable(canScroll());
if (event.getEventType() == TYPE_VIEW_SCROLLED
&& mAdapter != null) {
recordCompat.setItemCount(mAdapter.getCount());
recordCompat.setFromIndex(mCurItem);
recordCompat.setToIndex(mCurItem);
}
}
@Override
public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
super.onInitializeAccessibilityNodeInfo(host, info);
info.setClassName(ViewPager.class.getName());
info.setScrollable(canScroll());
if (internalCanScrollVertically(1)) {
info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD);
}
if (internalCanScrollVertically(-1)) {
info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD);
}
}
@Override
public boolean performAccessibilityAction(View host, int action, Bundle args) {
if (super.performAccessibilityAction(host, action, args)) {
return true;
}
switch (action) {
case AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD: {
if (internalCanScrollVertically(1)) {
setCurrentItem(mCurItem + 1);
return true;
}
}
return false;
case AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD: {
if (internalCanScrollVertically(-1)) {
setCurrentItem(mCurItem - 1);
return true;
}
}
return false;
}
return false;
}
private boolean canScroll() {
return (mAdapter != null) && (mAdapter.getCount() > 1);
}
}
private class PagerObserver extends DataSetObserver {
@Override
public void onChanged() {
dataSetChanged();
}
@Override
public void onInvalidated() {
dataSetChanged();
}
}
/**
* Layout parameters that should be supplied for views added to a
* ViewPager.
*/
public static class LayoutParams extends ViewGroup.LayoutParams {
/**
* true if this view is a decoration on the pager itself and not
* a view supplied by the adapter.
*/
public boolean isDecor;
/**
* Gravity setting for use on decor views only:
* Where to position the view page within the overall ViewPager
* container; constants are defined in {@link Gravity}.
*/
public int gravity;
/**
* Width as a 0-1 multiplier of the measured pager width
*/
float heightFactor = 0.f;
/**
* true if this view was added during layout and needs to be measured
* before being positioned.
*/
boolean needsMeasure;
/**
* Adapter position this view is for if !isDecor
*/
int position;
/**
* Current child index within the ViewPager that this view occupies
*/
int childIndex;
public LayoutParams() {
super(FILL_PARENT, FILL_PARENT);
}
public LayoutParams(Context context, AttributeSet attrs) {
super(context, attrs);
final TypedArray a = context.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
gravity = a.getInteger(0, Gravity.TOP);
a.recycle();
}
}
static class ViewPositionComparator implements Comparator<View> {
@Override
public int compare(View lhs, View rhs) {
final LayoutParams llp = (LayoutParams) lhs.getLayoutParams();
final LayoutParams rlp = (LayoutParams) rhs.getLayoutParams();
if (llp.isDecor != rlp.isDecor) {
return llp.isDecor ? 1 : -1;
}
return llp.position - rlp.position;
}
}
} | yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/recycler/OnPagerListener.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 com.yc.pagerlib.recycler;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/7/23
* desc : 自定义LinearLayoutManager
* revise:
* </pre>
*/
public interface OnPagerListener {
/**
* 初始化完成
*/
void onInitComplete();
/**
* 释放的监听
* @param isNext 是否下一个，true表示下一个，false表示上一个
* @param position 索引
*/
void onPageRelease(boolean isNext, int position);
/***
* 选中的监听以及判断是否滑动到底部
* @param position 索引
* @param isBottom 是否到了底部
*/
void onPageSelected(int position, boolean isBottom);
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/recycler/PagerLayoutManager.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 com.yc.pagerlib.recycler;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.RecyclerView;
import android.view.Gravity;
import android.view.View;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2019/7/23
* desc : 自定义LinearLayoutManager
* revise:
* </pre>
*/
public class PagerLayoutManager extends LinearLayoutManager {
private RecyclerView mRecyclerView;
private ScrollPageHelper mPagerSnapHelper;
private OnPagerListener mOnViewPagerListener;
private static final int HORIZONTAL = OrientationHelper.HORIZONTAL;
private static final int VERTICAL = OrientationHelper.VERTICAL;
private final int mOrientation;
/**
* 位移，用来判断移动方向
*/
private int mDrift;
public PagerLayoutManager(Context context, int orientation) {
super(context, orientation, false);
this.mOrientation = orientation;
init();
}
public PagerLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
this.mOrientation = orientation;
init();
}
/**
* 初始化操作
*/
private void init() {
switch (mOrientation){
case HORIZONTAL:
mPagerSnapHelper = new ScrollPageHelper(Gravity.START,false);
break;
case VERTICAL:
mPagerSnapHelper = new ScrollPageHelper(Gravity.TOP,false);
break;
default:
mPagerSnapHelper = new ScrollPageHelper(Gravity.TOP,false);
break;
}
}
/**
* attach到window窗口时，该方法必须调用
* @param recyclerView recyclerView
*/
@Override
public void onAttachedToWindow(RecyclerView recyclerView){
if (recyclerView == null) {
throw new IllegalArgumentException("The attach RecycleView must not null!!");
}
super.onAttachedToWindow(recyclerView);
this.mRecyclerView = recyclerView;
if (mPagerSnapHelper==null){
init();
}
try {
//attachToRecyclerView源码上的方法可能会抛出IllegalStateException异常，这里手动捕获一下
RecyclerView.OnFlingListener onFlingListener = mRecyclerView.getOnFlingListener();
//源码中判断了，如果onFlingListener已经存在的话，再次设置就直接抛出异常，那么这里可以判断一下
if (onFlingListener==null){
mPagerSnapHelper.attachToRecyclerView(mRecyclerView);
}
} catch (IllegalStateException e){
e.printStackTrace();
}
mRecyclerView.addOnChildAttachStateChangeListener(mChildAttachStateChangeListener);
}
/**
* 销毁的时候调用该方法，需要移除监听事件
* @param view view
* @param recycler recycler
*/
@Override
public void onDetachedFromWindow(RecyclerView view, RecyclerView.Recycler recycler) {
super.onDetachedFromWindow(view, recycler);
if (mRecyclerView!=null){
mRecyclerView.removeOnChildAttachStateChangeListener(mChildAttachStateChangeListener);
}
}
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
super.onLayoutChildren(recycler, state);
}
/**
* 滑动状态的改变
* 缓慢拖拽-> SCROLL_STATE_DRAGGING
* 快速滚动-> SCROLL_STATE_SETTLING
* 空闲状态-> SCROLL_STATE_IDLE
* @param state 状态
*/
@Override
public void onScrollStateChanged(int state) {
switch (state) {
case RecyclerView.SCROLL_STATE_IDLE:
View viewIdle = mPagerSnapHelper.findSnapView(this);
int positionIdle = 0;
if (viewIdle != null) {
positionIdle = getPosition(viewIdle);
}
int childCount = getChildCount();
if (mOnViewPagerListener != null && childCount == 1) {
mOnViewPagerListener.onPageSelected(positionIdle,
positionIdle == childCount - 1);
}
break;
case RecyclerView.SCROLL_STATE_DRAGGING:
View viewDrag = mPagerSnapHelper.findSnapView(this);
if (viewDrag != null) {
int positionDrag = getPosition(viewDrag);
}
break;
case RecyclerView.SCROLL_STATE_SETTLING:
View viewSettling = mPagerSnapHelper.findSnapView(this);
if (viewSettling != null) {
int positionSettling = getPosition(viewSettling);
}
break;
default:
break;
}
}
/**
* 监听竖直方向的相对偏移量
* @param dy y轴滚动值
* @param recycler recycler
* @param state state滚动状态
* @return int值
*/
@Override
public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
RecyclerView.State state) {
//需要判断子类的数量不能为0的情况
if (getChildCount() == 0 || dy == 0) {
return 0;
}
this.mDrift = dy;
return super.scrollVerticallyBy(dy, recycler, state);
}
/**
* 监听水平方向的相对偏移量
* @param dx x轴滚动值
* @param recycler recycler
* @param state state滚动状态
* @return int值
*/
@Override
public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (getChildCount() == 0 || dx == 0) {
return 0;
}
this.mDrift = dx;
return super.scrollHorizontallyBy(dx, recycler, state);
}
/**
* 设置监听
* @param listener listener
*/
public void setOnViewPagerListener(OnPagerListener listener){
this.mOnViewPagerListener = listener;
}
private final RecyclerView.OnChildAttachStateChangeListener mChildAttachStateChangeListener =
new RecyclerView.OnChildAttachStateChangeListener() {
/**
* 第一次进入界面的监听，可以做初始化方面的操作
* @param view view
*/
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
if (mOnViewPagerListener != null && getChildCount() == 1) {
mOnViewPagerListener.onInitComplete();
}
}
/**
* 页面销毁的时候调用该方法，可以做销毁方面的操作
* @param view view
*/
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
if (mDrift >= 0){
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(true , getPosition(view));
}
}else {
if (mOnViewPagerListener != null) {
mOnViewPagerListener.onPageRelease(false , getPosition(view));
}
}
}
};
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
PagerLib/src/main/java/com/yc/pagerlib/recycler/ScrollPageHelper.java | Java | /*
Copyright 2017 yangchong211（github.com/yangchong211）
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 com.yc.pagerlib.recycler;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.PagerSnapHelper;
import androidx.recyclerview.widget.RecyclerView;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.View;
import java.util.Locale;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/3/18
* desc : 自定义SnapHelper，设置左对齐，滑动时候会限制item只滑动一个。可以设置gravity位置对齐
* revise: 关于SnapHelper源码分析可以看我博客：https://blog.csdn.net/m0_37700275/article/details/83901677
* </pre>
*/
public class ScrollPageHelper extends PagerSnapHelper {
private OrientationHelper mHorizontalHelper, mVerticalHelper;
private final int gravity;
private final boolean snapLastItem;
private boolean isRtlHorizontal;
/**
* 构造方法
* @param gravity 位置
* @param enableSnapLast 最后一个是否按照位置对齐
*/
public ScrollPageHelper(int gravity, boolean enableSnapLast){
this.snapLastItem = enableSnapLast;
this.gravity = gravity;
}
/**
* 这个方法是与recyclerView绑定
* @param recyclerView recyclerView
* @throws IllegalStateException
*/
@Override
public void attachToRecyclerView(@Nullable RecyclerView recyclerView)
throws IllegalStateException {
if (recyclerView != null && !(recyclerView.getLayoutManager()
instanceof LinearLayoutManager)) {
throw new IllegalStateException("ScrollPageHelper needs a " +
"RecyclerView with a LinearLayoutManager");
}
if (recyclerView != null) {
//设置fling监听为null
recyclerView.setOnFlingListener(null);
if ((gravity == Gravity.START || gravity == Gravity.END)) {
isRtlHorizontal = isRtl();
}
}
super.attachToRecyclerView(recyclerView);
}
/**
*
* @param layoutManager layoutManager
* @param targetView 目标view
* @return
*/
@Nullable
@Override
public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager,
@NonNull View targetView) {
//创建数组
int[] out = new int[2];
//判断是否是横向方法
if (layoutManager.canScrollHorizontally()) {
if (gravity == Gravity.START) {
out[0] = distanceToStart(targetView, getHorizontalHelper(layoutManager), false);
} else { // END
out[0] = distanceToEnd(targetView, getHorizontalHelper(layoutManager), false);
}
} else {
out[0] = 0;
}
//判断是否是竖直方法
if (layoutManager.canScrollVertically()) {
if (gravity == Gravity.TOP) {
out[1] = distanceToStart(targetView, getVerticalHelper(layoutManager), false);
} else { // BOTTOM
out[1] = distanceToEnd(targetView, getVerticalHelper(layoutManager), false);
}
} else {
out[1] = 0;
}
return out;
}
/**
* 找到当前时刻的SnapView
* @param layoutManager layoutManager
* @return
*/
@Nullable
@Override
public View findSnapView(RecyclerView.LayoutManager layoutManager) {
View snapView = null;
if (layoutManager instanceof LinearLayoutManager) {
switch (gravity) {
case Gravity.START:
snapView = findStartView(layoutManager, getHorizontalHelper(layoutManager));
break;
case Gravity.END:
snapView = findEndView(layoutManager, getHorizontalHelper(layoutManager));
break;
case Gravity.TOP:
snapView = findStartView(layoutManager, getVerticalHelper(layoutManager));
break;
case Gravity.BOTTOM:
snapView = findEndView(layoutManager, getVerticalHelper(layoutManager));
break;
default:
break;
}
}
return snapView;
}
private boolean isRtl() {
return TextUtils.getLayoutDirectionFromLocale(
Locale.getDefault()) == View.LAYOUT_DIRECTION_RTL;
}
@NonNull
private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
if (mVerticalHelper == null) {
mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
}
return mVerticalHelper;
}
@NonNull
private OrientationHelper getHorizontalHelper(
@NonNull RecyclerView.LayoutManager layoutManager) {
if (mHorizontalHelper == null) {
mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
}
return mHorizontalHelper;
}
private int distanceToStart(View targetView, @NonNull OrientationHelper helper, boolean fromEnd) {
if (isRtlHorizontal && !fromEnd) {
return distanceToEnd(targetView, helper, true);
}
return helper.getDecoratedStart(targetView) - helper.getStartAfterPadding();
}
private int distanceToEnd(View targetView, @NonNull OrientationHelper helper, boolean fromStart) {
if (isRtlHorizontal && !fromStart) {
return distanceToStart(targetView, helper, true);
}
return helper.getDecoratedEnd(targetView) - helper.getEndAfterPadding();
}
@Nullable
private View findStartView(RecyclerView.LayoutManager layoutManager,
@NonNull OrientationHelper helper) {
if (layoutManager instanceof LinearLayoutManager) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
boolean reverseLayout = linearLayoutManager.getReverseLayout();
int firstChild = reverseLayout ? linearLayoutManager.findLastVisibleItemPosition()
: linearLayoutManager.findFirstVisibleItemPosition();
int offset = 1;
if (layoutManager instanceof GridLayoutManager) {
offset += ((GridLayoutManager) layoutManager).getSpanCount() - 1;
}
if (firstChild == RecyclerView.NO_POSITION) {
return null;
}
View child = layoutManager.findViewByPosition(firstChild);
float visibleWidth;
if (isRtlHorizontal) {
visibleWidth = (float) (helper.getTotalSpace() - helper.getDecoratedStart(child))
/ helper.getDecoratedMeasurement(child);
} else {
visibleWidth = (float) helper.getDecoratedEnd(child)
/ helper.getDecoratedMeasurement(child);
}
boolean endOfList;
if (!reverseLayout) {
endOfList = ((LinearLayoutManager) layoutManager)
.findLastCompletelyVisibleItemPosition()
== layoutManager.getItemCount() - 1;
} else {
endOfList = ((LinearLayoutManager) layoutManager)
.findFirstCompletelyVisibleItemPosition()
== 0;
}
if (visibleWidth > 0.5f && !endOfList) {
return child;
} else if (snapLastItem && endOfList) {
return child;
} else if (endOfList) {
return null;
} else {
return reverseLayout ? layoutManager.findViewByPosition(firstChild - offset)
: layoutManager.findViewByPosition(firstChild + offset);
}
}
return null;
}
@Nullable
private View findEndView(RecyclerView.LayoutManager layoutManager,
@NonNull OrientationHelper helper) {
if (layoutManager instanceof LinearLayoutManager) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
boolean reverseLayout = linearLayoutManager.getReverseLayout();
int lastChild = reverseLayout ? linearLayoutManager.findFirstVisibleItemPosition()
: linearLayoutManager.findLastVisibleItemPosition();
int offset = 1;
if (layoutManager instanceof GridLayoutManager) {
offset += ((GridLayoutManager) layoutManager).getSpanCount() - 1;
}
if (lastChild == RecyclerView.NO_POSITION) {
return null;
}
View child = layoutManager.findViewByPosition(lastChild);
float visibleWidth;
if (isRtlHorizontal) {
visibleWidth = (float) helper.getDecoratedEnd(child)
/ helper.getDecoratedMeasurement(child);
} else {
visibleWidth = (float) (helper.getTotalSpace() - helper.getDecoratedStart(child))
/ helper.getDecoratedMeasurement(child);
}
boolean startOfList;
if (!reverseLayout) {
startOfList = ((LinearLayoutManager) layoutManager)
.findFirstCompletelyVisibleItemPosition() == 0;
} else {
startOfList = ((LinearLayoutManager) layoutManager)
.findLastCompletelyVisibleItemPosition()
== layoutManager.getItemCount() - 1;
}
if (visibleWidth > 0.5f && !startOfList) {
return child;
} else if (snapLastItem && startOfList) {
return child;
} else if (startOfList) {
return null;
} else {
return reverseLayout ? layoutManager.findViewByPosition(lastChild + offset)
: layoutManager.findViewByPosition(lastChild - offset);
}
}
return null;
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/build.gradle | Gradle | apply plugin: 'com.android.application'
android {
compileSdkVersion 29
defaultConfig {
applicationId "com.ycbjie.ycscrollpager"
minSdkVersion 17
targetSdkVersion 29
versionCode 1
versionName "1.0"
testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
ndk {
//设置支持的SO库架构
abiFilters 'armeabi', 'armeabi-v7a'
}
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
//jdk1.8
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.0.0'
implementation 'com.google.android.material:material:1.0.0'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
//implementation project(path: ':PagerLib')
implementation 'com.github.yangchong211:YCScrollPager:1.0.5'
//exo的UI库
implementation 'com.google.android.exoplayer:exoplayer-ui:2.11.3'
implementation 'com.google.android.exoplayer:exoplayer-core:2.11.3'
//这两个是必须要加的，其它的可供选择
implementation 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
implementation 'tv.danmaku.ijk.media:ijkplayer-armv7a:0.8.4'
//其他库文件
//implementation 'tv.danmaku.ijk.media:ijkplayer-armv5:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-arm64:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-x86:0.8.8'
//implementation 'tv.danmaku.ijk.media:ijkplayer-x86_64:0.8.8'
//视频播放器库：https://github.com/yangchong211/YCVideoPlayer
implementation 'com.github.yangchong211.YCVideoPlayer:VideoPlayer:1.1.0'
implementation 'com.github.yangchong211.YCVideoPlayer:VideoKernel:1.1.0'
implementation 'com.github.yangchong211.YCVideoPlayer:VideoCache:1.1.0'
//其他库
implementation 'com.github.bumptech.glide:glide:4.9.0' //谷歌图片加载库
implementation 'jp.wasabeef:glide-transformations:2.0.1'
implementation 'cn.yc:YCBannerLib:1.4.0'
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/BaseActivity.java | Java | package com.ycbjie.ycscrollpager;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
public abstract class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(getContentView());
//避免切换横竖屏
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
initView();
initListener();
initData();
}
@Override
protected void onDestroy() {
super.onDestroy();
//测试内存泄漏，正式一定要隐藏
initLeakCanary();
}
@Override
protected void onRestart() {
super.onRestart();
}
@Override
protected void onResume() {
super.onResume();
}
@Override
protected void onPause() {
super.onPause();
}
/** 返回一个用于显示界面的布局id */
public abstract int getContentView();
/** 初始化View的代码写在这个方法中 */
public abstract void initView();
/** 初始化监听器的代码写在这个方法中 */
public abstract void initListener();
/** 初始数据的代码写在这个方法中，用于从服务器获取数据 */
public abstract void initData();
/**
* 通过Class跳转界面
**/
public void startActivity(Class<?> cls) {
startActivity(cls, null);
}
/**
* 通过Class跳转界面
**/
public void startActivityForResult(Class<?> cls, int requestCode) {
startActivityForResult(cls, null, requestCode);
}
/**
* 含有Bundle通过Class跳转界面
**/
public void startActivityForResult(Class<?> cls, Bundle bundle, int requestCode) {
Intent intent = new Intent();
intent.setClass(this, cls);
if (bundle != null) {
intent.putExtras(bundle);
}
startActivityForResult(intent, requestCode);
}
/**
* 含有Bundle通过Class跳转界面
**/
public void startActivity(Class<?> cls, Bundle bundle) {
Intent intent = new Intent();
intent.setClass(this, cls);
if (bundle != null) {
intent.putExtras(bundle);
}
startActivity(intent);
}
/**
* 用来检测所有Activity的内存泄漏
*/
private void initLeakCanary() {
/*RefWatcher refWatcher = BaseApplication.getRefWatcher(this);
refWatcher.watch(this);*/
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/BaseApplication.java | Java | package com.ycbjie.ycscrollpager;
import android.app.Application;
import android.content.Context;
import android.content.res.Configuration;
import android.util.Log;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.kernel.utils.PlayerConstant;
import com.yc.kernel.utils.PlayerFactoryUtils;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.player.VideoViewManager;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/8/18
* 描 述：BaseApplication
* 修订历史：
* ================================================
*/
public class BaseApplication extends Application {
private static BaseApplication instance;
public static synchronized BaseApplication getInstance() {
if (null == instance) {
instance = new BaseApplication();
}
return instance;
}
public BaseApplication(){}
/**
* 这个最先执行
*/
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
}
/**
* 程序启动的时候执行
*/
@Override
public void onCreate() {
Log.d("Application", "onCreate");
super.onCreate();
instance = this;
//播放器配置，注意：此为全局配置，按需开启
PlayerFactory player = PlayerFactoryUtils.getPlayer(PlayerConstant.PlayerType.TYPE_IJK);
VideoViewManager.setConfig(VideoPlayerConfig.newBuilder()
//设置上下文
.setContext(this)
//设置视频全局埋点事件
//调试的时候请打开日志，方便排错
.setLogEnabled(true)
//设置ijk
.setPlayerFactory(player)
//创建SurfaceView
//.setRenderViewFactory(SurfaceViewFactory.create())
.build());
}
/**
* 程序终止的时候执行
*/
@Override
public void onTerminate() {
Log.d("Application", "onTerminate");
super.onTerminate();
}
/**
* 低内存的时候执行
*/
@Override
public void onLowMemory() {
Log.d("Application", "onLowMemory");
super.onLowMemory();
}
/**
* HOME键退出应用程序
* 程序在内存清理的时候执行
*/
@Override
public void onTrimMemory(int level) {
Log.d("Application", "onTrimMemory");
super.onTrimMemory(level);
}
/**
* onConfigurationChanged
*/
@Override
public void onConfigurationChanged(Configuration newConfig) {
Log.d("Application", "onConfigurationChanged");
super.onConfigurationChanged(newConfig);
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/ConstantVideo.java | Java | package com.ycbjie.ycscrollpager;
import com.yc.video.config.VideoInfoBean;
import java.util.ArrayList;
import java.util.List;
public class ConstantVideo {
public static String[] VideoPlayerList = {
"http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4",
"http://jzvd.nathen.cn/c494b340ff704015bb6682ffde3cd302/64929c369124497593205a4190d7d128-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/63f3f73712544394be981d9e4f56b612/69c5767bb9e54156b5b60a1b6edeb3b5-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/b201be3093814908bf987320361c5a73/2f6d913ea25941ffa78cc53a59025383-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/d2438fd1c37c4618a704513ad38d68c5/68626a9d53ca421c896ac8010f172b68-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/25a8d119cfa94b49a7a4117257d8ebd7/f733e65a22394abeab963908f3c336db-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/7512edd1ad834d40bb5b978402274b1a/9691c7f2d7b74b5e811965350a0e5772-5287d2089db37e62345123a1be272f8b.mp4",
"http://jzvd.nathen.cn/c6e3dc12a1154626b3476d9bf3bd7266/6b56c5f0dc31428083757a45764763b0-5287d2089db37e62345123a1be272f8b.mp4",
"http://play.g3proxy.lecloud.com/vod/v2/MjUxLzE2LzgvbGV0di11dHMvMTQvdmVyXzAwXzIyLTExMDc2NDEzODctYXZjLTE5OTgxOS1hYWMtNDgwMDAtNTI2MTEwLTE3MDg3NjEzLWY1OGY2YzM1NjkwZTA2ZGFmYjg2MTVlYzc5MjEyZjU4LTE0OTg1NTc2ODY4MjMubXA0?b=259&mmsid=65565355&tm=1499247143&key=f0eadb4f30c404d49ff8ebad673d3742&platid=3&splatid=345&playid=0&tss=no&vtype=21&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"
};
public static String[] VideoPlayerTitle = {
"大家好，我是潇湘剑雨",
"大家好，我是潇湘剑雨",
"如果项目可以，可以给个star",
"有bug，可以直接提出来，欢迎一起探讨",
"把本地项目代码复制到拷贝的仓库",
"依次输入命令上传代码",
"把本地项目代码复制到拷贝的仓库",
"依次输入命令上传代码",
"逗比逗比把本地项目代码复制到拷贝的仓库",
};
public static List<VideoInfoBean> getVideoList() {
List<VideoInfoBean> videoList = new ArrayList<>();
videoList.add(new VideoInfoBean("大家好，我是潇湘剑雨",
"https://img-blog.csdnimg.cn/20201012215233584.png",
"http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4"));
videoList.add(new VideoInfoBean("如果项目可以，可以给个star",
"https://img-blog.csdnimg.cn/20201013092150588.png",
"http://vfx.mtime.cn/Video/2019/03/21/mp4/190321153853126488.mp4"));
videoList.add(new VideoInfoBean("把本地项目代码复制到拷贝的仓库",
"https://img-blog.csdnimg.cn/2020101309293329.png",
"http://vfx.mtime.cn/Video/2019/03/19/mp4/190319222227698228.mp4"));
videoList.add(new VideoInfoBean("有bug，可以直接提出来，欢迎一起探讨",
"https://img-blog.csdnimg.cn/20201013094115174.png",
"http://vfx.mtime.cn/Video/2019/03/19/mp4/190319212559089721.mp4"));
videoList.add(new VideoInfoBean("逗比逗比把本地项目代码复制到拷贝的仓库",
"https://img-blog.csdnimg.cn/20201013091432693.jpg",
"http://vfx.mtime.cn/Video/2019/03/18/mp4/190318231014076505.mp4"));
videoList.add(new VideoInfoBean("预告片6",
"https://img-blog.csdnimg.cn/20201013091432695.jpg",
"http://vfx.mtime.cn/Video/2019/03/18/mp4/190318214226685784.mp4"));
videoList.add(new VideoInfoBean("预告片7",
"https://img-blog.csdnimg.cn/20201013091432667.jpg",
"http://vfx.mtime.cn/Video/2019/03/19/mp4/190319104618910544.mp4"));
videoList.add(new VideoInfoBean("大家好，我是潇湘剑雨逗比",
"https://img-blog.csdnimg.cn/20201012215233584.png",
"http://vfx.mtime.cn/Video/2019/03/19/mp4/190319125415785691.mp4"));
videoList.add(new VideoInfoBean("依次输入命令上传代码",
"https://img-blog.csdnimg.cn/20201013091432667.jpg",
"http://vfx.mtime.cn/Video/2019/03/17/mp4/190317150237409904.mp4"));
videoList.add(new VideoInfoBean("依次输入命令上传代码",
"https://img-blog.csdnimg.cn/20201013091432625.jpg",
"http://vfx.mtime.cn/Video/2019/03/14/mp4/190314223540373995.mp4"));
videoList.add(new VideoInfoBean("预告片11",
"https://img-blog.csdnimg.cn/20201013091432602.jpg",
"http://vfx.mtime.cn/Video/2019/03/14/mp4/190314102306987969.mp4"));
videoList.add(new VideoInfoBean("依次输入命令上传代码",
"https://img-blog.csdnimg.cn/20201013091432603.jpg",
"http://vfx.mtime.cn/Video/2019/03/13/mp4/190313094901111138.mp4"));
videoList.add(new VideoInfoBean("如果项目可以，可以给个star",
"https://img-blog.csdnimg.cn/20201013091432616.jpg",
"http://vfx.mtime.cn/Video/2019/03/12/mp4/190312143927981075.mp4"));
videoList.add(new VideoInfoBean("预告片14",
"https://img-blog.csdnimg.cn/20201013091432581.jpg",
"http://vfx.mtime.cn/Video/2019/03/12/mp4/190312083533415853.mp4"));
return videoList;
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/IntentKeys.java | Java | package com.ycbjie.ycscrollpager;
public class IntentKeys {
public static final String URL = "url";
public static final String SEAMLESS_PLAY = "seamless_play";
public static final String TITLE = "title";
public static final String IS_LIVE = "isLive";
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/MainActivity.java | Java | package com.ycbjie.ycscrollpager;
import android.content.Intent;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import com.ycbjie.ycscrollpager.list.TestListActivity;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.tv_1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, TestListActivity.class);
intent.putExtra("type",0);
startActivity(intent);
}
});
findViewById(R.id.tv_2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, TestListActivity.class);
intent.putExtra("type",1);
startActivity(intent);
}
});
findViewById(R.id.tv_3).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, TestListActivity.class);
intent.putExtra("type",2);
startActivity(intent);
}
});
findViewById(R.id.tv_4).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, TestListActivity.class);
intent.putExtra("type",3);
startActivity(intent);
}
});
findViewById(R.id.tv_5).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this, TestListActivity.class);
intent.putExtra("type",4);
startActivity(intent);
}
});
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/ContinuousVideoActivity.java | Java | package com.ycbjie.ycscrollpager.list;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import com.bumptech.glide.Glide;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.SimpleStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.ui.view.BasisVideoController;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.List;
/**
* 连续播放列表视频
* 意思是说播放完了第一个，接着播放第二个，第三个……
*/
public class ContinuousVideoActivity extends AppCompatActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private Button mBtnScaleNormal;
private Button mBtnScale169;
private Button mBtnScale43;
private Button mBtnCrop;
private Button mBtnGif;
private List<VideoInfoBean> data = ConstantVideo.getVideoList();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_normal_video);
initFindViewById();
initVideoPlayer();
initListener();
}
@Override
protected void onResume() {
super.onResume();
if (mVideoPlayer != null) {
mVideoPlayer.resume();
}
}
@Override
protected void onPause() {
super.onPause();
if (mVideoPlayer != null) {
mVideoPlayer.pause();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mVideoPlayer != null) {
mVideoPlayer.release();
}
}
@Override
public void onBackPressed() {
if (mVideoPlayer == null || !mVideoPlayer.onBackPressed()) {
super.onBackPressed();
}
}
private void initFindViewById() {
mVideoPlayer = findViewById(R.id.video_player);
mBtnScaleNormal = findViewById(R.id.btn_scale_normal);
mBtnScale169 = findViewById(R.id.btn_scale_169);
mBtnScale43 = findViewById(R.id.btn_scale_43);
mBtnCrop = findViewById(R.id.btn_crop);
mBtnGif = findViewById(R.id.btn_gif);
}
private void initVideoPlayer() {
BasisVideoController controller = new BasisVideoController(this);
//设置视频背景图
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
//设置控制器
mVideoPlayer.setController(controller);
mVideoPlayer.setUrl(ConstantVideo.VideoPlayerList[0]);
mVideoPlayer.start();
//监听播放结束
mVideoPlayer.addOnStateChangeListener(new SimpleStateListener() {
private int mCurrentVideoPosition;
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
if (data != null) {
mCurrentVideoPosition++;
if (mCurrentVideoPosition >= data.size()) return;
mVideoPlayer.release();
//重新设置数据
VideoInfoBean videoBean = data.get(mCurrentVideoPosition);
mVideoPlayer.setUrl(videoBean.getVideoUrl());
mVideoPlayer.setController(controller);
//开始播放
mVideoPlayer.start();
}
}
}
});
}
private void initListener() {
mBtnScaleNormal.setOnClickListener(this);
mBtnScale169.setOnClickListener(this);
mBtnScale43.setOnClickListener(this);
mBtnCrop.setOnClickListener(this);
mBtnGif.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mBtnScale169){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9);
} else if (v == mBtnScaleNormal){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_DEFAULT);
}else if (v == mBtnScale43){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_4_3);
} else if (v == mBtnCrop){
} else if (v == mBtnGif){
}
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/DetailActivity.java | Java | package com.ycbjie.ycscrollpager.list;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.core.view.ViewCompat;
import androidx.appcompat.app.AppCompatActivity;
import android.transition.Transition;
import android.widget.FrameLayout;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import com.ycbjie.ycscrollpager.IntentKeys;
import com.ycbjie.ycscrollpager.R;
public class DetailActivity extends AppCompatActivity {
private FrameLayout mPlayerContainer;
private VideoPlayer mVideoView;
public static final String VIEW_NAME_PLAYER_CONTAINER = "player_container";
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_detail_video);
initView();
initVideoView();
}
protected void initView() {
mPlayerContainer = findViewById(R.id.player_container);
ViewCompat.setTransitionName(mPlayerContainer, VIEW_NAME_PLAYER_CONTAINER);
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP || !addTransitionListener()) {
initVideoView();
}
}
private void initVideoView() {
//拿到VideoView实例
VideoPlayer mVideoView = VideoViewManager.instance().get("seamless");
//如果已经添加到某个父容器，就将其移除
PlayerUtils.removeViewFormParent(mVideoView);
//把播放器添加到页面的容器中
mPlayerContainer.addView(mVideoView);
//设置新的控制器
BasisVideoController controller = new BasisVideoController(DetailActivity.this);
mVideoView.setController(controller);
Intent intent = getIntent();
boolean seamlessPlay = intent.getBooleanExtra(IntentKeys.SEAMLESS_PLAY, false);
String title = intent.getStringExtra(IntentKeys.TITLE);
controller.addDefaultControlComponent(title);
if (seamlessPlay) {
//无缝播放需还原Controller状态
controller.setPlayState(mVideoView.getCurrentPlayState());
controller.setPlayerState(mVideoView.getCurrentPlayerState());
} else {
//不是无缝播放的情况
String url = intent.getStringExtra(IntentKeys.URL);
mVideoView.setUrl(url);
mVideoView.start();
}
}
@RequiresApi(21)
private boolean addTransitionListener() {
final Transition transition = getWindow().getSharedElementEnterTransition();
if (transition != null) {
transition.addListener(new Transition.TransitionListener() {
@Override
public void onTransitionEnd(Transition transition) {
transition.removeListener(this);
}
@Override
public void onTransitionStart(Transition transition) {
initVideoView();
}
@Override
public void onTransitionCancel(Transition transition) {
transition.removeListener(this);
}
@Override
public void onTransitionPause(Transition transition) {
}
@Override
public void onTransitionResume(Transition transition) {
}
});
return true;
}
return false;
}
@Override
protected void onPause() {
if (isFinishing()) {
//移除Controller
mVideoView.setController(null);
//将VideoView置空，其目的是不执行 super.onPause(); 和 super.onDestroy(); 中的代码
mVideoView = null;
}
super.onPause();
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/OnItemChildClickListener.java | Java | package com.ycbjie.ycscrollpager.list;
public interface OnItemChildClickListener {
void onItemChildClick(int position);
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/OnItemClickListener.java | Java | package com.ycbjie.ycscrollpager.list;
public interface OnItemClickListener {
void onItemClick(int position);
} | yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/RecyclerView2Fragment.java | Java | package com.ycbjie.ycscrollpager.list;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.yc.pagerlib.recycler.ScrollPageHelper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.SimpleStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
/**
* RecyclerView demo
*/
public class RecyclerView2Fragment extends Fragment {
protected List<VideoInfoBean> mVideos = new ArrayList<>();
protected VideoRecyclerViewAdapter mAdapter;
protected RecyclerView mRecyclerView;
protected LinearLayoutManager mLinearLayoutManager;
protected VideoPlayer mVideoView;
protected BasisVideoController mController;
/**
* 当前播放的位置
*/
protected int mCurPos = -1;
/**
* 上次播放的位置，用于页面切回来之后恢复播放
*/
protected int mLastPos = mCurPos;
private Context context;
@Override
public void onAttach(@NonNull Context context) {
super.onAttach(context);
this.context = context;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
return inflater.inflate(R.layout.base_recycler_view, container, false);
}
@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
initData();
}
protected void initView(View view) {
initVideoView();
mRecyclerView = view.findViewById(R.id.recyclerView);
mLinearLayoutManager = new LinearLayoutManager(getContext());
mRecyclerView.setLayoutManager(mLinearLayoutManager);
mAdapter = new VideoRecyclerViewAdapter(mVideos);
mAdapter.setOnItemChildClickListener(new OnItemChildClickListener() {
@Override
public void onItemChildClick(int position) {
startPlay(position);
}
});
mRecyclerView.setAdapter(mAdapter);
ScrollPageHelper snapHelper = new ScrollPageHelper(Gravity.TOP,false);
snapHelper.attachToRecyclerView(mRecyclerView);
mRecyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
}
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
FrameLayout playerContainer = view.findViewById(R.id.player_container);
View v = playerContainer.getChildAt(0);
if (v != null && v == mVideoView && !mVideoView.isFullScreen()) {
releaseVideoView();
}
}
});
}
protected void initVideoView() {
mVideoView = new VideoPlayer(context);
mVideoView.setOnStateChangeListener(new SimpleStateListener() {
@Override
public void onPlayStateChanged(int playState) {
//监听VideoViewManager释放，重置状态
if (playState == ConstantKeys.CurrentState.STATE_IDLE) {
PlayerUtils.removeViewFormParent(mVideoView);
mLastPos = mCurPos;
mCurPos = -1;
}
}
});
mController = new BasisVideoController(context);
mVideoView.setController(mController);
}
protected void initData() {
List<VideoInfoBean> videoList = ConstantVideo.getVideoList();
mVideos.addAll(videoList);
mAdapter.notifyDataSetChanged();
}
@Override
public void onPause() {
super.onPause();
pause();
}
/**
* 由于onPause必须调用super。故增加此方法，
* 子类将会重写此方法，改变onPause的逻辑
*/
protected void pause() {
releaseVideoView();
}
@Override
public void onResume() {
super.onResume();
resume();
}
/**
* 由于onResume必须调用super。故增加此方法，
* 子类将会重写此方法，改变onResume的逻辑
*/
protected void resume() {
if (mLastPos == -1)
return;
//恢复上次播放的位置
startPlay(mLastPos);
}
/**
* 开始播放
* @param position 列表位置
*/
protected void startPlay(int position) {
if (mCurPos == position) return;
if (mCurPos != -1) {
releaseVideoView();
}
VideoInfoBean videoBean = mVideos.get(position);
mVideoView.setUrl(videoBean.getVideoUrl());
View itemView = mLinearLayoutManager.findViewByPosition(position);
if (itemView == null) return;
VideoRecyclerViewAdapter.VideoHolder viewHolder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
//把列表中预置的PrepareView添加到控制器中，注意isPrivate此处只能为true。
mController.addControlComponent(viewHolder.mPrepareView, true);
PlayerUtils.removeViewFormParent(mVideoView);
viewHolder.mPlayerContainer.addView(mVideoView, 0);
//播放之前将VideoView添加到VideoViewManager以便在别的页面也能操作它
VideoViewManager.instance().add(mVideoView, "list");
mVideoView.start();
mCurPos = position;
}
private void releaseVideoView() {
mVideoView.release();
if (mVideoView.isFullScreen()) {
mVideoView.stopFullScreen();
}
if(getActivity().getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mCurPos = -1;
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/RecyclerViewAutoPlayFragment.java | Java | package com.ycbjie.ycscrollpager.list;
import android.graphics.Rect;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
/**
* 滑动列表自动播放，仅包含自动播放的逻辑
*/
public class RecyclerViewAutoPlayFragment extends RecyclerViewFragment {
@Override
protected void initView(View view) {
super.initView(view);
mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
super.onScrollStateChanged(recyclerView, newState);
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
//滚动停止
autoPlayVideo(recyclerView);
}
}
private void autoPlayVideo(RecyclerView view) {
if (view == null) return;
//遍历RecyclerView子控件,如果mPlayerContainer完全可见就开始播放
int count = view.getChildCount();
for (int i = 0; i < count; i++) {
View itemView = view.getChildAt(i);
if (itemView == null) continue;
VideoRecyclerViewAdapter.VideoHolder holder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
Rect rect = new Rect();
holder.mPlayerContainer.getLocalVisibleRect(rect);
//获取item的高度
int height = holder.mPlayerContainer.getHeight();
if (rect.top == 0 && rect.bottom == height) {
startPlay(holder.mPosition);
break;
}
}
}
});
}
@Override
protected void initData() {
super.initData();
mRecyclerView.post(() -> {
//自动播放第一个
startPlay(0);
});
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.