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/com/ycbjie/ycscrollpager/list/RecyclerViewFragment.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.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
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.yc.videotool.VideoLogUtils;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
/**
* 普通的列表播放
*/
public class RecyclerViewFragment 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);
mRecyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
VideoLogUtils.i("addOnChildAttachStateChangeListener-----AttachedToWindow---"+view);
}
/**
* 当适配器创建的view（即列表项view）被窗口分离（即滑动离开了当前窗口界面）就会被调用
*
* @param view
*/
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
VideoLogUtils.i("addOnChildAttachStateChangeListener-----DetachedFromWindow---"+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() {
if (mVideoView.isFullScreen()) {
mVideoView.stopFullScreen();
}
mVideoView.release();
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/SeamlessPlayFragment.java | Java | package com.ycbjie.ycscrollpager.list;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;
import androidx.core.app.ActivityOptionsCompat;
import android.transition.Transition;
import android.view.View;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
import com.ycbjie.ycscrollpager.IntentKeys;
import com.ycbjie.ycscrollpager.R;
/**
* 无缝播放
*/
public class SeamlessPlayFragment extends RecyclerViewAutoPlayFragment {
private boolean mSkipToDetail;
@Override
protected void initView(View view) {
super.initView(view);
//提前添加到VideoViewManager，供详情使用
VideoViewManager.instance().add(mVideoView, "seamless");
mAdapter.setOnItemClickListener(position -> {
mSkipToDetail = true;
Intent intent = new Intent(getActivity(), DetailActivity.class);
Bundle bundle = new Bundle();
VideoInfoBean videoBean = mVideos.get(position);
if (mCurPos == position) {
//需要无缝播放
bundle.putBoolean(IntentKeys.SEAMLESS_PLAY, true);
bundle.putString(IntentKeys.TITLE, videoBean.getTitle());
} else {
//无需无缝播放，把相应数据传到详情页
mVideoView.release();
//需要把控制器还原
mController.setPlayState(ConstantKeys.CurrentState.STATE_IDLE);
bundle.putBoolean(IntentKeys.SEAMLESS_PLAY, false);
bundle.putString(IntentKeys.URL, videoBean.getVideoUrl());
bundle.putString(IntentKeys.TITLE, videoBean.getTitle());
mCurPos = position;
}
intent.putExtras(bundle);
View sharedView = mLinearLayoutManager.findViewByPosition(position).findViewById(R.id.player_container);
//使用共享元素动画
ActivityOptionsCompat options = ActivityOptionsCompat
.makeSceneTransitionAnimation(getActivity(), sharedView, DetailActivity.VIEW_NAME_PLAYER_CONTAINER);
ActivityCompat.startActivity(getActivity(), intent, options.toBundle());
});
}
@Override
protected void startPlay(int position) {
mVideoView.setController(mController);
super.startPlay(position);
}
@Override
protected void pause() {
if (!mSkipToDetail) {
super.pause();
}
}
@Override
protected void resume() {
if (mSkipToDetail) {
mSkipToDetail = false;
} else {
super.resume();
}
}
@Override
public void onStart() {
super.onStart();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP || !addTransitionListener()) {
restoreVideoView();
}
}
@RequiresApi(21)
private boolean addTransitionListener() {
final Transition transition = getActivity().getWindow().getSharedElementExitTransition();
if (transition != null) {
transition.addListener(new Transition.TransitionListener() {
@Override
public void onTransitionEnd(Transition transition) {
restoreVideoView();
transition.removeListener(this);
}
@Override
public void onTransitionStart(Transition transition) {
}
@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;
}
private void restoreVideoView() {
//还原播放器
View itemView = mLinearLayoutManager.findViewByPosition(mCurPos);
VideoRecyclerViewAdapter.VideoHolder viewHolder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
mVideoView = VideoViewManager.instance().get("seamless");
PlayerUtils.removeViewFormParent(mVideoView);
viewHolder.mPlayerContainer.addView(mVideoView, 0);
mController.addControlComponent(viewHolder.mPrepareView, true);
mController.setPlayState(mVideoView.getCurrentPlayState());
mController.setPlayerState(mVideoView.getCurrentPlayerState());
mRecyclerView.postDelayed(new Runnable() {
@Override
public void run() {
mVideoView.setController(mController);
}
}, 100);
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/TestListActivity.java | Java | package com.ycbjie.ycscrollpager.list;
import com.ycbjie.ycscrollpager.BaseActivity;
import com.ycbjie.ycscrollpager.R;
import com.ycbjie.ycscrollpager.tiktok.TikTok1ListFragment;
import com.ycbjie.ycscrollpager.tiktok.TikTokListFragment;
/**
* @author yc
*/
public class TestListActivity extends BaseActivity {
@Override
public int getContentView() {
return R.layout.activity_test_fragment;
}
@Override
public void initView() {
int type = getIntent().getIntExtra("type", 0);
if (type==0){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerViewFragment())
.commit();
} else if (type==1){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerViewAutoPlayFragment())
.commit();
} else if (type==2){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new TikTokListFragment())
.commit();
} else if (type==3){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new TikTok1ListFragment())
.commit();
}else if (type==4){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new SeamlessPlayFragment())
.commit();
}else {
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerView2Fragment())
.commit();
}
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/list/VideoRecyclerViewAdapter.java | Java | package com.ycbjie.ycscrollpager.list;
import android.annotation.SuppressLint;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.ui.view.CustomPrepareView;
import com.ycbjie.ycscrollpager.R;
import java.util.List;
public class VideoRecyclerViewAdapter extends RecyclerView.Adapter<VideoRecyclerViewAdapter.VideoHolder> {
private List<VideoInfoBean> videos;
private OnItemChildClickListener mOnItemChildClickListener;
private OnItemClickListener mOnItemClickListener;
public VideoRecyclerViewAdapter(List<VideoInfoBean> videos) {
this.videos = videos;
}
@Override
@NonNull
public VideoHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_video, parent, false);
return new VideoHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull VideoHolder holder, @SuppressLint("RecyclerView") int position) {
VideoInfoBean videoBean = videos.get(position);
Glide.with(holder.mThumb.getContext())
.load(videoBean.getCover())
.placeholder(android.R.color.darker_gray)
.into(holder.mThumb);
holder.mTitle.setText(videoBean.getTitle());
holder.mPosition = position;
}
@Override
public int getItemCount() {
return videos.size();
}
public void addData(List<VideoInfoBean> videoList) {
int size = videos.size();
videos.addAll(videoList);
//使用此方法添加数据，使用notifyDataSetChanged会导致正在播放的视频中断
notifyItemRangeChanged(size, videos.size());
}
public class VideoHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
public int mPosition;
public FrameLayout mPlayerContainer;
public TextView mTitle;
public ImageView mThumb;
public CustomPrepareView mPrepareView;
VideoHolder(View itemView) {
super(itemView);
mPlayerContainer = itemView.findViewById(R.id.player_container);
mTitle = itemView.findViewById(R.id.tv_title);
mPrepareView = itemView.findViewById(R.id.prepare_view);
mThumb = mPrepareView.getThumb();
if (mOnItemChildClickListener != null) {
mPlayerContainer.setOnClickListener(this);
}
if (mOnItemClickListener != null) {
itemView.setOnClickListener(this);
}
//通过tag将ViewHolder和itemView绑定
itemView.setTag(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.player_container) {
if (mOnItemChildClickListener != null) {
mOnItemChildClickListener.onItemChildClick(mPosition);
}
} else {
if (mOnItemClickListener != null) {
mOnItemClickListener.onItemClick(mPosition);
}
}
}
}
public void setOnItemChildClickListener(OnItemChildClickListener onItemChildClickListener) {
mOnItemChildClickListener = onItemChildClickListener;
}
public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
mOnItemClickListener = onItemClickListener;
}
} | yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTok1Activity.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import android.widget.FrameLayout;
import com.yc.pagerlib.recycler.OnPagerListener;
import com.yc.pagerlib.recycler.PagerLayoutManager;
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 com.ycbjie.ycscrollpager.list.OnItemChildClickListener;
import com.ycbjie.ycscrollpager.list.VideoRecyclerViewAdapter;
import java.util.ArrayList;
import java.util.List;
/**
* 模仿抖音短视频，使用RecyclerView，实现了预加载功能
*/
public class TikTok1Activity extends AppCompatActivity {
protected List<VideoInfoBean> mVideos = new ArrayList<>();
protected VideoRecyclerViewAdapter mAdapter;
protected RecyclerView mRecyclerView;
protected PagerLayoutManager mLinearLayoutManager;
protected VideoPlayer mVideoView;
protected BasisVideoController mController;
/**
* 当前播放的位置
*/
protected int mCurPos = -1;
/**
* 上次播放的位置，用于页面切回来之后恢复播放
*/
protected int mLastPos = mCurPos;
private static final String KEY_INDEX = "index";
public static void start(Context context, int index) {
Intent i = new Intent(context, TikTok2Activity.class);
i.putExtra(KEY_INDEX, index);
context.startActivity(i);
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recycler_view);
mCurPos = getIntent().getIntExtra(KEY_INDEX, 0);
initView();
initData();
}
protected void initView() {
initVideoView();
mRecyclerView = findViewById(R.id.recyclerView);
mLinearLayoutManager= new PagerLayoutManager(this, OrientationHelper.VERTICAL);
mRecyclerView.setLayoutManager(mLinearLayoutManager);
mAdapter = new VideoRecyclerViewAdapter(mVideos);
mAdapter.setOnItemChildClickListener(new OnItemChildClickListener() {
@Override
public void onItemChildClick(int position) {
startPlay(position);
}
});
mRecyclerView.setAdapter(mAdapter);
mLinearLayoutManager.setOnViewPagerListener(new OnPagerListener() {
@Override
public void onInitComplete() {
System.out.println("OnPagerListener---onInitComplete--"+"初始化完成");
}
@Override
public void onPageRelease(boolean isNext, int position) {
System.out.println("OnPagerListener---onPageRelease--"+position+"-----"+isNext);
}
@Override
public void onPageSelected(int position, boolean isBottom) {
System.out.println("OnPagerListener---onPageSelected--"+position+"-----"+isBottom);
}
});
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(this);
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(this);
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(this.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
this.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/tiktok/TikTok1ListAdapter.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.annotation.SuppressLint;
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 com.yc.video.config.VideoInfoBean;
import com.ycbjie.ycscrollpager.R;
import java.util.List;
public class TikTok1ListAdapter extends RecyclerView.Adapter<TikTok1ListAdapter.TikTokListViewHolder> {
public List<VideoInfoBean> data;
private int mId;
public TikTok1ListAdapter(List<VideoInfoBean> data) {
this.data = data;
}
@NonNull
@Override
public TikTokListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_tiktok_list, parent, false);
return new TikTokListViewHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull TikTokListViewHolder holder, @SuppressLint("RecyclerView") int position) {
VideoInfoBean item = data.get(position);
holder.mTitle.setText(item.getTitle());
Glide.with(holder.mThumb.getContext())
.load(item.getCover())
.into(holder.mThumb);
holder.mPosition = position;
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
public void setImpl(int id) {
mId = id;
}
public class TikTokListViewHolder extends RecyclerView.ViewHolder {
public ImageView mThumb;
public TextView mTitle;
public int mPosition;
public TikTokListViewHolder(@NonNull View itemView) {
super(itemView);
mThumb = itemView.findViewById(R.id.iv_thumb);
mTitle = itemView.findViewById(R.id.tv_title);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
TikTok1Activity.start(itemView.getContext(), mPosition);
}
});
}
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTok1ListFragment.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.yc.video.config.VideoInfoBean;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
public class TikTok1ListFragment extends Fragment {
private List<VideoInfoBean> data = new ArrayList<>();
private RecyclerView mRecyclerView;
private TikTok1ListAdapter mAdapter;
@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) {
mRecyclerView = view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 2));
mAdapter = new TikTok1ListAdapter(data);
mRecyclerView.setAdapter(mAdapter);
}
protected void initData() {
//模拟请求数据
new Thread(new Runnable() {
@Override
public void run() {
List<VideoInfoBean> tiktokBeans = ConstantVideo.getVideoList();
data.addAll(tiktokBeans);
mRecyclerView.post(new Runnable() {
@Override
public void run() {
mAdapter.notifyDataSetChanged();
}
});
}
}).start();
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTok2Activity.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.viewpager.widget.ViewPager;
import androidx.appcompat.app.AppCompatActivity;
import android.view.View;
import com.yc.pagerlib.pager.VerticalViewPager;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import com.yc.videocache.cache.PreloadManager;
import com.yc.videocache.cache.ProxyVideoCacheManager;
import com.yc.videotool.VideoLogUtils;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
/**
* 模仿抖音短视频，使用VerticalViewPager实现，实现了预加载功能
*/
public class TikTok2Activity extends AppCompatActivity {
/**
* 当前播放位置
*/
private int mCurPos;
private List<VideoInfoBean> mVideoList = new ArrayList<>();
private Tiktok2Adapter mTiktok2Adapter;
private VerticalViewPager mViewPager;
private PreloadManager mPreloadManager;
private VideoPlayer mVideoPlayer;
private BasisVideoController mController;
private static final String KEY_INDEX = "index";
public static void start(Context context, int index) {
Intent i = new Intent(context, TikTok2Activity.class);
i.putExtra(KEY_INDEX, index);
context.startActivity(i);
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mVideoPlayer != null) {
mVideoPlayer.release();
}
mPreloadManager.removeAllPreloadTask();
//清除缓存，实际使用可以不需要清除，这里为了方便测试
ProxyVideoCacheManager.clearAllCache(this);
}
@Override
protected void onResume() {
super.onResume();
if (mVideoPlayer != null) {
mVideoPlayer.resume();
}
}
@Override
protected void onPause() {
super.onPause();
if (mVideoPlayer != null) {
mVideoPlayer.pause();
}
}
@Override
public void onBackPressed() {
if (mVideoPlayer == null || !mVideoPlayer.onBackPressed()) {
super.onBackPressed();
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tiktok2);
initFindViewById();
initListener();
initView();
}
private void initFindViewById() {
mViewPager = findViewById(R.id.vvp);
}
private void initListener() {
}
protected void initView() {
initViewPager();
initVideoView();
mPreloadManager = PreloadManager.getInstance(this);
addData(null);
Intent extras = getIntent();
int index = extras.getIntExtra(KEY_INDEX, 0);
mViewPager.setCurrentItem(index);
mViewPager.post(new Runnable() {
@Override
public void run() {
startPlay(index);
}
});
}
private void initVideoView() {
mVideoPlayer = new VideoPlayer(this);
mVideoPlayer.setLooping(true);
//以下只能二选一，看你的需求
mVideoPlayer.setRenderViewFactory(TikTokRenderViewFactory.create());
mController = new BasisVideoController(this);
mVideoPlayer.setController(mController);
}
private void initViewPager() {
mViewPager = findViewById(R.id.vvp);
mViewPager.setOffscreenPageLimit(4);
mTiktok2Adapter = new Tiktok2Adapter(mVideoList);
mViewPager.setAdapter(mTiktok2Adapter);
mViewPager.setOverScrollMode(View.OVER_SCROLL_NEVER);
mViewPager.setOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
private int mCurItem;
/**
* VerticalViewPager是否反向滑动
*/
private boolean mIsReverseScroll;
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
super.onPageScrolled(position, positionOffset, positionOffsetPixels);
if (position == mCurItem) {
return;
}
mIsReverseScroll = position < mCurItem;
}
@Override
public void onPageSelected(int position) {
super.onPageSelected(position);
if (position == mCurPos) return;
startPlay(position);
}
@Override
public void onPageScrollStateChanged(int state) {
super.onPageScrollStateChanged(state);
if (state == VerticalViewPager.SCROLL_STATE_DRAGGING) {
mCurItem = mViewPager.getCurrentItem();
}
if (state == VerticalViewPager.SCROLL_STATE_IDLE) {
mPreloadManager.resumePreload(mCurPos, mIsReverseScroll);
} else {
mPreloadManager.pausePreload(mCurPos, mIsReverseScroll);
}
}
});
// RecyclerView recyclerView = new RecyclerView(this);
// recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
// /**
// * 是否反向滑动
// */
// private boolean mIsReverseScroll;
//
// @Override
// public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
// super.onScrolled(recyclerView, dx, dy);
// if (dy>0){
// //表示下滑
// mIsReverseScroll = false;
// } else {
// //表示上滑
// mIsReverseScroll = true;
// }
// }
//
// @Override
// public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
// super.onScrollStateChanged(recyclerView, newState);
// if (newState == VerticalViewPager.SCROLL_STATE_IDLE) {
// mPreloadManager.resumePreload(mCurPos, mIsReverseScroll);
// } else {
// mPreloadManager.pausePreload(mCurPos, mIsReverseScroll);
// }
// }
// });
}
private void startPlay(int position) {
int count = mViewPager.getChildCount();
for (int i = 0; i < count; i ++) {
View itemView = mViewPager.getChildAt(i);
Tiktok2Adapter.ViewHolder viewHolder = (Tiktok2Adapter.ViewHolder) itemView.getTag();
if (viewHolder.mPosition == position) {
mVideoPlayer.release();
PlayerUtils.removeViewFormParent(mVideoPlayer);
VideoInfoBean tiktokBean = mVideoList.get(position);
String playUrl = mPreloadManager.getPlayUrl(tiktokBean.getVideoUrl());
VideoLogUtils.i("startPlay: " + "position: " + position + " url: " + playUrl);
mVideoPlayer.setUrl(playUrl);
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9);
mController.addControlComponent(viewHolder.mTikTokView, true);
viewHolder.mPlayerContainer.addView(mVideoPlayer, 0);
mVideoPlayer.start();
mCurPos = position;
break;
}
}
}
public void addData(View view) {
mVideoList.addAll(ConstantVideo.getVideoList());
mTiktok2Adapter.notifyDataSetChanged();
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTokListAdapter.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.annotation.SuppressLint;
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 com.yc.video.config.VideoInfoBean;
import com.ycbjie.ycscrollpager.R;
import java.util.List;
public class TikTokListAdapter extends RecyclerView.Adapter<TikTokListAdapter.TikTokListViewHolder> {
public List<VideoInfoBean> data;
private int mId;
public TikTokListAdapter(List<VideoInfoBean> data) {
this.data = data;
}
@NonNull
@Override
public TikTokListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_tiktok_list, parent, false);
return new TikTokListViewHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull TikTokListViewHolder holder, @SuppressLint("RecyclerView") int position) {
VideoInfoBean item = data.get(position);
holder.mTitle.setText(item.getTitle());
Glide.with(holder.mThumb.getContext())
.load(item.getCover())
.into(holder.mThumb);
holder.mPosition = position;
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
public void setImpl(int id) {
mId = id;
}
public class TikTokListViewHolder extends RecyclerView.ViewHolder {
public ImageView mThumb;
public TextView mTitle;
public int mPosition;
public TikTokListViewHolder(@NonNull View itemView) {
super(itemView);
mThumb = itemView.findViewById(R.id.iv_thumb);
mTitle = itemView.findViewById(R.id.tv_title);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
TikTok2Activity.start(itemView.getContext(), mPosition);
}
});
}
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTokListFragment.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.yc.video.config.VideoInfoBean;
import com.ycbjie.ycscrollpager.ConstantVideo;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
public class TikTokListFragment extends Fragment {
private List<VideoInfoBean> data = new ArrayList<>();
private RecyclerView mRecyclerView;
private TikTokListAdapter mAdapter;
@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) {
mRecyclerView = view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 2));
mAdapter = new TikTokListAdapter(data);
mRecyclerView.setAdapter(mAdapter);
}
protected void initData() {
//模拟请求数据
new Thread(new Runnable() {
@Override
public void run() {
List<VideoInfoBean> tiktokBeans = ConstantVideo.getVideoList();
data.addAll(tiktokBeans);
mRecyclerView.post(new Runnable() {
@Override
public void run() {
mAdapter.notifyDataSetChanged();
}
});
}
}).start();
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTokRenderView.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.graphics.Bitmap;
import androidx.annotation.NonNull;
import android.view.View;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.video.config.ConstantKeys;
import com.yc.video.surface.InterSurfaceView;
/**
* TikTok专用RenderView，横屏视频默认显示，竖屏视频居中裁剪
* 使用代理模式实现
*/
public class TikTokRenderView implements InterSurfaceView {
private InterSurfaceView mProxyRenderView;
TikTokRenderView(@NonNull InterSurfaceView renderView) {
this.mProxyRenderView = renderView;
}
@Override
public void attachToPlayer(@NonNull AbstractVideoPlayer player) {
mProxyRenderView.attachToPlayer(player);
}
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mProxyRenderView.setVideoSize(videoWidth, videoHeight);
if (videoHeight > videoWidth) {
//竖屏视频，使用居中裁剪
mProxyRenderView.setScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_CENTER_CROP);
} else {
//横屏视频，使用默认模式
mProxyRenderView.setScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_DEFAULT);
}
}
}
@Override
public void setVideoRotation(int degree) {
mProxyRenderView.setVideoRotation(degree);
}
@Override
public void setScaleType(int scaleType) {
// 置空，不要让外部去设置ScaleType
}
@Override
public View getView() {
return mProxyRenderView.getView();
}
@Override
public Bitmap doScreenShot() {
return mProxyRenderView.doScreenShot();
}
@Override
public void release() {
mProxyRenderView.release();
}
} | yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTokRenderViewFactory.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.content.Context;
import com.yc.video.surface.InterSurfaceView;
import com.yc.video.surface.RenderTextureView;
import com.yc.video.surface.SurfaceFactory;
public class TikTokRenderViewFactory extends SurfaceFactory {
public static TikTokRenderViewFactory create() {
return new TikTokRenderViewFactory();
}
@Override
public InterSurfaceView createRenderView(Context context) {
return new TikTokRenderView(new RenderTextureView(context));
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/TikTokView.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.Toast;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.ui.view.InterControlView;
import com.yc.videotool.VideoLogUtils;
import com.ycbjie.ycscrollpager.R;
public class TikTokView extends FrameLayout implements InterControlView {
private ImageView thumb;
private ImageView mPlayBtn;
private ControlWrapper mControlWrapper;
private int mScaledTouchSlop;
private int mStartX, mStartY;
public TikTokView(@NonNull Context context) {
super(context);
}
public TikTokView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public TikTokView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
{
LayoutInflater.from(getContext()).inflate(R.layout.layout_tiktok_controller, this, true);
thumb = findViewById(R.id.iv_thumb);
mPlayBtn = findViewById(R.id.play_btn);
setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
mControlWrapper.togglePlay();
}
});
mScaledTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
}
/**
* 解决点击和VerticalViewPager滑动冲突问题
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
mStartX = (int) event.getX();
mStartY = (int) event.getY();
return true;
case MotionEvent.ACTION_UP:
int endX = (int) event.getX();
int endY = (int) event.getY();
if (Math.abs(endX - mStartX) < mScaledTouchSlop
&& Math.abs(endY - mStartY) < mScaledTouchSlop) {
performClick();
}
break;
}
return false;
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
VideoLogUtils.e("STATE_IDLE " + hashCode());
thumb.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
VideoLogUtils.e("STATE_PLAYING " + hashCode());
thumb.setVisibility(GONE);
mPlayBtn.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
VideoLogUtils.e("STATE_PAUSED " + hashCode());
thumb.setVisibility(GONE);
mPlayBtn.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PREPARED:
VideoLogUtils.e("STATE_PREPARED " + hashCode());
break;
case ConstantKeys.CurrentState.STATE_ERROR:
VideoLogUtils.e("STATE_ERROR " + hashCode());
Toast.makeText(getContext(), R.string.error_message, Toast.LENGTH_SHORT).show();
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/ycbjie/ycscrollpager/tiktok/Tiktok2Adapter.java | Java | package com.ycbjie.ycscrollpager.tiktok;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.viewpager.widget.PagerAdapter;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.yc.video.config.VideoInfoBean;
import com.yc.videocache.cache.PreloadManager;
import com.ycbjie.ycscrollpager.R;
import java.util.ArrayList;
import java.util.List;
public class Tiktok2Adapter extends PagerAdapter {
/**
* View缓存池，从ViewPager中移除的item将会存到这里面，用来复用
*/
private List<View> mViewPool = new ArrayList<>();
/**
* 数据源
*/
private List<VideoInfoBean> mVideoBeans;
public Tiktok2Adapter(List<VideoInfoBean> videoBeans) {
this.mVideoBeans = videoBeans;
}
@Override
public int getCount() {
return mVideoBeans == null ? 0 : mVideoBeans.size();
}
@Override
public boolean isViewFromObject(@NonNull View view, @NonNull Object o) {
return view == o;
}
@NonNull
@Override
public Object instantiateItem(@NonNull ViewGroup container, int position) {
Context context = container.getContext();
View view = null;
if (mViewPool.size() > 0) {//取第一个进行复用
view = mViewPool.get(0);
mViewPool.remove(0);
}
ViewHolder viewHolder;
if (view == null) {
view = LayoutInflater.from(context).inflate(R.layout.item_tik_tok, container, false);
viewHolder = new ViewHolder(view);
} else {
viewHolder = (ViewHolder) view.getTag();
}
VideoInfoBean item = mVideoBeans.get(position);
//开始预加载
PreloadManager.getInstance(context).addPreloadTask(item.getVideoUrl(), position);
Glide.with(context)
.load(item.getCover())
.placeholder(android.R.color.white)
.into(viewHolder.mThumb);
viewHolder.mTitle.setText(item.getTitle());
viewHolder.mTitle.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(context, "点击了标题", Toast.LENGTH_SHORT).show();
}
});
viewHolder.mPosition = position;
container.addView(view);
return view;
}
@Override
public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
View itemView = (View) object;
container.removeView(itemView);
VideoInfoBean item = mVideoBeans.get(position);
//取消预加载
PreloadManager.getInstance(container.getContext()).removePreloadTask(item.getVideoUrl());
//保存起来用来复用
mViewPool.add(itemView);
}
/**
* 借鉴ListView item复用方法
*/
public static class ViewHolder {
public int mPosition;
public TextView mTitle;//标题
public ImageView mThumb;//封面图
public TikTokView mTikTokView;
public FrameLayout mPlayerContainer;
ViewHolder(View itemView) {
mTikTokView = itemView.findViewById(R.id.tiktok_View);
mTitle = mTikTokView.findViewById(R.id.tv_title);
mThumb = mTikTokView.findViewById(R.id.iv_thumb);
mPlayerContainer = itemView.findViewById(R.id.container);
itemView.setTag(this);
}
}
}
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | 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/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
settings.gradle | Gradle | include ':app', ':PagerLib'
| yangchong211/YCScrollPager | 384 | 仿抖音，快手，短视频，竖直方向，一次滚动一个页面的封装库。目前支持ViewPager做法，也支持RecyclerView做法……使用ViewPager则只是修改滑动速率，以及滚动翻页过渡时间；使用recyclerView打造丝滑切换视频的功能，更多内容可以看demo | Java | yangchong211 | 杨充 | Tencent |
YCSlideLib/build.gradle | Gradle | apply plugin: 'com.android.library'
//迁移到jitpack
apply plugin: 'com.github.dcendents.android-maven'
android {
compileSdkVersion 29
defaultConfig {
minSdkVersion 16
targetSdkVersion 29
versionCode 12
versionName "1.1.2"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.3.0'
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
YCSlideLib/src/main/java/com/yc/slide/LoggerUtils.java | Java | package com.yc.slide;
import android.util.Log;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211/YCShopDetailLayout
* time : 2018/6/6
* desc : 日志
* revise:
* </pre>
*/
public class LoggerUtils {
private static boolean isLog = false;
public static void setIsLog(boolean isLog) {
LoggerUtils.isLog = isLog;
}
public static void i(String string){
if (isLog){
Log.i("LoggerUtils",string);
}
}
public static void d(String string){
if (isLog){
Log.d("LoggerUtils",string);
}
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
YCSlideLib/src/main/java/com/yc/slide/SlideAnimLayout.java | Java | package com.yc.slide;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import androidx.core.view.ViewCompat;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211/YCShopDetailLayout
* time : 2018/6/6
* desc : SlideAnimLayout
* revise:
* </pre>
*/
public class SlideAnimLayout extends ViewGroup {
private ValueAnimator animator;
public enum Status {
/**
* 关闭
*/
CLOSE,
/**
* 打开
*/
OPEN;
public static Status valueOf(int stats) {
if (0 == stats) {
return CLOSE;
} else if (1 == stats) {
return OPEN;
} else {
return CLOSE;
}
}
}
private static final int DEFAULT_DURATION = 300;
private View mFrontView;
private View mAnimView;
private View mBehindView;
private float mTouchSlop;
private float mInitMotionY;
private float mInitMotionX;
private View mTarget;
private float mSlideOffset;
private Status mStatus = Status.CLOSE;
private boolean isFirstShowBehindView = true;
private long mDuration = DEFAULT_DURATION;
private int mDefaultPanel = 0;
private int animHeight;
public SlideAnimLayout(Context context) {
this(context, null);
}
public SlideAnimLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public SlideAnimLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
@SuppressLint("CustomViewStyleable")
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.SlideLayout, defStyleAttr, 0);
mDuration = a.getInt(R.styleable.SlideLayout_duration, DEFAULT_DURATION);
mDefaultPanel = a.getInt(R.styleable.SlideLayout_default_panel, 0);
a.recycle();
//在我们认为用户正在滚动之前，触摸可以移动的像素距离
mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
}
/**
* 打开商详页
* @param smooth
*/
public void smoothOpen(boolean smooth) {
if (mStatus != Status.OPEN) {
mStatus = Status.OPEN;
//控件的高度+动画布局
final float height = -getMeasuredHeight() - animHeight;
LoggerUtils.i("SlideLayout---smoothOpen---"+height);
animatorSwitch(0, height, true, smooth ? mDuration : 0);
}
}
/**
* 关闭商详页
* @param smooth
*/
public void smoothClose(boolean smooth) {
if (mStatus != Status.CLOSE) {
mStatus = Status.CLOSE;
final float height = -getMeasuredHeight();
LoggerUtils.i("SlideLayout---smoothClose---"+height);
animatorSwitch(height, 0, true, smooth ? mDuration : 0);
}
}
/**
* 这个方法是在结束inflate之后才会执行
*/
@Override
protected void onFinishInflate() {
super.onFinishInflate();
final int childCount = getChildCount();
if (1 >= childCount) {
throw new RuntimeException("SlideDetailsLayout only accept childs more than 1!!");
}
LoggerUtils.i("获取子节点的个数"+childCount);
mFrontView = getChildAt(0);
mAnimView = getChildAt(1);
mBehindView = getChildAt(2);
mAnimView.post(new Runnable() {
@Override
public void run() {
animHeight = mAnimView.getHeight();
LoggerUtils.i("获取控件高度"+animHeight);
}
});
if(mDefaultPanel == 1){
post(new Runnable() {
@Override
public void run() {
//默认效果
smoothOpen(false);
}
});
}
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
setScrollStatusListener(null);
setOnSlideStatusListener(null);
if (animator!=null){
animator.cancel();
animator = null;
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//获取宽高
final int pWidth = MeasureSpec.getSize(widthMeasureSpec);
final int pHeight = MeasureSpec.getSize(heightMeasureSpec);
final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(pWidth, MeasureSpec.EXACTLY);
final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(pHeight, MeasureSpec.EXACTLY);
View child;
for (int i = 0; i < getChildCount(); i++) {
child = getChildAt(i);
//当控件是Gone的时候，不进行测量
if (child.getVisibility() == View.GONE) {
continue;
}
//当孩子控件是动画控件时，则特殊处理
if(getChildAt(i) == mAnimView){
child.measure(0,0);
int measuredHeight = child.getMeasuredHeight();
int makeMeasureSpec = MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY);
LoggerUtils.i("onMeasure获取控件高度"+measuredHeight);
measureChild(child, childWidthMeasureSpec, makeMeasureSpec);
} else{
measureChild(child, childWidthMeasureSpec, childHeightMeasureSpec);
}
}
setMeasuredDimension(pWidth, pHeight);
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
int top;
int bottom;
final int offset = (int) mSlideOffset;
View child;
for (int i = 0; i < getChildCount(); i++) {
child = getChildAt(i);
if (child.getVisibility() == GONE) {
continue;
}
LoggerUtils.i("onLayout，offset---"+offset);
int measuredHeight = getChildAt(1).getMeasuredHeight();
if (child == mBehindView) {
top = b + offset + measuredHeight ;
bottom = top + b - t + measuredHeight;
LoggerUtils.i("onLayout，mBehindView---"+top+"-----"+bottom);
}else if(child == mAnimView){
top = b + offset;
bottom = top - t + child.getMeasuredHeight();
LoggerUtils.i("onLayout，mAnimView---"+top+"-----"+bottom);
} else {
top = t + offset;
bottom = b + offset;
LoggerUtils.i("onLayout，other---"+top+"-----"+bottom);
}
child.layout(l, top, r, bottom);
}
}
/**
* 分发事件:事件分发的对象是事件。注意，事件分发是向下传递的，也就是父到子的顺序。
* 根据内部拦截状态，向其child或者自己分发事件
*
* @param ev
* @return
*/
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
ensureTarget();
if (null == mTarget) {
return false;
}
if (!isEnabled()) {
return false;
}
final int action = ev.getAction();
boolean shouldIntercept = false;
switch (action) {
case MotionEvent.ACTION_DOWN:
mInitMotionX = ev.getX();
mInitMotionY = ev.getY();
shouldIntercept = false;
break;
case MotionEvent.ACTION_MOVE:
final float x = ev.getX();
final float y = ev.getY();
final float xDiff = x - mInitMotionX;
final float yDiff = y - mInitMotionY;
boolean close = mStatus == Status.CLOSE && yDiff > 0;
boolean open = mStatus == Status.OPEN && yDiff < 0;
if (!canChildScrollVertically((int) yDiff)) {
final float xDiffers = Math.abs(xDiff);
final float yDiffers = Math.abs(yDiff);
if (yDiffers > mTouchSlop && yDiffers >= xDiffers && !(close || open)) {
shouldIntercept = true;
}
}
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
break;
default:
break;
}
return shouldIntercept;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
ensureTarget();
if (null == mTarget) {
return false;
}
if (!isEnabled()) {
return false;
}
boolean wantTouch = true;
final int action = ev.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
break;
case MotionEvent.ACTION_MOVE: {
//获取滑动点y轴的位移
final float y = ev.getY();
final float yDiff = y - mInitMotionY;
boolean childScrollVertically = canChildScrollVertically(((int) yDiff));
//在关闭状态并且滑动位移小于等于0时
boolean isDiffZero = yDiff<=0 && Status.OPEN == mStatus;
boolean isAnimOpen = Status.OPEN == mStatus && yDiff>=animHeight;
boolean isAnimClose = Status.CLOSE == mStatus && Math.abs(yDiff)>=animHeight;
if (childScrollVertically || isDiffZero) {
wantTouch = false;
}else if(isAnimOpen|| isAnimClose){
wantTouch = true;
} else {
processTouchEvent(yDiff);
wantTouch = true;
}
break;
}
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL: {
finishTouchEvent();
wantTouch = false;
break;
}
default:
break;
}
return wantTouch;
}
/**
* 设置方法是触摸滑动的时候
* @param offset offset
*/
private void processTouchEvent(final float offset) {
if (Math.abs(offset) < mTouchSlop) {
return;
}
final float oldOffset = mSlideOffset;
if (mStatus == Status.CLOSE) {
if (offset >= 0) {
mSlideOffset = 0;
} else {
mSlideOffset = offset;
}
if (mSlideOffset == oldOffset) {
return;
}
} else if (mStatus == Status.OPEN) {
final float pHeight = -getMeasuredHeight();
if (offset <= 0) {
mSlideOffset = pHeight;
} else {
mSlideOffset = pHeight- animHeight + offset;
}
if (mSlideOffset == oldOffset) {
return;
}
}
if (Status.CLOSE == mStatus) {
if (offset <= -animHeight/2) {
LoggerUtils.i("准备翻下页，已超过一半");
if(listener!=null){
listener.onStatusChanged(mStatus, true);
}
} else {
LoggerUtils.i("准备翻下页，不超过一半");
if(listener!=null){
listener.onStatusChanged(mStatus, false);
}
}
} else if (Status.OPEN == mStatus) {
if ((offset ) >= animHeight/2) {
if(listener!=null){
listener.onStatusChanged(mStatus, false);
}
LoggerUtils.i("准备翻上页，已超过一半:offset:"+offset+"--->pHeight:"+"--->:"+animHeight);
} else {
if(listener!=null){
listener.onStatusChanged(mStatus, true);
}
LoggerUtils.i("准备翻上页，不超过一半"+offset+"--->pHeight:"+"--->:"+animHeight);
}
}
requestLayout();
}
/**
* 结束触摸
*/
private void finishTouchEvent() {
final int pHeight = getMeasuredHeight();
LoggerUtils.i("finishTouchEvent------pHeight---"+pHeight);
final float offset = mSlideOffset;
boolean changed = false;
if (Status.CLOSE == mStatus) {
if (offset <= -animHeight /2) {
mSlideOffset = -pHeight - animHeight;
mStatus = Status.OPEN;
changed = true;
} else {
mSlideOffset = 0;
}
LoggerUtils.i("finishTouchEvent----CLOSE--mSlideOffset---"+mSlideOffset);
} else if (Status.OPEN == mStatus) {
if ((offset + pHeight) >= -animHeight/2) {
mSlideOffset = 0;
mStatus = Status.CLOSE;
changed = true;
} else {
mSlideOffset = -pHeight - animHeight;
}
LoggerUtils.i("finishTouchEvent----OPEN-----"+mSlideOffset);
}
animatorSwitch(offset, mSlideOffset, changed);
}
/**
* 共同调用的方法
*/
private void animatorSwitch(final float start, final float end, final boolean changed) {
animatorSwitch(start, end, changed, mDuration);
}
private void animatorSwitch(final float start, final float end,
final boolean changed, final long duration) {
animator = ValueAnimator.ofFloat(start, end);
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
mSlideOffset = (float) animation.getAnimatedValue();
LoggerUtils.i("animatorSwitch----onAnimationUpdate-----"+mSlideOffset);
requestLayout();
}
});
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
if (changed) {
if (mStatus == Status.OPEN && isFirstShowBehindView) {
isFirstShowBehindView = false;
mBehindView.setVisibility(VISIBLE);
}
if (onSlideStatusListener!=null){
onSlideStatusListener.onStatusChanged(mStatus);
}
}
}
});
animator.setDuration(duration);
animator.start();
}
private void ensureTarget() {
if (mStatus == Status.CLOSE) {
mTarget = mFrontView;
} else {
mTarget = mBehindView;
}
}
/**
* 是否可以滑动，direction为负数时表示向下滑动，反之表示向上滑动。
* @param direction direction
* @return
*/
protected boolean canChildScrollVertically(int direction) {
if (mTarget instanceof AbsListView) {
return canListViewScroll((AbsListView) mTarget);
} else if (mTarget instanceof FrameLayout || mTarget instanceof RelativeLayout ||
mTarget instanceof LinearLayout) {
View child;
for (int i = 0; i < ((ViewGroup) mTarget).getChildCount(); i++) {
child = ((ViewGroup) mTarget).getChildAt(i);
if (child instanceof AbsListView) {
return canListViewScroll((AbsListView) child);
}
}
}
return ViewCompat.canScrollVertically(mTarget, -direction);
}
protected boolean canListViewScroll(AbsListView absListView) {
if (mStatus == Status.OPEN) {
return absListView.getChildCount() > 0
&& (absListView.getFirstVisiblePosition() > 0
|| absListView.getChildAt(0).getTop() < absListView.getPaddingTop());
} else {
final int count = absListView.getChildCount();
return count > 0 && (absListView.getLastVisiblePosition() < count - 1
|| absListView.getChildAt(count - 1).getBottom() > absListView.getMeasuredHeight());
}
}
@Override
protected Parcelable onSaveInstanceState() {
SavedState ss = new SavedState(super.onSaveInstanceState());
ss.offset = mSlideOffset;
ss.status = mStatus.ordinal();
return ss;
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mSlideOffset = ss.offset;
mStatus = Status.valueOf(ss.status);
if (mStatus == Status.OPEN) {
mBehindView.setVisibility(VISIBLE);
}
requestLayout();
}
private static class SavedState extends BaseSavedState {
private float offset;
private int status;
SavedState(Parcel source) {
super(source);
offset = source.readFloat();
status = source.readInt();
}
SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeFloat(offset);
out.writeInt(status);
}
public static final Creator<SavedState> CREATOR = new Creator<SlideAnimLayout.SavedState>() {
@Override
public SlideAnimLayout.SavedState createFromParcel(Parcel in) {
return new SlideAnimLayout.SavedState(in);
}
@Override
public SlideAnimLayout.SavedState[] newArray(int size) {
return new SlideAnimLayout.SavedState[size];
}
};
}
public interface onScrollStatusListener{
/**
* 监听方法
* @param status 状态
* @param isHalf 是否是一半距离
*/
void onStatusChanged(Status status, boolean isHalf);
}
private onScrollStatusListener listener;
public void setScrollStatusListener(onScrollStatusListener listener){
this.listener = listener;
}
private OnSlideStatusListener onSlideStatusListener;
public interface OnSlideStatusListener {
void onStatusChanged(Status status);
}
public void setOnSlideStatusListener(OnSlideStatusListener listener){
this.onSlideStatusListener = listener;
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
YCSlideLib/src/main/java/com/yc/slide/SlideLayout.java | Java | package com.yc.slide;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import androidx.core.view.ViewCompat;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211/YCShopDetailLayout
* time : 2018/6/6
* desc : SlideLayout
* revise:
* </pre>
*/
public class SlideLayout extends ViewGroup {
private static final float DEFAULT_PERCENT = 0.2f;
private static final int DEFAULT_DURATION = 300;
private View mFrontView;
private View mBehindView;
private View mTarget;
private float mTouchSlop;
private float mInitMotionY;
private float mInitMotionX;
private float mSlideOffset;
private Status mStatus = Status.CLOSE;
private boolean isFirstShowBehindView = true;
private float mPercent = DEFAULT_PERCENT;
private long mDuration = DEFAULT_DURATION;
private int mDefaultPanel = 0;
/**
* 状态，使用枚举
*/
public enum Status {
CLOSE,
OPEN;
public static Status valueOf(int stats) {
if (0 == stats) {
return CLOSE;
} else if (1 == stats) {
return OPEN;
} else {
return CLOSE;
}
}
}
public SlideLayout(Context context) {
this(context, null);
}
public SlideLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public SlideLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.SlideLayout, defStyleAttr, 0);
mPercent = a.getFloat(R.styleable.SlideLayout_percent, DEFAULT_PERCENT);
mDuration = a.getInt(R.styleable.SlideLayout_duration, DEFAULT_DURATION);
mDefaultPanel = a.getInt(R.styleable.SlideLayout_default_panel, 0);
a.recycle();
mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
final int childCount = getChildCount();
if (1 >= childCount) {
throw new RuntimeException("SlideDetailsLayout only accept child more than 1!!");
}
mFrontView = getChildAt(0);
mBehindView = getChildAt(1);
if(mDefaultPanel == 1){
this.post(new Runnable() {
@Override
public void run() {
smoothOpen(false);
}
});
}
}
/**
* 测量
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
final int pWidth = MeasureSpec.getSize(widthMeasureSpec);
final int pHeight = MeasureSpec.getSize(heightMeasureSpec);
final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(pWidth, MeasureSpec.EXACTLY);
final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(pHeight, MeasureSpec.EXACTLY);
View child;
for (int i = 0; i < getChildCount(); i++) {
child = getChildAt(i);
if (child.getVisibility() == GONE) {
continue;
}
measureChild(child, childWidthMeasureSpec, childHeightMeasureSpec);
}
setMeasuredDimension(pWidth, pHeight);
}
/**
* 绘制
*/
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
}
/**
* 布局
*/
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
int top;
int bottom;
final int offset = (int) mSlideOffset;
View child;
for (int i = 0; i < getChildCount(); i++) {
child = getChildAt(i);
if (child.getVisibility() == GONE) {
continue;
}
if (child == mBehindView) {
top = b + offset;
bottom = top + b - t;
} else {
top = t + offset;
bottom = b + offset;
}
child.layout(l, top, r, bottom);
}
}
/**
* 拦截事件
* @param ev ev
* @return
*/
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
ensureTarget();
if (null == mTarget) {
return false;
}
if (!isEnabled()) {
return false;
}
final int action = ev.getAction();
boolean shouldIntercept = false;
switch (action) {
case MotionEvent.ACTION_DOWN: {
mInitMotionX = ev.getX();
mInitMotionY = ev.getY();
shouldIntercept = false;
break;
}
case MotionEvent.ACTION_MOVE: {
final float x = ev.getX();
final float y = ev.getY();
final float xDiff = x - mInitMotionX;
final float yDiff = y - mInitMotionY;
boolean close = mStatus == SlideLayout.Status.CLOSE && yDiff > 0;
boolean open = mStatus == SlideLayout.Status.OPEN && yDiff < 0;
if (!canChildScrollVertically((int) yDiff)) {
final float xDiffers = Math.abs(xDiff);
final float yDiffers = Math.abs(yDiff);
if (yDiffers > mTouchSlop && yDiffers >= xDiffers && !(close || open)) {
shouldIntercept = true;
}
}
break;
}
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL: {
shouldIntercept = false;
break;
}
default:
break;
}
return shouldIntercept;
}
/**
* 触摸事件
* @param ev ev
* @return true表示自己处理，false表示自己处理不了
*/
@Override
public boolean onTouchEvent(MotionEvent ev) {
ensureTarget();
if (null == mTarget) {
return false;
}
if (!isEnabled()) {
return false;
}
boolean wantTouch = true;
final int action = ev.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
if (mTarget instanceof View) {
wantTouch = true;
}
break;
case MotionEvent.ACTION_MOVE:
final float y = ev.getY();
final float yDiff = y - mInitMotionY;
if (canChildScrollVertically(((int) yDiff))) {
wantTouch = false;
} else {
processTouchEvent(yDiff);
wantTouch = true;
}
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
finishTouchEvent();
wantTouch = false;
break;
default:
break;
}
return wantTouch;
}
private void processTouchEvent(final float offset) {
if (Math.abs(offset) < mTouchSlop) {
return;
}
final float oldOffset = mSlideOffset;
if (mStatus == Status.CLOSE) {
if (offset >= 0) {
mSlideOffset = 0;
} else {
mSlideOffset = offset;
}
if (mSlideOffset == oldOffset) {
return;
}
} else if (mStatus == Status.OPEN) {
final float pHeight = -getMeasuredHeight();
if (offset <= 0) {
mSlideOffset = pHeight;
} else {
final float newOffset = pHeight + offset;
mSlideOffset = newOffset;
}
if (mSlideOffset == oldOffset) {
return;
}
}
requestLayout();
}
private void finishTouchEvent() {
final int pHeight = getMeasuredHeight();
final int percent = (int) (pHeight * mPercent);
final float offset = mSlideOffset;
boolean changed = false;
if (Status.CLOSE == mStatus) {
if (offset <= -percent) {
mSlideOffset = -pHeight;
mStatus = Status.OPEN;
changed = true;
} else {
mSlideOffset = 0;
}
} else if (Status.OPEN == mStatus) {
if ((offset + pHeight) >= percent) {
mSlideOffset = 0;
mStatus = Status.CLOSE;
changed = true;
} else {
mSlideOffset = -pHeight;
}
}
animatorSwitch(offset, mSlideOffset, changed);
}
private void animatorSwitch(final float start, final float end, final boolean changed) {
animatorSwitch(start, end, changed, mDuration);
}
private void animatorSwitch(final float start, final float end, final boolean changed, final long duration) {
ValueAnimator animator = ValueAnimator.ofFloat(start, end);
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
mSlideOffset = (float) animation.getAnimatedValue();
requestLayout();
}
});
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
if (changed) {
if (mStatus == Status.OPEN) {
checkAndFirstOpenPanel();
}
if (null != mOnSlideDetailsListener) {
mOnSlideDetailsListener.onStatusChanged(mStatus);
}
}
}
});
animator.setDuration(duration);
animator.start();
}
private void checkAndFirstOpenPanel() {
if (isFirstShowBehindView) {
isFirstShowBehindView = false;
mBehindView.setVisibility(VISIBLE);
}
}
private void ensureTarget() {
if (mStatus == Status.CLOSE) {
mTarget = mFrontView;
} else {
mTarget = mBehindView;
}
}
protected boolean canChildScrollVertically(int direction) {
if (mTarget instanceof AbsListView) {
return canListViewScroll((AbsListView) mTarget);
} else if (mTarget instanceof FrameLayout || mTarget instanceof RelativeLayout ||
mTarget instanceof LinearLayout) {
View child;
for (int i = 0; i < ((ViewGroup) mTarget).getChildCount(); i++) {
child = ((ViewGroup) mTarget).getChildAt(i);
if (child instanceof AbsListView) {
return canListViewScroll((AbsListView) child);
}
}
}
return ViewCompat.canScrollVertically(mTarget, -direction);
}
protected boolean canListViewScroll(AbsListView absListView) {
if (mStatus == Status.OPEN) {
return absListView.getChildCount() > 0
&& (absListView.getFirstVisiblePosition() > 0
|| absListView.getChildAt(0).getTop() < absListView.getPaddingTop());
} else {
final int count = absListView.getChildCount();
return count > 0
&& (absListView.getLastVisiblePosition() < count - 1
|| absListView.getChildAt(count - 1).getBottom() > absListView.getMeasuredHeight());
}
}
@Override
protected Parcelable onSaveInstanceState() {
SavedState ss = new SavedState(super.onSaveInstanceState());
ss.offset = mSlideOffset;
ss.status = mStatus.ordinal();
return ss;
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mSlideOffset = ss.offset;
mStatus = Status.valueOf(ss.status);
if (mStatus == Status.OPEN) {
mBehindView.setVisibility(VISIBLE);
}
requestLayout();
}
static class SavedState extends BaseSavedState {
private float offset;
private int status;
SavedState(Parcel source) {
super(source);
offset = source.readFloat();
status = source.readInt();
}
SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeFloat(offset);
out.writeInt(status);
}
public static final Creator<SavedState> CREATOR =
new Creator<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
/*------------------------------------回调接口------------------------------------------------*/
private OnSlideDetailsListener mOnSlideDetailsListener;
public interface OnSlideDetailsListener {
void onStatusChanged(Status status);
}
public void setOnSlideDetailsListener(OnSlideDetailsListener listener) {
this.mOnSlideDetailsListener = listener;
}
/*------------------------------------相关方法------------------------------------------------*/
public void smoothOpen(boolean smooth) {
if (mStatus != Status.OPEN) {
mStatus = Status.OPEN;
final float height = -getMeasuredHeight();
animatorSwitch(0, height, true, smooth ? mDuration : 0);
}
}
public void smoothClose(boolean smooth) {
if (mStatus != Status.CLOSE) {
mStatus = Status.CLOSE;
final float height = -getMeasuredHeight();
animatorSwitch(height, 0, true, smooth ? mDuration : 0);
}
}
public void setPercent(float percent) {
this.mPercent = percent;
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
YCSlideLib/src/main/java/com/yc/slide/VerticalScrollView.java | Java | package com.yc.slide;
import android.content.Context;
import android.os.Build;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.ScrollView;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211/YCShopDetailLayout
* time : 2018/6/6
* desc : 当ScrollView在最顶部或者最底部的时候，不消费事件
* revise:
* </pre>
*/
public class VerticalScrollView extends ScrollView {
private float downX;
private float downY;
public VerticalScrollView(Context context) {
this(context, null);
}
public VerticalScrollView(Context context, AttributeSet attrs) {
this(context, attrs, android.R.attr.scrollViewStyle);
}
public VerticalScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
downX = ev.getX();
downY = ev.getY();
//如果滑动到了最底部，就允许继续向上滑动加载下一页，否者不允许
//如果子节点不希望父进程拦截触摸事件，则为true。
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float dx = ev.getX() - downX;
float dy = ev.getY() - downY;
boolean allowParentTouchEvent;
if (Math.abs(dy) > Math.abs(dx)) {
if (dy > 0) {
//位于顶部时下拉，让父View消费事件
allowParentTouchEvent = isTop();
} else {
//位于底部时上拉，让父View消费事件
allowParentTouchEvent = isBottom();
}
} else {
//水平方向滑动
allowParentTouchEvent = true;
}
getParent().requestDisallowInterceptTouchEvent(!allowParentTouchEvent);
break;
default:
break;
}
return super.dispatchTouchEvent(ev);
}
private boolean isTop() {
return !canScrollVertically(-1);
}
private boolean isBottom() {
return !canScrollVertically(1);
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/build.gradle | Gradle | apply plugin: 'com.android.application'
android {
compileSdkVersion 29
defaultConfig {
applicationId "com.ycbjie.ycshopdetaillayout"
minSdkVersion 17
targetSdkVersion 29
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.3.0'
implementation 'androidx.recyclerview:recyclerview:1.2.1'
// implementation project(path: ':YCSlideLib')
implementation 'com.github.yangchong211:YCSlideLayout:1.1.6'
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/FiveActivity.java | Java | package com.yc.ycshopdetaillayout;
import android.os.Bundle;
import android.view.View;
import android.widget.ScrollView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.slide.VerticalScrollView;
import com.ycbjie.ycshopdetaillayout.R;
public class FiveActivity extends AppCompatActivity {
private VerticalScrollView scrollView;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.shop_main);
scrollView = findViewById(R.id.scrollView);
findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//scrollView.scrollTo(0,0);
scrollView.post(new Runnable() {
@Override
public void run() {
//ScrollView滑动到顶部
scrollView.fullScroll(ScrollView.FOCUS_UP);
}
});
}
});
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/MainActivity.java | Java | package com.yc.ycshopdetaillayout;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.slide.LoggerUtils;
import com.yc.ycshopdetaillayout.first.FirstActivity;
import com.yc.ycshopdetaillayout.second.SecondActivity;
import com.yc.ycshopdetaillayout.third.ThirdActivity;
import com.ycbjie.ycshopdetaillayout.R;
import com.yc.ycshopdetaillayout.four.FourActivity;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
LoggerUtils.setIsLog(true);
findViewById(R.id.tv_1).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this, FirstActivity.class));
}
});
findViewById(R.id.tv_2).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this, SecondActivity.class));
}
});
findViewById(R.id.tv_3).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this, ThirdActivity.class));
}
});
findViewById(R.id.tv_4).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this,FourActivity.class));
}
});
findViewById(R.id.tv_5).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this,FiveActivity.class));
}
});
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/VerticalRecyclerView.java | Java | package com.yc.ycshopdetaillayout;
import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.recyclerview.widget.StaggeredGridLayoutManager;
/**
* <pre>
* @author yangchong
* blog :
* time : 2018/6/6
* desc : 当WebView在最顶部或者最底部的时候，不消费事件
* revise:
* </pre>
*/
public class VerticalRecyclerView extends RecyclerView {
private float downX;
private float downY;
/** 第一个可见的item的位置 */
private int firstVisibleItemPosition;
/** 第一个的位置 */
private int[] firstPositions;
/** 最后一个可见的item的位置 */
private int lastVisibleItemPosition;
/** 最后一个的位置 */
private int[] lastPositions;
private boolean isTop;
private boolean isBottom;
public VerticalRecyclerView(Context context) {
this(context, null);
}
public VerticalRecyclerView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public VerticalRecyclerView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
RecyclerView.LayoutManager layoutManager = getLayoutManager();
if (layoutManager != null) {
if (layoutManager instanceof GridLayoutManager) {
lastVisibleItemPosition = ((GridLayoutManager) layoutManager).findLastVisibleItemPosition();
firstVisibleItemPosition = ((GridLayoutManager) layoutManager).findFirstVisibleItemPosition();
} else if (layoutManager instanceof LinearLayoutManager) {
lastVisibleItemPosition = ((LinearLayoutManager) layoutManager).findLastVisibleItemPosition();
firstVisibleItemPosition = ((LinearLayoutManager) layoutManager).findFirstVisibleItemPosition();
} else if (layoutManager instanceof StaggeredGridLayoutManager) {
StaggeredGridLayoutManager staggeredGridLayoutManager = (StaggeredGridLayoutManager) layoutManager;
if (lastPositions == null) {
lastPositions = new int[staggeredGridLayoutManager.getSpanCount()];
firstPositions = new int[staggeredGridLayoutManager.getSpanCount()];
}
staggeredGridLayoutManager.findLastVisibleItemPositions(lastPositions);
staggeredGridLayoutManager.findFirstVisibleItemPositions(firstPositions);
lastVisibleItemPosition = findMax(lastPositions);
firstVisibleItemPosition = findMin(firstPositions);
}
} else {
throw new RuntimeException("Unsupported LayoutManager used. Valid ones are LinearLayoutManager, GridLayoutManager and StaggeredGridLayoutManager");
}
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
downX = ev.getX();
downY = ev.getY();
//如果滑动到了最底部，就允许继续向上滑动加载下一页，否者不允许
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float dx = ev.getX() - downX;
float dy = ev.getY() - downY;
boolean allowParentTouchEvent;
if (Math.abs(dy) > Math.abs(dx)) {
if (dy > 0) {
//位于顶部时下拉，让父View消费事件
allowParentTouchEvent = isTop = firstVisibleItemPosition == 0 && getChildAt(0).getTop() >= 0;
} else {
//位于底部时上拉，让父View消费事件
int visibleItemCount = layoutManager.getChildCount();
int totalItemCount = layoutManager.getItemCount();
allowParentTouchEvent = isBottom = visibleItemCount > 0 && (lastVisibleItemPosition) >= totalItemCount - 1 && getChildAt(getChildCount() - 1).getBottom() <= getHeight();
}
} else {
//水平方向滑动
allowParentTouchEvent = true;
}
getParent().requestDisallowInterceptTouchEvent(!allowParentTouchEvent);
break;
default:
break;
}
return super.dispatchTouchEvent(ev);
}
private int findMax(int[] lastPositions) {
int max = lastPositions[0];
for (int value : lastPositions) {
if (value >= max) {
max = value;
}
}
return max;
}
private int findMin(int[] firstPositions) {
int min = firstPositions[0];
for (int value : firstPositions) {
if (value < min) {
min = value;
}
}
return min;
}
public boolean isTop() {
return isTop;
}
public boolean isBottom() {
return isBottom;
}
public void goTop() {
scrollToPosition(0);
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/VerticalWebView.java | Java | package com.yc.ycshopdetaillayout;
import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.webkit.WebView;
/**
* <pre>
* @author yangchong
* blog :
* time : 2018/6/6
* desc : 当WebView在最顶部或者最底部的时候，不消费事件
* revise:
* </pre>
*/
public class VerticalWebView extends WebView {
private float downX;
private float downY;
public VerticalWebView(Context context) {
this(context, null);
}
public VerticalWebView(Context context, AttributeSet attrs) {
this(context, attrs, android.R.attr.webViewStyle);
}
public VerticalWebView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
downX = ev.getX();
downY = ev.getY();
//如果滑动到了最底部，就允许继续向上滑动加载下一页，否者不允许
getParent().requestDisallowInterceptTouchEvent(true);
break;
case MotionEvent.ACTION_MOVE:
float dx = ev.getX() - downX;
float dy = ev.getY() - downY;
boolean allowParentTouchEvent;
if (Math.abs(dy) > Math.abs(dx)) {
if (dy > 0) {
//位于顶部时下拉，让父View消费事件
allowParentTouchEvent = isTop();
} else {
//位于底部时上拉，让父View消费事件
allowParentTouchEvent = isBottom();
}
} else {
//水平方向滑动
allowParentTouchEvent = true;
}
getParent().requestDisallowInterceptTouchEvent(!allowParentTouchEvent);
break;
default:
break;
}
return super.dispatchTouchEvent(ev);
}
private boolean isTop() {
return getScrollY() <= 0;
}
private boolean isBottom() {
return getHeight() + getScrollY() >= getContentHeight() * getScale();
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/first/FirstActivity.java | Java | package com.yc.ycshopdetaillayout.first;
import android.annotation.SuppressLint;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.LinearLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import com.yc.slide.SlideLayout;
import com.ycbjie.ycshopdetaillayout.R;
public class FirstActivity extends AppCompatActivity {
private SlideLayout mSlideDetailsLayout;
private ShopMainFragment shopMainFragment;
private WebView webView;
private LinearLayout mLlDetail;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_first);
initView();
initShopMainFragment();
initSlideDetailsLayout();
initWebView();
}
private void initView() {
mSlideDetailsLayout = findViewById(R.id.slideDetailsLayout);
webView = findViewById(R.id.wb_view);
mLlDetail = findViewById(R.id.ll_detail);
}
private void initShopMainFragment() {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fm.beginTransaction();
if(shopMainFragment==null){
shopMainFragment = new ShopMainFragment();
fragmentTransaction
.replace(R.id.fl_shop_main, shopMainFragment)
.commit();
}else {
fragmentTransaction.show(shopMainFragment);
}
}
private void initSlideDetailsLayout() {
mSlideDetailsLayout.setOnSlideDetailsListener(new SlideLayout.OnSlideDetailsListener() {
@Override
public void onStatusChanged(SlideLayout.Status status) {
if (status == SlideLayout.Status.OPEN) {
//当前为图文详情页
Log.e("FirstActivity","下拉回到商品详情");
shopMainFragment.changBottomView(true);
} else {
//当前为商品详情页
Log.e("FirstActivity","继续上拉，查看图文详情");
shopMainFragment.changBottomView(false);
}
}
});
}
@SuppressLint({"ObsoleteSdkInt", "SetJavaScriptEnabled"})
private void initWebView() {
final WebSettings settings = webView.getSettings();
settings.setJavaScriptEnabled(true);
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
settings.setUseWideViewPort(true);
settings.setDomStorageEnabled(true);
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
});
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR_MR1) {
new Object() {
void setLoadWithOverviewMode(boolean overview) {
settings.setLoadWithOverviewMode(overview);
}
}.setLoadWithOverviewMode(true);
}
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
getWindow().getDecorView().post(new Runnable() {
@Override
public void run() {
webView.loadUrl("https://www.jianshu.com/p/d745ea0cb5bd");
}
});
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/first/ShopDetailFragment.java | Java | package com.yc.ycshopdetaillayout.first;
import android.annotation.SuppressLint;
import android.os.Build;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import com.ycbjie.ycshopdetaillayout.R;
public class ShopDetailFragment extends Fragment {
private WebView webView;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(getContentView(), container , false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
initWebView();
}
private int getContentView() {
return R.layout.include_shop_detail;
}
private void initView(View view) {
webView = view.findViewById(R.id.wb_view);
}
@SuppressLint("ObsoleteSdkInt")
private void initWebView() {
final WebSettings settings = webView.getSettings();
settings.setJavaScriptEnabled(true);
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
settings.setUseWideViewPort(true);
settings.setDomStorageEnabled(true);
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
});
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR_MR1) {
new Object() {
void setLoadWithOverviewMode(boolean overview) {
settings.setLoadWithOverviewMode(overview);
}
}.setLoadWithOverviewMode(true);
}
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
webView.loadUrl("https://www.jianshu.com/p/d745ea0cb5bd");
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/first/ShopMainFragment.java | Java | package com.yc.ycshopdetaillayout.first;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import com.ycbjie.ycshopdetaillayout.R;
public class ShopMainFragment extends Fragment {
private ScrollView mScrollView;
private TextView mTvGoodsTitle;
private TextView mTvNewPrice;
private TextView mTvOldPrice;
private LinearLayout mLlActivity;
private LinearLayout mLlCurrentGoods;
private TextView mTvCurrentGoods;
private ImageView mIvEnsure;
private LinearLayout mLlComment;
private TextView mTvCommentCount;
private TextView mTvGoodComment;
private ImageView mIvCommentRight;
private LinearLayout mLlEmptyComment;
private LinearLayout mLlRecommend;
private TextView mTvBottomView;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(getContentView(), container , false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
}
private int getContentView() {
return R.layout.include_shop_main;
}
private void initView(View view) {
mScrollView = view.findViewById(R.id.scrollView);
mTvGoodsTitle = view.findViewById(R.id.tv_goods_title);
mTvNewPrice = view.findViewById(R.id.tv_new_price);
mTvOldPrice = view.findViewById(R.id.tv_old_price);
mLlCurrentGoods = view.findViewById(R.id.ll_current_goods);
mTvCurrentGoods = view.findViewById(R.id.tv_current_goods);
mIvEnsure = view.findViewById(R.id.iv_ensure);
mLlComment = view.findViewById(R.id.ll_comment);
mTvCommentCount = view.findViewById(R.id.tv_comment_count);
mTvGoodComment = view.findViewById(R.id.tv_good_comment);
mIvCommentRight = view.findViewById(R.id.iv_comment_right);
mLlEmptyComment = view.findViewById(R.id.ll_empty_comment);
mLlRecommend = view.findViewById(R.id.ll_recommend);
mTvBottomView = view.findViewById(R.id.tv_bottom_view);
}
public void changBottomView(boolean isDetail) {
if(isDetail){
mTvBottomView.setText("下拉回到商品详情");
}else {
mTvBottomView.setText("继续上拉，查看图文详情");
}
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/four/FourActivity.java | Java | package com.yc.ycshopdetaillayout.four;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Color;
import android.os.Build;
import android.os.Bundle;
import android.view.View;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.widget.NestedScrollView;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import com.yc.slide.LoggerUtils;
import com.yc.slide.SlideAnimLayout;
import com.yc.ycshopdetaillayout.second.ShopMain1Fragment;
import com.ycbjie.ycshopdetaillayout.R;
public class FourActivity extends AppCompatActivity {
private SlideAnimLayout mSlideDetailsLayout;
private ShopMain1Fragment shopMainFragment;
private WebView webView;
private LinearLayout ll_page_more;
private ImageView mIvMoreImg;
private TextView mTvMoreText;
private TextView tvBarGoods;
private TextView tvBarDetail;
private LinearLayout root;
private NestedScrollView scrollView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_four);
initView();
initListener();
initShopMainFragment();
initSlideDetailsLayout();
initWebView();
}
private void initView() {
root = findViewById(R.id.root);
mSlideDetailsLayout = findViewById(R.id.slideDetailsLayout);
ll_page_more = findViewById(R.id.ll_page_more);
webView = findViewById(R.id.wb_view);
mIvMoreImg = findViewById(R.id.iv_more_img);
mTvMoreText = findViewById(R.id.tv_more_text);
tvBarGoods = findViewById(R.id.tv_bar_goods);
tvBarDetail = findViewById(R.id.tv_bar_detail);
scrollView = findViewById(R.id.scrollView);
}
private void initListener() {
View.OnClickListener onClickListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.tv_bar_goods:
tvBarGoods.setTextColor(Color.RED);
tvBarDetail.setTextColor(Color.BLACK);
mSlideDetailsLayout.smoothClose(true);
break;
case R.id.tv_bar_detail:
tvBarGoods.setTextColor(Color.BLACK);
tvBarDetail.setTextColor(Color.RED);
mSlideDetailsLayout.smoothOpen(true);
break;
default:
break;
}
}
};
tvBarGoods.setOnClickListener(onClickListener);
tvBarDetail.setOnClickListener(onClickListener);
}
private void initShopMainFragment() {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fm.beginTransaction();
if(shopMainFragment==null){
shopMainFragment = new ShopMain1Fragment();
fragmentTransaction
.replace(R.id.fl_shop_main2, shopMainFragment)
.commit();
}else {
fragmentTransaction.show(shopMainFragment);
}
}
private void initSlideDetailsLayout() {
mSlideDetailsLayout.setScrollStatusListener(new SlideAnimLayout.onScrollStatusListener() {
@Override
public void onStatusChanged(SlideAnimLayout.Status mNowStatus, boolean isHalf) {
if(mNowStatus== SlideAnimLayout.Status.CLOSE){
//打开
if(isHalf){
mTvMoreText.setText("释放，查看图文详情");
mIvMoreImg.animate().rotation(0);
LoggerUtils.i("onStatusChanged---CLOSE---释放"+isHalf);
}else{//关闭
mTvMoreText.setText("继续上拉，查看图文详情");
mIvMoreImg.animate().rotation(180);
LoggerUtils.i("onStatusChanged---CLOSE---继续上拉"+isHalf);
}
}else{
//打开
if(isHalf){
mTvMoreText.setText("下拉回到商品详情");
mIvMoreImg.animate().rotation(0);
LoggerUtils.i("onStatusChanged---OPEN---下拉回到商品详情"+isHalf);
}else{//关闭
mTvMoreText.setText("释放回到商品详情");
mIvMoreImg.animate().rotation(180);
LoggerUtils.i("onStatusChanged---OPEN---释放回到商品详情"+isHalf);
}
}
}
});
mSlideDetailsLayout.setOnSlideStatusListener(new SlideAnimLayout.OnSlideStatusListener() {
@Override
public void onStatusChanged(SlideAnimLayout.Status status) {
FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams)
root.getLayoutParams();
if (status == SlideAnimLayout.Status.OPEN) {
layoutParams.topMargin = dip2px(FourActivity.this,44.0f);
root.setLayoutParams(layoutParams);
LoggerUtils.i("setOnSlideStatusListener---OPEN---下拉回到商品详情");
//scrollView.scrollTo(0,0);
scrollView.post(new Runnable() {
@Override
public void run() {
//ScrollView滑动到顶部
scrollView.fullScroll(ScrollView.FOCUS_UP);
}
});
} else {
layoutParams.topMargin = dip2px(FourActivity.this,0);
root.setLayoutParams(layoutParams);
LoggerUtils.i("setOnSlideStatusListener---CLOSE---上拉查看图文详情");
}
}
});
}
@SuppressLint({"ObsoleteSdkInt", "SetJavaScriptEnabled"})
private void initWebView() {
final WebSettings settings = webView.getSettings();
settings.setJavaScriptEnabled(true);
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
settings.setUseWideViewPort(true);
settings.setDomStorageEnabled(true);
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
});
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR_MR1) {
new Object() {
void setLoadWithOverviewMode(boolean overview) {
settings.setLoadWithOverviewMode(overview);
}
}.setLoadWithOverviewMode(true);
}
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
getWindow().getDecorView().post(new Runnable() {
@Override
public void run() {
webView.loadUrl("https://www.jianshu.com/p/d745ea0cb5bd");
}
});
}
public static int dip2px(Context context, float dpValue) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/second/SecondActivity.java | Java | package com.yc.ycshopdetaillayout.second;
import android.annotation.SuppressLint;
import android.os.Build;
import android.os.Bundle;
import android.view.View;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import com.yc.slide.SlideAnimLayout;
import com.ycbjie.ycshopdetaillayout.R;
public class SecondActivity extends AppCompatActivity {
private SlideAnimLayout mSlideDetailsLayout;
private ShopMain1Fragment shopMainFragment;
private WebView webView;
private LinearLayout ll_page_more;
private ImageView mIvMoreImg;
private TextView mTvMoreText;
private boolean isBtn = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
initView();
initShopMainFragment();
initSlideDetailsLayout();
initWebView();
findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (isBtn){
isBtn = false;
mSlideDetailsLayout.smoothOpen(true);
}else {
isBtn = true;
mSlideDetailsLayout.smoothClose(true);
}
}
});
}
private void initView() {
mSlideDetailsLayout = findViewById(R.id.slideDetailsLayout);
ll_page_more = findViewById(R.id.ll_page_more);
webView = findViewById(R.id.wb_view);
mIvMoreImg = findViewById(R.id.iv_more_img);
mTvMoreText = findViewById(R.id.tv_more_text);
}
private void initShopMainFragment() {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fm.beginTransaction();
if(shopMainFragment==null){
shopMainFragment = new ShopMain1Fragment();
fragmentTransaction
.replace(R.id.fl_shop_main2, shopMainFragment)
.commit();
}else {
fragmentTransaction.show(shopMainFragment);
}
}
private void initSlideDetailsLayout() {
mSlideDetailsLayout.setScrollStatusListener(new SlideAnimLayout.onScrollStatusListener() {
@Override
public void onStatusChanged(SlideAnimLayout.Status mNowStatus,boolean isHalf) {
if(mNowStatus==SlideAnimLayout.Status.CLOSE){
if(isHalf){//打开
mTvMoreText.setText("释放，查看图文详情");
mIvMoreImg.animate().rotation(0);
}else{//关闭
mTvMoreText.setText("继续上拉，查看图文详情");
mIvMoreImg.animate().rotation(180);
}
}else{
if(isHalf){//打开
mTvMoreText.setText("下拉回到商品详情");
mIvMoreImg.animate().rotation(0);
}else{//关闭
mTvMoreText.setText("释放回到商品详情");
mIvMoreImg.animate().rotation(180);
}
}
}
});
}
@SuppressLint({"ObsoleteSdkInt", "SetJavaScriptEnabled"})
private void initWebView() {
final WebSettings settings = webView.getSettings();
settings.setJavaScriptEnabled(true);
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
settings.setUseWideViewPort(true);
settings.setDomStorageEnabled(true);
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
});
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR_MR1) {
new Object() {
void setLoadWithOverviewMode(boolean overview) {
settings.setLoadWithOverviewMode(overview);
}
}.setLoadWithOverviewMode(true);
}
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
getWindow().getDecorView().post(new Runnable() {
@Override
public void run() {
webView.loadUrl("https://www.jianshu.com/p/d745ea0cb5bd");
}
});
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/second/ShopMain1Fragment.java | Java | package com.yc.ycshopdetaillayout.second;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;
import com.ycbjie.ycshopdetaillayout.R;
public class ShopMain1Fragment extends Fragment {
private ScrollView mScrollView;
private TextView mTvGoodsTitle;
private TextView mTvNewPrice;
private TextView mTvOldPrice;
private LinearLayout mLlActivity;
private LinearLayout mLlCurrentGoods;
private TextView mTvCurrentGoods;
private ImageView mIvEnsure;
private LinearLayout mLlComment;
private TextView mTvCommentCount;
private TextView mTvGoodComment;
private ImageView mIvCommentRight;
private LinearLayout mLlEmptyComment;
private LinearLayout mLlRecommend;
private TextView mTvBottomView;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(getContentView(), container , false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
}
private int getContentView() {
return R.layout.include_shop_main;
}
private void initView(View view) {
mScrollView = view.findViewById(R.id.scrollView);
mTvGoodsTitle = view.findViewById(R.id.tv_goods_title);
mTvNewPrice = view.findViewById(R.id.tv_new_price);
mTvOldPrice = view.findViewById(R.id.tv_old_price);
mLlCurrentGoods = view.findViewById(R.id.ll_current_goods);
mTvCurrentGoods = view.findViewById(R.id.tv_current_goods);
mIvEnsure = view.findViewById(R.id.iv_ensure);
mLlComment = view.findViewById(R.id.ll_comment);
mTvCommentCount = view.findViewById(R.id.tv_comment_count);
mTvGoodComment = view.findViewById(R.id.tv_good_comment);
mIvCommentRight = view.findViewById(R.id.iv_comment_right);
mLlEmptyComment = view.findViewById(R.id.ll_empty_comment);
mLlRecommend = view.findViewById(R.id.ll_recommend);
mTvBottomView = view.findViewById(R.id.tv_bottom_view);
}
public void changBottomView(boolean isDetail) {
if(isDetail){
mTvBottomView.setText("下拉回到商品详情");
}else {
mTvBottomView.setText("继续上拉，查看图文详情");
}
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/third/NoScrollWebView.java | Java | package com.yc.ycshopdetaillayout.third;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.webkit.WebView;
public class NoScrollWebView extends WebView {
public NoScrollWebView(Context context) {
super(context);
initView();
}
public NoScrollWebView(Context context, AttributeSet attrs) {
super(context, attrs);
initView();
}
public NoScrollWebView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView();
}
private void initView() {
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int mExpandSpec = View.MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, View.MeasureSpec.AT_MOST);
super.onMeasure(widthMeasureSpec, mExpandSpec);
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
app/src/main/java/com/yc/ycshopdetaillayout/third/ThirdActivity.java | Java | package com.yc.ycshopdetaillayout.third;
import android.annotation.SuppressLint;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.LinearLayout;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import com.yc.slide.SlideLayout;
import com.ycbjie.ycshopdetaillayout.R;
import com.yc.ycshopdetaillayout.first.ShopMainFragment;
/**
* Created by yc on 2018/7/23.
*/
public class ThirdActivity extends AppCompatActivity {
private SlideLayout mSlideDetailsLayout;
private ShopMainFragment shopMainFragment;
private WebView webView;
private LinearLayout mLlDetail;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_third);
initView();
initShopMainFragment();
initSlideDetailsLayout();
initWebView();
}
private void initView() {
mSlideDetailsLayout = findViewById(R.id.slideDetailsLayout);
webView = findViewById(R.id.wb_view);
mLlDetail = findViewById(R.id.ll_detail);
}
private void initShopMainFragment() {
FragmentManager fm = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fm.beginTransaction();
if(shopMainFragment==null){
shopMainFragment = new ShopMainFragment();
fragmentTransaction
.replace(R.id.fl_shop_main, shopMainFragment)
.commit();
}else {
fragmentTransaction.show(shopMainFragment);
}
}
private void initSlideDetailsLayout() {
mSlideDetailsLayout.setOnSlideDetailsListener(new SlideLayout.OnSlideDetailsListener() {
@Override
public void onStatusChanged(SlideLayout.Status status) {
if (status == SlideLayout.Status.OPEN) {
//当前为图文详情页
Log.e("FirstActivity","图文详情页");
shopMainFragment.changBottomView(true);
} else {
//当前为商品详情页
Log.e("FirstActivity","商品详情页");
shopMainFragment.changBottomView(false);
}
}
});
}
@SuppressLint({"ObsoleteSdkInt", "SetJavaScriptEnabled"})
private void initWebView() {
final WebSettings settings = webView.getSettings();
settings.setJavaScriptEnabled(true);
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
settings.setUseWideViewPort(true);
settings.setDomStorageEnabled(true);
webView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
});
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ECLAIR_MR1) {
new Object() {
void setLoadWithOverviewMode(boolean overview) {
settings.setLoadWithOverviewMode(overview);
}
}.setLoadWithOverviewMode(true);
}
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
getWindow().getDecorView().post(new Runnable() {
@Override
public void run() {
webView.loadUrl("https://www.jianshu.com/p/d745ea0cb5bd");
}
});
}
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | 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://jitpack.io' }
maven { url 'https://maven.google.com' }
}
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://jitpack.io' }
maven { url 'https://maven.google.com' }
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
settings.gradle | Gradle | include ':app', ':YCSlideLib'
| yangchong211/YCSlideLayout | 491 | 购物商场商品详情页面自定义控件，模仿淘宝、京东、考拉等商品详情页分页加载的UI效果。可以嵌套RecyclerView、WebView、ViewPager、ScrollView等等。支持设置上拉分页加载动画效果…… | Java | yangchong211 | 杨充 | Tencent |
Demo/build.gradle | Gradle | apply plugin: 'com.android.application'
android {
compileSdkVersion 29
buildToolsVersion '29.0.0'
defaultConfig {
applicationId "org.yczbj.ycvideoplayer"
minSdkVersion 17
targetSdkVersion 29
versionCode 28
versionName "2.8.0"
// dex突破65535的限制
multiDexEnabled true
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
}
lintOptions {
abortOnError false
}
}
dependencies {
implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation 'androidx.annotation:annotation:1.1.0'
implementation 'androidx.cardview:cardview:1.0.0'
implementation 'androidx.recyclerview:recyclerview:1.1.0'
implementation 'com.google.android.material:material:1.2.1'
implementation 'androidx.constraintlayout:constraintlayout:2.0.2'
//其他库
implementation 'com.github.bumptech.glide:glide:4.9.0' //谷歌图片加载库
implementation 'jp.wasabeef:glide-transformations:2.0.1'
//exo的UI库
implementation 'com.google.android.exoplayer:exoplayer-ui:2.11.3'
implementation 'com.google.android.exoplayer:exoplayer-core:2.11.3'
//弹幕
implementation 'com.github.ctiao:DanmakuFlameMaster:0.9.25'
implementation 'com.github.ctiao:ndkbitmap-armv7a:0.9.21'
// implementation project(path: ':VideoCache')
// implementation project(path: ':VideoPlayer')
// implementation project(path: ':VideoKernel')
// implementation project(path: ':VideoView')
// implementation project(path: ':MusicPlayer')
// implementation project(path: ':VideoM3u8')
// implementation project(path: ':VideoSqlLite')
implementation 'cn.yc:MusicPlayer:1.0.2'
implementation 'cn.yc:VideoPlayer:3.1.0'
implementation 'cn.yc:VideoCache:3.0.5'
implementation 'cn.yc:VideoKernel:3.0.6'
implementation 'cn.yc:VideoView:3.0.5'
implementation 'cn.yc:VideoM3u8:1.0.0'
implementation 'cn.yc:VideoSqlLite:1.0.2'
//自己封装的库，都有对应的案例项目【欢迎star】：https://github.com/yangchong211
implementation 'cn.yc:YCStatusBarLib:1.5.0'
implementation 'com.yc:PagerLib:1.0.4'
implementation 'cn.yc:YCStateLib:1.2.2'
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/assets/jzvd.html | HTML | <!DOCTYPE html>
<html>
<body>
<div class="content"></div>
<div id="cont" style="width:100%;height:200px">
</div>
<div style="height:100px"></div>
<h3 style="width:100%;text-align:center">This is webview</h3>
<div style="height:700px"></div>
<div id="cont1" style="width:65%;height:200px;float:right;">
</div>
<div style="height:800px"></div>
<script>
var cont=document.getElementById("cont");
jzvd.adViewJiaoZiVideoPlayer(-1,200,0,0,0)
<!--jzvd.adViewJiaoZiVideoPlayer(cont1.width,cont1.height,cont1.offsetTop,cont1.offsetLeft)-->
var cont1=document.getElementById("cont1");
jzvd.adViewJiaoZiVideoPlayer(210,120,cont1.offsetTop,cont1.offsetLeft,1)
</script>
</body>
</html> | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/BaseActivity.java | Java | package com.yc.ycvideoplayer;
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/BaseApplication.java | Java | package com.yc.ycvideoplayer;
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.music.utils.MusicSpUtils;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.player.VideoViewManager;
import com.yc.video.surface.SurfaceViewFactory;
import com.yc.videosqllite.manager.CacheConfig;
import com.yc.videosqllite.manager.LocationManager;
/**
* ================================================
* 作 者：杨充
* 版 本：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;
ScreenDensityUtils.setup(this);
ScreenDensityUtils.register(this,375.0f,
ScreenDensityUtils.MATCH_BASE_WIDTH,ScreenDensityUtils.MATCH_UNIT_DP);
//播放器配置，注意：此为全局配置，按需开启
PlayerFactory player = PlayerFactoryUtils.getPlayer(PlayerConstant.PlayerType.TYPE_IJK);
VideoViewManager.setConfig(VideoPlayerConfig.newBuilder()
//设置上下文
.setContext(this)
//设置视频全局埋点事件
.setBuriedPointEvent(new BuriedPointEventImpl())
//调试的时候请打开日志，方便排错
.setLogEnabled(true)
//设置ijk
.setPlayerFactory(player)
//创建SurfaceView
//.setRenderViewFactory(SurfaceViewFactory.create())
.build());
MusicSpUtils.init(this);
initVideoCache();
}
private void initVideoCache() {
CacheConfig cacheConfig = new CacheConfig();
cacheConfig.setIsEffective(true);
cacheConfig.setType(2);
cacheConfig.setContext(this);
cacheConfig.setCacheMax(1000);
cacheConfig.setLog(false);
LocationManager.getInstance().init(cacheConfig);
}
/**
* 程序终止的时候执行
*/
@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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/BuriedPointEventImpl.java | Java | package com.yc.ycvideoplayer;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.BuriedPointEvent;
import com.yc.videosqllite.manager.LocationManager;
import com.yc.videosqllite.model.VideoLocation;
public class BuriedPointEventImpl implements BuriedPointEvent {
/**
* 进入视频播放
* @param url 视频url
*/
@Override
public void playerIn(String url) {
VideoLogUtils.i("BuriedPointEvent---进入视频播放--"+url);
}
/**
* 退出视频播放
* @param url 视频url
*/
@Override
public void playerDestroy(String url) {
VideoLogUtils.i("BuriedPointEvent---退出视频播放--"+url);
}
/**
* 视频播放完成
* @param url 视频url
*/
@Override
public void playerCompletion(String url) {
VideoLogUtils.i("BuriedPointEvent---视频播放完成--"+url);
}
/**
* 视频播放异常
* @param url 视频url
* @param isNetError 是否是网络异常
*/
@Override
public void onError(String url, boolean isNetError) {
VideoLogUtils.i("BuriedPointEvent---视频播放异常--"+url);
}
/**
* 点击了视频广告
* @param url 视频url
*/
@Override
public void clickAd(String url) {
VideoLogUtils.i("BuriedPointEvent---点击了视频广告--"+url);
}
/**
* 视频试看点击
* @param url 视频url
*/
@Override
public void playerAndProved(String url) {
VideoLogUtils.i("BuriedPointEvent---视频试看点击--"+url);
}
/**
* 退出视频播放时候的播放进度百度比
* @param url 视频url
* @param progress 视频进度，计算百分比【退出时候进度 / 总进度】
*/
@Override
public void playerOutProgress(String url, float progress) {
VideoLogUtils.i("BuriedPointEvent---退出视频播放时候的播放进度百度比--"+url+"-----"+progress);
}
/**
* 退出视频播放时候的播放进度
* @param url 视频url
* @param duration 总时长
* @param currentPosition 当前进度时长
*/
@Override
public void playerOutProgress(String url, long duration, long currentPosition) {
VideoLogUtils.i("BuriedPointEvent---退出视频播放时候的播放进度百度比--"+url+"-----"+duration+"----"+currentPosition);
VideoLocation location = new VideoLocation(url,currentPosition,duration);
LocationManager.getInstance().put(url,location);
}
/**
* 视频切换音频
* @param url 视频url
*/
@Override
public void videoToMedia(String url) {
VideoLogUtils.i("BuriedPointEvent---视频切换音频--"+url);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/ConstantVideo.java | Java | package com.yc.ycvideoplayer;
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/ImageUtil.java | Java | package com.yc.ycvideoplayer;
import android.content.Context;
import android.graphics.Bitmap;
import android.widget.ImageView;
import androidx.core.graphics.drawable.RoundedBitmapDrawable;
import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.target.BitmapImageViewTarget;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/3/14
* 描 述：图片加载工具类
* 修订历史：
* ================================================
*/
public class ImageUtil {
/**
* 将gif图转换为静态图
* @param context
* @param url
* @param resId
* @param imageView
*/
public static void display(Context context , String url, int resId ,ImageView imageView) {
if(imageView==null){
return;
}
if(url!=null && url.length()>0){
Glide.with(context)
.asBitmap()
.load(url)
.placeholder(resId)
.error(resId)
.into(imageView);
}else {
Glide.with(context)
.asBitmap()
.load(resId)
.placeholder(resId)
.error(resId)
.into(imageView);
}
}
/**
* 加载带有圆角的矩形图片 用glide处理
*
* @param path 路径
* @param round 圆角半径
* @param resId 加载失败时的图片
* @param target 控件
*/
public static void loadImgByPicassoWithRound(final Context activity, String path, final int round, int resId, final ImageView target) {
if (path != null && path.length() > 0) {
Glide.with(activity)
.asBitmap()
.load(path)
.placeholder(resId)
.error(resId)
//设置缓存
.diskCacheStrategy(DiskCacheStrategy.ALL)
.into(new BitmapImageViewTarget(target) {
@Override
protected void setResource(Bitmap resource) {
super.setResource(resource);
RoundedBitmapDrawable circularBitmapDrawable = RoundedBitmapDrawableFactory.create(activity.getResources(), resource);
//设置圆角弧度
circularBitmapDrawable.setCornerRadius(round);
target.setImageDrawable(circularBitmapDrawable);
}
});
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/MainActivity.java | Java | package com.yc.ycvideoplayer;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.graphics.Color;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import org.yc.ycvideoplayer.R;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.music.model.AudioBean;
import com.yc.music.service.PlayService;
import com.yc.music.tool.BaseAppHelper;
import com.yc.ycvideoplayer.demo.DemoActivity;
import com.yc.ycvideoplayer.m3u8.M3u8Activity;
import com.yc.ycvideoplayer.music.MusicPlayerActivity;
import com.yc.ycvideoplayer.newPlayer.activity.TypeActivity;
import com.yc.ycvideoplayer.oldPlayer.OldActivity;
import java.util.List;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/11/18
* 描 述：Main主页面
* 修订历史：
* ================================================
*/
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private TextView mTv1;
private TextView mTv2;
private TextView mTv3;
private TextView mTv4;
private TextView mTv5;
private PlayServiceConnection mPlayServiceConnection;
@Override
protected void onDestroy() {
if (mPlayServiceConnection != null) {
unbindService(mPlayServiceConnection);
}
super.onDestroy();
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
StateAppBar.setStatusBarLightMode(this, Color.WHITE);
initView();
}
private void initView() {
mTv1 = (TextView) findViewById(R.id.tv_1);
mTv2 = (TextView) findViewById(R.id.tv_2);
mTv3 = (TextView) findViewById(R.id.tv_3);
mTv4 = (TextView) findViewById(R.id.tv_4);
mTv5 = (TextView) findViewById(R.id.tv_5);
mTv1.setOnClickListener(this);
mTv2.setOnClickListener(this);
mTv3.setOnClickListener(this);
mTv4.setOnClickListener(this);
mTv5.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.tv_1:
startActivity(DemoActivity.class);
break;
case R.id.tv_2:
startActivity(TypeActivity.class);
break;
case R.id.tv_3:
startActivity(OldActivity.class);
break;
case R.id.tv_4:
startCheckService();
startActivity(MusicPlayerActivity.class);
break;
case R.id.tv_5:
startActivity(M3u8Activity.class);
break;
}
}
private void startActivity(Class c){
startActivity(new Intent(this,c));
}
/**
* 检测服务
*/
private void startCheckService() {
if (BaseAppHelper.get().getPlayService() == null) {
startService();
mTv1.postDelayed(new Runnable() {
@Override
public void run() {
bindService();
}
},500);
}
}
/**
* 开启服务
*/
private void startService() {
Intent intent = new Intent(this, PlayService.class);
startService(intent);
}
/**
* 绑定服务
* 注意对于绑定服务一定要解绑
*/
private void bindService() {
Intent intent = new Intent();
intent.setClass(this, PlayService.class);
mPlayServiceConnection = new PlayServiceConnection();
bindService(intent, mPlayServiceConnection, Context.BIND_AUTO_CREATE);
}
private class PlayServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
VideoLogUtils.e("onServiceConnected"+name);
final PlayService playService = ((PlayService.PlayBinder) service).getService();
BaseAppHelper.get().setPlayService(playService);
List<AudioBean> musicList = BaseAppHelper.get().getMusicList();
AudioBean audioBean1 = new AudioBean();
audioBean1.setPath("http://img.zhugexuetang.com/lleXB2SNF5UFp1LfNpPI0hsyQjNs");
audioBean1.setId("1");
audioBean1.setTitle("音频1");
musicList.add(audioBean1);
AudioBean audioBean2 = new AudioBean();
audioBean2.setPath("http://img.zhugexuetang.com/ljUa-X-oDbLHu7n9AhkuMLu2Yz3k");
audioBean2.setId("2");
audioBean2.setTitle("音频2");
musicList.add(audioBean2);
AudioBean audioBean3 = new AudioBean();
audioBean3.setPath("http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4");
audioBean3.setId("3");
audioBean3.setTitle("音频3");
musicList.add(audioBean3);
}
@Override
public void onServiceDisconnected(ComponentName name) {
VideoLogUtils.e("onServiceDisconnected"+name);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/ScreenDensityUtils.java | Java | package com.yc.ycvideoplayer;
import android.app.Activity;
import android.app.Application;
import android.content.ComponentCallbacks;
import android.content.Context;
import android.content.res.Configuration;
import android.os.Build;
import android.os.Bundle;
import android.util.DisplayMetrics;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
/**
* <pre>
* @author yangchong
* blog :
* time : 2018/9/14
* desc : 头条适配方案简易版，测试用，注意不要用到正式版
* revise:
* </pre>
*/
public class ScreenDensityUtils {
/*
* 1.先在application中使用setup()方法初始化一下
* 2.手动在Activity中调用match()方法做适配，必须在setContentView()之前
* 3.建议使用dp做宽度适配，大多数时候宽度适配才是主流需要
* 4.个人觉得在写布局的时候，可以多用dp，如果是使用px，建议转化成dp
* 5.入侵性很低，不需要改动原来的代码
*/
/**
* 屏幕适配的基准
*/
public static final int MATCH_BASE_WIDTH = 0;
public static final int MATCH_BASE_HEIGHT = 1;
/**
* 适配单位
*/
public static final int MATCH_UNIT_DP = 0;
public static final int MATCH_UNIT_PT = 1;
// 适配信息
private static MatchInfo sMatchInfo;
// Activity 的生命周期监测
private static Application.ActivityLifecycleCallbacks mActivityLifecycleCallback;
private ScreenDensityUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
/**
* 初始化
* @param application 需要在application中初始化
*/
public static void setup(@NonNull final Application application) {
/*
//获取屏幕分辨率信息的三种方法
//第一种
DisplayMetrics metrics = new DisplayMetrics();
Display display = activity.getWindowManager().getDefaultDisplay();
display.getMetrics(metrics);
//第二种
DisplayMetrics metrics= activity.getResources().getDisplayMetrics();
//第三种
Resources.getSystem().getDisplayMetrics();
*/
//注意这个是获取系统的displayMetrics
final DisplayMetrics displayMetrics = application.getResources().getDisplayMetrics();
if (sMatchInfo == null) {
// 记录系统的原始值
sMatchInfo = new MatchInfo();
sMatchInfo.setScreenWidth(displayMetrics.widthPixels);
sMatchInfo.setScreenHeight(displayMetrics.heightPixels);
sMatchInfo.setAppDensity(displayMetrics.density);
sMatchInfo.setAppDensityDpi(displayMetrics.densityDpi);
sMatchInfo.setAppScaledDensity(displayMetrics.scaledDensity);
sMatchInfo.setAppXdpi(displayMetrics.xdpi);
}
// 添加字体变化的监听
// 调用 Application#registerComponentCallbacks 注册下 onConfigurationChanged 监听即可。
application.registerComponentCallbacks(new ComponentCallbacks() {
@Override
public void onConfigurationChanged(Configuration newConfig) {
// 字体改变后,将 appScaledDensity 重新赋值
if (newConfig != null && newConfig.fontScale > 0) {
float scaledDensity = displayMetrics.scaledDensity;
sMatchInfo.setAppScaledDensity(scaledDensity);
}
}
@Override
public void onLowMemory() {
}
});
}
/**
* 在 application 中全局激活适配（也可单独使用 match() 方法在指定页面中配置适配）
*/
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public static void register(@NonNull final Application application, final float designSize, final int matchBase, final int matchUnit) {
if (mActivityLifecycleCallback == null) {
mActivityLifecycleCallback = new Application.ActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
if (activity != null) {
match(activity, designSize, matchBase, matchUnit);
}
}
@Override
public void onActivityStarted(Activity activity) {
}
@Override
public void onActivityResumed(Activity activity) {
}
@Override
public void onActivityPaused(Activity activity) {
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
@Override
public void onActivityDestroyed(Activity activity) {
}
};
application.registerActivityLifecycleCallbacks(mActivityLifecycleCallback);
}
}
/**
* 全局取消所有的适配
*/
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public static void unregister(@NonNull final Application application, @NonNull int... matchUnit) {
if (mActivityLifecycleCallback != null) {
application.unregisterActivityLifecycleCallbacks(mActivityLifecycleCallback);
mActivityLifecycleCallback = null;
}
for (int unit : matchUnit) {
cancelMatch(application, unit);
}
}
/**
* 适配屏幕（放在 Activity 的 setContentView() 之前执行）
*
* @param context 上下文
* @param designSize 设计图的尺寸
*/
public static void match(@NonNull final Context context, final float designSize) {
match(context, designSize, MATCH_BASE_WIDTH, MATCH_UNIT_DP);
}
/**
* 适配屏幕（放在 Activity 的 setContentView() 之前执行）
*
* @param context 上下文
* @param designSize 设计图的尺寸
* @param matchBase 适配基准
*/
public static void match(@NonNull final Context context, final float designSize, int matchBase) {
match(context, designSize, matchBase, MATCH_UNIT_DP);
}
/**
* 适配屏幕（放在 Activity 的 setContentView() 之前执行）
*
* @param context 上下文
* @param designSize 设计图的尺寸
* @param matchBase 适配基准
* @param matchUnit 使用的适配单位
*/
private static void match(@NonNull final Context context, final float designSize, int matchBase, int matchUnit) {
if (designSize == 0) {
throw new UnsupportedOperationException("The designSize cannot be equal to 0");
}
if (matchUnit == MATCH_UNIT_DP) {
matchByDP(context, designSize, matchBase);
} else if (matchUnit == MATCH_UNIT_PT) {
matchByPT(context, designSize, matchBase);
}
}
/**
* 重置适配信息，取消适配
*/
public static void cancelMatch(@NonNull final Context context) {
cancelMatch(context, MATCH_UNIT_DP);
cancelMatch(context, MATCH_UNIT_PT);
}
/**
* 重置适配信息，取消适配
*
* @param context 上下文
* @param matchUnit 需要取消适配的单位
*/
private static void cancelMatch(@NonNull final Context context, int matchUnit) {
if (sMatchInfo != null) {
final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
if (matchUnit == MATCH_UNIT_DP) {
if (displayMetrics.density != sMatchInfo.getAppDensity()) {
displayMetrics.density = sMatchInfo.getAppDensity();
}
if (displayMetrics.densityDpi != sMatchInfo.getAppDensityDpi()) {
displayMetrics.densityDpi = (int) sMatchInfo.getAppDensityDpi();
}
if (displayMetrics.scaledDensity != sMatchInfo.getAppScaledDensity()) {
displayMetrics.scaledDensity = sMatchInfo.getAppScaledDensity();
}
} else if (matchUnit == MATCH_UNIT_PT) {
if (displayMetrics.xdpi != sMatchInfo.getAppXdpi()) {
displayMetrics.xdpi = sMatchInfo.getAppXdpi();
}
}
}
}
public static MatchInfo getMatchInfo() {
return sMatchInfo;
}
/**
* 使用 dp 作为适配单位（适合在新项目中使用，在老项目中使用会对原来既有的 dp 值产生影响）
* <br>
* <ul>
* dp 与 px 之间的换算:
* <li> px = density * dp </li>
* <li> density = dpi / 160 </li>
* <li> px = dp * (dpi / 160) </li>
* </ul>
*
* @param context 上下文
* @param designSize 设计图的宽/高（单位: dp）
* @param base 适配基准
*/
private static void matchByDP(@NonNull final Context context, final float designSize, int base) {
final float targetDensity;
if (base == MATCH_BASE_WIDTH) {
targetDensity = sMatchInfo.getScreenWidth() * 1f / designSize;
} else if (base == MATCH_BASE_HEIGHT) {
targetDensity = sMatchInfo.getScreenHeight() * 1f / designSize;
} else {
targetDensity = sMatchInfo.getScreenWidth() * 1f / designSize;
}
final int targetDensityDpi = (int) (targetDensity * 160);
final float targetScaledDensity = targetDensity * (sMatchInfo.getAppScaledDensity() / sMatchInfo.getAppDensity());
final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
displayMetrics.density = targetDensity;
displayMetrics.densityDpi = targetDensityDpi;
displayMetrics.scaledDensity = targetScaledDensity;
}
/**
* 使用 pt 作为适配单位（因为 pt 比较冷门，新老项目皆适合使用；也可作为 dp 适配的补充，
* 在需要同时适配宽度和高度时，使用 pt 来适配 dp 未适配的宽度或高度）
* <br/>
* <p> pt 转 px 算法: pt * metrics.xdpi * (1.0f/72) </p>
*
* @param context 上下文
* @param designSize 设计图的宽/高（单位: pt）
* @param base 适配基准
*/
private static void matchByPT(@NonNull final Context context, final float designSize, int base) {
final float targetXdpi;
if (base == MATCH_BASE_WIDTH) {
targetXdpi = sMatchInfo.getScreenWidth() * 72f / designSize;
} else if (base == MATCH_BASE_HEIGHT) {
targetXdpi = sMatchInfo.getScreenHeight() * 72f / designSize;
} else {
targetXdpi = sMatchInfo.getScreenWidth() * 72f / designSize;
}
final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
displayMetrics.xdpi = targetXdpi;
}
/**
* 适配信息
*/
private static class MatchInfo {
private int screenWidth;
private int screenHeight;
private float appDensity;
private float appDensityDpi;
private float appScaledDensity;
private float appXdpi;
int getScreenWidth() {
return screenWidth;
}
void setScreenWidth(int screenWidth) {
this.screenWidth = screenWidth;
}
int getScreenHeight() {
return screenHeight;
}
void setScreenHeight(int screenHeight) {
this.screenHeight = screenHeight;
}
float getAppDensity() {
return appDensity;
}
void setAppDensity(float appDensity) {
this.appDensity = appDensity;
}
float getAppDensityDpi() {
return appDensityDpi;
}
void setAppDensityDpi(float appDensityDpi) {
this.appDensityDpi = appDensityDpi;
}
float getAppScaledDensity() {
return appScaledDensity;
}
void setAppScaledDensity(float appScaledDensity) {
this.appScaledDensity = appScaledDensity;
}
float getAppXdpi() {
return appXdpi;
}
void setAppXdpi(float appXdpi) {
this.appXdpi = appXdpi;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/demo/DemoActivity.java | Java | package com.yc.ycvideoplayer.demo;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import org.yc.ycvideoplayer.R;
public class DemoActivity extends AppCompatActivity implements View.OnClickListener {
private TextView mTv1;
private TextView mTv12;
private TextView mTv2;
private TextView mTv3;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_demo_player);
mTv1 = findViewById(R.id.tv_1);
mTv12 = findViewById(R.id.tv_1_2);
mTv2 = findViewById(R.id.tv_2);
mTv3 = findViewById(R.id.tv_3);
mTv1.setOnClickListener(this);
mTv12.setOnClickListener(this);
mTv2.setOnClickListener(this);
mTv3.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.tv_1:
startActivity(MediaActivity.class);
break;
case R.id.tv_1_2:
startActivity(MediaActivity2.class);
break;
case R.id.tv_2:
startActivity(IjkActivity.class);
break;
case R.id.tv_3:
startActivity(ExoActivity.class);
break;
}
}
private void startActivity(Class c){
startActivity(new Intent(this,c));
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/demo/ExoActivity.java | Java | package com.yc.ycvideoplayer.demo;
import android.net.Uri;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.google.android.exoplayer2.DefaultLoadControl;
import com.google.android.exoplayer2.ExoPlayerFactory;
import com.google.android.exoplayer2.SimpleExoPlayer;
import com.google.android.exoplayer2.source.ProgressiveMediaSource;
import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
import com.google.android.exoplayer2.ui.PlayerView;
import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
public class ExoActivity extends AppCompatActivity {
private PlayerView mVideoView;
private SimpleExoPlayer player;
@Override
protected void onPause() {
super.onPause();
mVideoView.onPause();
}
@Override
protected void onResume() {
super.onResume();
mVideoView.onResume();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (player!=null){
player.release();
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_exo_player);
mVideoView = findViewById(R.id.video_view);
SimpleExoPlayer player = ExoPlayerFactory.newSimpleInstance(this,
new DefaultTrackSelector(),new DefaultLoadControl());
player.setPlayWhenReady(true);
mVideoView.setPlayer(player);
Uri uri = Uri.parse(ConstantVideo.VideoPlayerList[0]);
DefaultHttpDataSourceFactory dataSourceFactory = new DefaultHttpDataSourceFactory("user-agent");
ProgressiveMediaSource mediaSource = new ProgressiveMediaSource.Factory(
dataSourceFactory).createMediaSource(uri);
// 播放
player.prepare(mediaSource);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/demo/IjkActivity.java | Java | package com.yc.ycvideoplayer.demo;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import org.yc.ycvideoplayer.R;
public class IjkActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ijk_player);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/demo/MediaActivity.java | Java | package com.yc.ycvideoplayer.demo;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.MediaController;
import android.widget.VideoView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.tool.BaseToast;
public class MediaActivity extends AppCompatActivity {
private VideoView mVideo;
private Button mBtnStart;
private Button mBtnPause;
private MediaController mMediaController;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_media_player);
initView();
initListener();
}
private void initView() {
mVideo = findViewById(R.id.video);
mBtnStart = findViewById(R.id.btn_start);
mBtnPause = findViewById(R.id.btn_pause);
Uri uri = Uri.parse(ConstantVideo.VideoPlayerList[2]);
mVideo.setVideoURI(uri);
mMediaController = new MediaController(this);
mVideo.setMediaController(mMediaController);
mVideo.start();
mVideo.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
// mp.setLooping(true);
mp.start();// 播放
BaseToast.showRoundRectToast("开始播放！");
}
});
mVideo.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
BaseToast.showRoundRectToast("播放完毕！");
}
});
}
private void initListener() {
mBtnStart.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mVideo.start();
}
});
mBtnPause.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mVideo.pause();
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/demo/MediaActivity2.java | Java | package com.yc.ycvideoplayer.demo;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Bundle;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;
import android.widget.SeekBar;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.tool.BaseToast;
public class MediaActivity2 extends AppCompatActivity {
private SurfaceView mSvMainSurface;
private SeekBar mSeekBar;
private Button mStart;
private MediaPlayer mediaPlayer;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_media_player2);
initView();
initMedia();
initSurfaceView();
}
private void initView() {
mSvMainSurface = findViewById(R.id.sv_main_surface);
mSeekBar = findViewById(R.id.seekBar);
mStart = findViewById(R.id.start);
mStart.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mStart.getText().toString().equals("暂停")){
mediaPlayer.start();
mStart.setText("播放");
} else {
mediaPlayer.pause();
mStart.setText("暂停");
}
}
});
}
private void initMedia() {
mediaPlayer=new MediaPlayer();
//设置类型
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
/* 得到文件路径 *//* 注：文件存放在SD卡的根目录，一定要进行prepare()方法，使硬件进行准备 */
try{
Uri uri = Uri.parse(ConstantVideo.VideoPlayerList[2]);
/* 为MediaPlayer 设置数据源 */
mediaPlayer.setDataSource(this,uri);
/* 准备 */
mediaPlayer.prepare();
//将播放器捕捉的画面展示到SurfaceView画面上
mediaPlayer.setDisplay(mSvMainSurface.getHolder());
}catch(Exception ex){
ex.printStackTrace();
}
mediaPlayer.start();
// 把图标变为暂停图标
mStart.setText("暂停");
//获取音乐的总时长
int duration=mediaPlayer.getDuration();
//设置进度条的最大值为音乐总时长
mSeekBar.setMax(duration);
}
private void initSurfaceView() {
mSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
//获取拖动结束之后的位置
int progress=seekBar.getProgress();
//跳转到某个位置播放
mediaPlayer.seekTo(progress);
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/m3u8/M3u8Activity.java | Java | package com.yc.ycvideoplayer.m3u8;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.m3u8.bean.M3u8;
import com.yc.m3u8.inter.OnDownloadListener;
import com.yc.m3u8.inter.OnM3u8InfoListener;
import com.yc.m3u8.manager.M3u8InfoManger;
import com.yc.m3u8.manager.M3u8LiveManger;
import com.yc.m3u8.task.M3u8DownloadTask;
import com.yc.m3u8.utils.M3u8FileUtils;
import com.yc.m3u8.utils.NetSpeedUtils;
import com.yc.ycvideoplayer.newPlayer.activity.NormalActivity;
import org.yc.ycvideoplayer.R;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class M3u8Activity extends AppCompatActivity {
//url随时可能失效
private String url = "yangchong";
private TextView tvSpeed1;
private EditText etUrl;
private TextView tvConsole;
private TextView tvSaveFilePathTip;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_m3u8_view);
tvSpeed1 = (TextView) findViewById(R.id.tv_speed1);
etUrl = (EditText) findViewById(R.id.et_url);
etUrl.setText(url);
tvConsole = (TextView) findViewById(R.id.tv_console);
tvSaveFilePathTip= (TextView) findViewById(R.id.tv_savepath_tip);
}
public void onGetInfo(View view) {
String url = etUrl.getText().toString().trim();
M3u8InfoManger.getInstance().getM3U8Info(url, new OnM3u8InfoListener() {
@Override
public void onSuccess(M3u8 m3U8) {
tvConsole.append("\n\n获取成功了" + m3U8);
VideoLogUtils.e("获取成功了" + m3U8);
}
@Override
public void onStart() {
tvConsole.append("\n\n开始获取信息");
VideoLogUtils.e("开始获取信息");
}
@Override
public void onError(Throwable errorMsg) {
tvConsole.append("\n\n出错了" + errorMsg);
VideoLogUtils.e("出错了" + errorMsg);
}
});
}
//上一秒的大小
private long lastLength = 0;
M3u8DownloadTask task1 = new M3u8DownloadTask("1001");
public void onDownload(View view) {
String url = etUrl.getText().toString().trim();
// url = etUrl.getText().toString();
task1.setSaveFilePath("/sdcard/111/" + System.currentTimeMillis() + ".ts");
tvSaveFilePathTip.setText("文件保存在：/sdcard/111/" + System.currentTimeMillis() + ".ts");
task1.download(url, new OnDownloadListener() {
@Override
public void onDownloading(final long itemFileSize, final int totalTs, final int curTs) {
VideoLogUtils.e(task1.getTaskId() + "下载中.....itemFileSize=" + itemFileSize + "\ttotalTs=" + totalTs + "\tcurTs=" + curTs);
tvConsole.append("\n\n下载中....." + itemFileSize + "\t" + totalTs + "\t" + curTs);
}
/**
* 下载成功
*/
@Override
public void onSuccess() {
VideoLogUtils.e(task1.getTaskId() + "下载完成了");
tvConsole.append("\n\n下载完成");
}
/**
* 当前的进度回调
*
* @param curLenght
*/
@Override
public void onProgress(final long curLenght) {
if (curLenght - lastLength > 0) {
final String speed = NetSpeedUtils.getInstance().displayFileSize(curLenght - lastLength) + "/s";
VideoLogUtils.e(task1.getTaskId() + "speed = " + speed);
runOnUiThread(new Runnable() {
@Override
public void run() {
VideoLogUtils.e("更新了");
tvSpeed1.setText(speed);
VideoLogUtils.e(tvSpeed1.getText().toString());
}
});
lastLength = curLenght;
}
}
@Override
public void onStart() {
VideoLogUtils.e(task1.getTaskId() + "开始下载了");
tvConsole.append("\n\n开始下载");
}
@Override
public void onError(Throwable errorMsg) {
tvConsole.append("\n\n出错了" + errorMsg);
VideoLogUtils.e(task1.getTaskId() + "出错了" + errorMsg);
}
});
}
public void onStopTask1(View view) {
task1.stop();
M3u8LiveManger.getInstance().stop();
}
/**
* 当前正在下载的视频
*/
private int curTsIndex;
public void onLiveDownload(View view) {
// String url = "http://tvbilive7-i.akamaihd.net/hls/live/494651/CJHK4/CJHK4-06.m3u8";
String url = etUrl.getText().toString().trim();
String toFile="/sdcard/" + System.currentTimeMillis() + ".ts";
tvSaveFilePathTip.setText("缓存目录在：/sdcard/11m3u8/\n最终导出的缓存文件在："+toFile);
M3u8LiveManger.getInstance()
.setTempDir("/sdcard/11m3u8/")
.setSaveFile(toFile)//（设置导出缓存文件）必须以.ts结尾
.caching(url, new OnDownloadListener() {
@Override
public void onDownloading(long itemFileSize, int totalTs, int curTs) {
curTsIndex = curTs;
tvConsole.append(String.format("\n\n下载中.....开始下载第 %s 个视频了", curTs));
// tvConsole.setText("第 " + curTs + " 个视频下载中\n\n" + tvConsole.getText().toString());
}
@Override
public void onSuccess() {
}
@Override
public void onProgress(long curLength) {
if (curLength - lastLength > 0) {
final String speed = NetSpeedUtils.getInstance().displayFileSize(curLength - lastLength) + "/s";
VideoLogUtils.e(task1.getTaskId() + "speed = " + speed);
runOnUiThread(new Runnable() {
@Override
public void run() {
VideoLogUtils.e("更新了");
tvSpeed1.setText(speed + "( 第" + (curTsIndex + 1) + "个视频 )");
VideoLogUtils.e(tvSpeed1.getText().toString());
}
});
lastLength = curLength;
}
}
@Override
public void onStart() {
tvConsole.append("\n\n开始缓存");
}
@Override
public void onError(Throwable errorMsg) {
tvConsole.append("\n\n缓存出错了" + errorMsg);
}
});
}
public void onGetLiveCache(View view) {
String currentTs = M3u8LiveManger.getInstance().getCurrentTs();
tvConsole.append("\n\n缓存完成了，已经存至：" + currentTs);
Log.e("hdltag", "onGetLiveCache(Main2Activity.java:151): currentTs = " + currentTs);
}
public void onPlay(View view){
String url = etUrl.getText().toString().trim();
Intent intent = new Intent(this, NormalActivity.class);
intent.putExtra("url",url);
startActivity(intent);
}
public void onMergin(View view) {
File dir=new File("/sdcard/11m3u8/11");
File[] files = dir.listFiles();
List<File> fileList=new ArrayList<>();
for (File file : files) {
fileList.add(file);
}
try {
M3u8FileUtils.merge(fileList,"/sdcard/1123/"+ System.currentTimeMillis()+".ts");
} catch (IOException e) {
e.printStackTrace();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/music/MusicPlayerActivity.java | Java | package com.yc.ycvideoplayer.music;
import android.os.Bundle;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.fragment.app.FragmentTransaction;
import com.yc.music.inter.OnPlayerEventListener;
import com.yc.music.model.AudioBean;
import com.yc.music.tool.BaseAppHelper;
import org.yc.ycvideoplayer.R;
public class MusicPlayerActivity extends AppCompatActivity implements View.OnClickListener {
private Toolbar mToolbar;
private TextView mTv1;
private TextView mTv2;
private TextView mTv3;
private TextView mTvStart;
private TextView mTvStop;
private TextView mTvNext;
private TextView mTvPre;
private FrameLayout mFlPlayBar;
private ImageView mIvPlayBarCover;
private TextView mTvPlayBarTitle;
private TextView mTvPlayBarArtist;
private ImageView mIvPlayBarList;
private ImageView mIvPlayBarPlay;
private ImageView mIvPlayBarNext;
private ProgressBar mPbPlayBar;
private boolean isPlayFragmentShow = false;
private PlayMusicFragment mPlayFragment;
@Override
public void onBackPressed() {
if (mPlayFragment != null && isPlayFragmentShow) {
hidePlayingFragment();
return;
}
super.onBackPressed();
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_music_player);
initFindViewById();
initListener();
mTv1.postDelayed(new Runnable() {
@Override
public void run() {
initPlayServiceListener();
}
},1000);
}
private void initFindViewById() {
mToolbar = findViewById(R.id.toolbar);
mTv1 = findViewById(R.id.tv_1);
mTv2 = findViewById(R.id.tv_2);
mTv3 = findViewById(R.id.tv_3);
mTvStart = findViewById(R.id.tv_start);
mTvStop = findViewById(R.id.tv_stop);
mTvNext = findViewById(R.id.tv_next);
mTvPre = findViewById(R.id.tv_pre);
mFlPlayBar = findViewById(R.id.fl_play_bar);
mIvPlayBarCover = findViewById(R.id.iv_play_bar_cover);
mTvPlayBarTitle = findViewById(R.id.tv_play_bar_title);
mTvPlayBarArtist = findViewById(R.id.tv_play_bar_artist);
mIvPlayBarList = findViewById(R.id.iv_play_bar_list);
mIvPlayBarPlay = findViewById(R.id.iv_play_bar_play);
mIvPlayBarNext = findViewById(R.id.iv_play_bar_next);
mPbPlayBar = findViewById(R.id.pb_play_bar);
}
private void initListener() {
mTv1.setOnClickListener(this);
mTv2.setOnClickListener(this);
mTv3.setOnClickListener(this);
mTvStart.setOnClickListener(this);
mTvStop.setOnClickListener(this);
mTvNext.setOnClickListener(this);
mTvPre.setOnClickListener(this);
mIvPlayBarPlay.setOnClickListener(this);
mFlPlayBar.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.tv_1:
BaseAppHelper.get().getMusicService().play(0);
break;
case R.id.tv_2:
break;
case R.id.tv_3:
break;
case R.id.tv_start:
BaseAppHelper.get().getMusicService().start();
break;
case R.id.tv_stop:
BaseAppHelper.get().getMusicService().stop();
break;
case R.id.tv_next:
BaseAppHelper.get().getMusicService().next();
break;
case R.id.tv_pre:
BaseAppHelper.get().getMusicService().prev();
break;
case R.id.fl_play_bar:
showPlayingFragment();
break;
case R.id.iv_play_bar_play:
if (BaseAppHelper.get().getMusicService().isDefault()) {
if (BaseAppHelper.get().getMusicList().size() > 0) {
int mPlayPosition;
if (BaseAppHelper.get().getMusicService().getPlayingMusic() != null &&
BaseAppHelper.get().getMusicService().getPlayingMusic().getType()
== AudioBean.Type.LOCAL) {
mPlayPosition = BaseAppHelper.get().getMusicService().getPlayingPosition();
} else {
mPlayPosition = 0;
}
BaseAppHelper.get().getMusicService().play(BaseAppHelper.get()
.getMusicList().get(mPlayPosition));
}
} else {
BaseAppHelper.get().getMusicService().playPause();
}
break;
}
}
/**
* 初始化服务播放音频播放进度监听器
* 这个是要是通过监听即时更新主页面的底部控制器视图
* 同时还要同步播放详情页面mPlayFragment的视图
*/
public void initPlayServiceListener() {
if (BaseAppHelper.get().getMusicService() == null) {
return;
}
BaseAppHelper.get().getMusicService().setOnPlayEventListener(new OnPlayerEventListener() {
/**
* 切换歌曲
* 主要是切换歌曲的时候需要及时刷新界面信息
*/
@Override
public void onChange(AudioBean music) {
onChangeImpl(music);
}
/**
* 继续播放
* 主要是切换歌曲的时候需要及时刷新界面信息，比如播放暂停按钮
*/
@Override
public void onPlayerStart() {
mIvPlayBarPlay.setSelected(true);
}
/**
* 暂停播放
* 主要是切换歌曲的时候需要及时刷新界面信息，比如播放暂停按钮
*/
@Override
public void onPlayerPause() {
mIvPlayBarPlay.setSelected(false);
}
/**
* 更新进度
* 主要是播放音乐或者拖动进度条时，需要更新进度
*/
@Override
public void onUpdateProgress(int progress) {
mPbPlayBar.setProgress(progress);
}
@Override
public void onBufferingUpdate(int percent) {
}
/**
* 更新定时停止播放时间
*/
@Override
public void onTimer(long remain) {
}
});
}
/**
* 当在播放音频详细页面切换歌曲的时候，需要刷新底部控制器，和音频详细页面的数据
* 之前关于activity，Fragment，service之间用EventBus通信
* 案例：https://github.com/yangchong211/LifeHelper
* 本项目中直接通过定义接口来实现功能，尝试中……
*
* @param music LocalMusic
*/
private void onChangeImpl(AudioBean music) {
if (music == null) {
return;
}
mTvPlayBarTitle.setText(music.getTitle());
mIvPlayBarPlay.setSelected(BaseAppHelper.get().getMusicService().isPlaying() || BaseAppHelper.get().getMusicService().isPreparing());
//更新进度条
mPbPlayBar.setMax((int) music.getDuration());
mPbPlayBar.setProgress((int) BaseAppHelper.get().getMusicService().getCurrentPosition());
}
/**
* 展示页面
*/
private void showPlayingFragment() {
if (isPlayFragmentShow) {
return;
}
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setCustomAnimations(R.anim.fragment_slide_up, 0);
if (mPlayFragment == null) {
mPlayFragment = PlayMusicFragment.newInstance("OnLine");
ft.replace(android.R.id.content, mPlayFragment);
} else {
ft.show(mPlayFragment);
}
ft.commitAllowingStateLoss();
isPlayFragmentShow = true;
}
/**
* 隐藏页面
*/
private void hidePlayingFragment() {
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setCustomAnimations(0, R.anim.fragment_slide_down);
ft.hide(mPlayFragment);
ft.commitAllowingStateLoss();
isPlayFragmentShow = false;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/music/PlayMusicFragment.java | Java | package com.yc.ycvideoplayer.music;
import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.os.Build;
import android.os.Bundle;
import android.text.format.DateUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.SeekBar;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import com.yc.music.config.MusicConstant;
import com.yc.music.config.PlayModeEnum;
import com.yc.music.inter.OnPlayerEventListener;
import com.yc.music.model.AudioBean;
import com.yc.music.tool.BaseAppHelper;
import com.yc.music.utils.MusicLogUtils;
import com.yc.music.utils.MusicSpUtils;
import com.yc.video.tool.PlayerUtils;
import org.yc.ycvideoplayer.R;
import java.io.File;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
public class PlayMusicFragment extends Fragment implements View.OnClickListener, OnPlayerEventListener {
private ImageView ivPlayPageBg;
private LinearLayout llContent;
private ImageView ivBack;
private TextView tvTitle;
private TextView tvArtist;
private ImageView ivShare;
private SeekBar sbVolume;
private LinearLayout llMusicTool;
private ImageView ivPlayingFav;
private ImageView ivPlayingDown;
private ImageView ivPlayingCmt;
private ImageView ivPlayingMore;
private TextView tvCurrentTime;
private SeekBar sbProgress;
private TextView tvTotalTime;
private ImageView ivMode;
private ImageView ivPrev;
private ImageView ivPlay;
private ImageView ivNext;
private ImageView ivOther;
private FragmentActivity activity;
private int mLastProgress;
/**
* 是否拖进度，默认是false
*/
private boolean isDraggingProgress;
private AudioManager mAudioManager;
private static final String TAG = "DetailAudioFragment";
private String type;
/**
* 使用FragmentPagerAdapter+ViewPager时，
* 切换回上一个Fragment页面时（已经初始化完毕），
* 不会回调任何生命周期方法以及onHiddenChanged()，
* 只有setUserVisibleHint(boolean isVisibleToUser)会被回调，
* 所以如果你想进行一些懒加载，需要在这里处理。
* @param isVisibleToUser 是否显示
*/
@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
super.setUserVisibleHint(isVisibleToUser);
MusicLogUtils.e(TAG+"setUserVisibleHint"+isVisibleToUser);
}
/**
* 当使用add()+show()，hide()跳转新的Fragment时，旧的Fragment回调onHiddenChanged()，
* 不会回调onStop()等生命周期方法，
* 而新的Fragment在创建时是不会回调onHiddenChanged()，这点要切记
* @param hidden 是否显示
*/
@Override
public void onHiddenChanged(boolean hidden) {
super.onHiddenChanged(hidden);
MusicLogUtils.e(TAG+"onHiddenChanged"+hidden);
if (!hidden){
initData();
}
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
activity = (FragmentActivity) context;
}
@Override
public void onDetach() {
super.onDetach();
activity = null;
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
View view = inflater.inflate(getContentView(), container , false);
return view;
}
@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
initListener();
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
initData();
}
/**
* 对Fragment传递数据，建议使用setArguments(Bundle args)，而后在onCreate中使用getArguments()取出，
* 在 “内存重启”前，系统会帮你保存数据，不会造成数据的丢失。和Activity的Intent恢复机制类似。
* @param type type
* @return PlayMusicFragment实例对象
*/
public static PlayMusicFragment newInstance(String type) {
Bundle bundle = new Bundle();
bundle.putString(TAG, type);
PlayMusicFragment fragment = new PlayMusicFragment();
fragment.setArguments(bundle);
return fragment;
}
/**
* 返回监听
*/
private void onBackPressed() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
Objects.requireNonNull(getActivity()).onBackPressed();
}
ivBack.setEnabled(false);
ivBack.postDelayed(new Runnable() {
@Override
public void run() {
ivBack.setEnabled(true);
}
},300);
}
@Override
public void onDestroy() {
super.onDestroy();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
Objects.requireNonNull(getContext()).unregisterReceiver(mVolumeReceiver);
}
}
@Override
public void onResume() {
super.onResume();
IntentFilter filter = new IntentFilter();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
Objects.requireNonNull(getContext()).registerReceiver(mVolumeReceiver, filter);
}
}
public int getContentView() {
return R.layout.fragment_play_music;
}
public void initView(View view) {
if (getArguments() != null) {
type = getArguments().getString(TAG);
}
initFindById(view);
initPlayMode();
initVolume();
}
private void initFindById(View view) {
llContent = view.findViewById(R.id.ll_content);
ivBack = view.findViewById(R.id.iv_back);
tvTitle = view.findViewById(R.id.tv_title);
tvArtist = view.findViewById(R.id.tv_artist);
ivShare = view.findViewById(R.id.iv_share);
sbVolume = view.findViewById(R.id.sb_volume);
llMusicTool = view.findViewById(R.id.ll_music_tool);
ivPlayingFav = view.findViewById(R.id.iv_playing_fav);
ivPlayingDown = view.findViewById(R.id.iv_playing_down);
ivPlayingCmt = view.findViewById(R.id.iv_playing_cmt);
ivPlayingMore = view.findViewById(R.id.iv_playing_more);
tvCurrentTime = view.findViewById(R.id.tv_current_time);
sbProgress = view.findViewById(R.id.sb_progress);
tvTotalTime = view.findViewById(R.id.tv_total_time);
ivMode = view.findViewById(R.id.iv_mode);
ivPrev = view.findViewById(R.id.iv_prev);
ivPlay = view.findViewById(R.id.iv_play);
ivNext = view.findViewById(R.id.iv_next);
ivOther = view.findViewById(R.id.iv_other);
}
public void initListener() {
ivBack.setOnClickListener(this);
ivMode.setOnClickListener(this);
ivPlay.setOnClickListener(this);
ivPrev.setOnClickListener(this);
ivNext.setOnClickListener(this);
ivOther.setOnClickListener(this);
initSeekBarListener();
}
private void initSeekBarListener() {
SeekBar.OnSeekBarChangeListener onSeekBarChangeListener = new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
if (seekBar == sbProgress) {
if (Math.abs(progress - mLastProgress) >= DateUtils.SECOND_IN_MILLIS) {
tvCurrentTime.setText(PlayerUtils.formatTime(progress));
mLastProgress = progress;
}
}
}
/**
* 通知用户已启动触摸手势,开始触摸时调用
* @param seekBar seekBar
*/
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
if (seekBar == sbProgress) {
isDraggingProgress = true;
}
}
/**
* 通知用户已结束触摸手势,触摸结束时调用
* @param seekBar seekBar
*/
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
if (seekBar == sbProgress) {
isDraggingProgress = false;
//如果是正在播放，或者暂停，那么直接拖动进度
if (BaseAppHelper.get().getMusicService().isPlaying() || BaseAppHelper.get().getMusicService().isPausing()) {
//获取进度
int progress = seekBar.getProgress();
//直接移动进度
BaseAppHelper.get().getMusicService().seekTo(progress);
} else {
//其他情况，直接设置进度为0
seekBar.setProgress(0);
}
} else if (seekBar == sbVolume) {
mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, seekBar.getProgress(),
AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE);
}
}
};
sbProgress.setOnSeekBarChangeListener(onSeekBarChangeListener);
sbVolume.setOnSeekBarChangeListener(onSeekBarChangeListener);
}
public void initData() {
setViewData(BaseAppHelper.get().getMusicService().getPlayingMusic());
}
@Override
public void onClick(View v) {
int i = v.getId();
if (i == R.id.iv_back) {
onBackPressed();
} else if (i == R.id.iv_mode) {
switchPlayMode();
} else if (i == R.id.iv_play) {
play();
} else if (i == R.id.iv_next) {
next();
} else if (i == R.id.iv_prev) {
prev();
} else if (i == R.id.iv_other) {
} else {
}
}
private void prev() {
if (BaseAppHelper.get().getMusicService() != null) {
BaseAppHelper.get().getMusicService().prev();
}
}
private void next() {
if (BaseAppHelper.get().getMusicService() != null) {
BaseAppHelper.get().getMusicService().next();
}
}
private void play() {
if (BaseAppHelper.get().getMusicService() != null) {
BaseAppHelper.get().getMusicService().playPause();
}
}
private void switchPlayMode() {
int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
PlayModeEnum mode = PlayModeEnum.valueOf(playMode);
switch (mode) {
case LOOP:
mode = PlayModeEnum.SHUFFLE;
break;
case SHUFFLE:
mode = PlayModeEnum.SINGLE;
break;
case SINGLE:
mode = PlayModeEnum.LOOP;
break;
default:
break;
}
MusicSpUtils.getInstance(MusicConstant.SP_NAME).put(MusicConstant.PLAY_MODE, mode.value());
initPlayMode();
}
private void initPlayMode() {
int playMode = MusicSpUtils.getInstance(MusicConstant.SP_NAME).getInt(MusicConstant.PLAY_MODE, 0);
ivMode.setImageLevel(playMode);
}
/**
* 初始化音量
*/
private void initVolume() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
mAudioManager = (AudioManager) Objects.requireNonNull(getContext())
.getSystemService(Context.AUDIO_SERVICE);
}
if (mAudioManager != null) {
sbVolume.setMax(mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC));
sbVolume.setProgress(mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
}
}
/**
* 发送广播接收者
*/
private BroadcastReceiver mVolumeReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
sbVolume.setProgress(mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC));
}
};
/**
* 填充页面数据
*
* @param playingMusic 正在播放的音乐
*/
@SuppressLint("SetTextI18n")
private void setViewData(AudioBean playingMusic) {
if (playingMusic == null) {
return;
}
tvTitle.setText(playingMusic.getTitle());
tvArtist.setText(playingMusic.getArtist());
sbProgress.setProgress((int) BaseAppHelper.get().getMusicService().getCurrentPosition());
sbProgress.setSecondaryProgress(0);
sbProgress.setMax((int) playingMusic.getDuration());
MusicLogUtils.e("-----------------------"+(int) playingMusic.getDuration());
mLastProgress = 0;
tvCurrentTime.setText("00:00");
tvTotalTime.setText(PlayerUtils.formatTime(playingMusic.getDuration()));
setCoverAndBg(playingMusic);
if (BaseAppHelper.get().getMusicService().isPlaying() || BaseAppHelper.get().getMusicService().isPreparing()) {
ivPlay.setSelected(true);
//mAlbumCoverView.start();
} else {
ivPlay.setSelected(false);
//mAlbumCoverView.pause();
}
}
private void setCoverAndBg(AudioBean music) {
//mAlbumCoverView.setCoverBitmap(CoverLoader.getInstance().loadRound(music));
//ivPlayPageBg.setImageBitmap(CoverLoader.getInstance().loadBlur(music));
}
/**
* ---------------通过MainActivity进行调用-----------------------------
**/
@Override
public void onChange(AudioBean music) {
setViewData(music);
}
@Override
public void onPlayerStart() {
ivPlay.setSelected(true);
}
@Override
public void onPlayerPause() {
ivPlay.setSelected(false);
}
@Override
public void onUpdateProgress(int progress) {
if(progress>0){
//如果没有拖动进度，则开始更新进度条进度
if (!isDraggingProgress) {
sbProgress.setProgress(progress);
}
}
}
@Override
public void onBufferingUpdate(int percent) {
if(sbProgress.getMax()>0 && percent>0){
MusicLogUtils.e("setOnPlayEventListener---percent---"+ sbProgress.getMax() + "-----" +percent);
sbProgress.setSecondaryProgress(sbProgress.getMax() * 100 / percent);
}
}
@Override
public void onTimer(long remain) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/activity/DetailActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.activity;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.transition.Transition;
import android.widget.FrameLayout;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.view.ViewCompat;
import org.yc.ycvideoplayer.R;
import com.yc.video.player.VideoViewManager;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/activity/IntentKeys.java | Java | package com.yc.ycvideoplayer.newPlayer.activity;
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/activity/MultipleActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.activity;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoPlayerBuilder;
import com.yc.video.ui.view.BasisVideoController;
import java.util.ArrayList;
import java.util.List;
public class MultipleActivity extends AppCompatActivity {
private static final String VOD_URL_1 = ConstantVideo.VideoPlayerList[3];
private static final String VOD_URL_2 = ConstantVideo.VideoPlayerList[0];
private VideoPlayer player1;
private VideoPlayer player2;
private List<VideoPlayer> mVideoViews = new ArrayList<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_multiple_play);
initFindViewById();
initVideoPlayer();
}
private void initFindViewById() {
player1 = findViewById(R.id.video_player1);
player2 = findViewById(R.id.video_player2);
}
private void initVideoPlayer() {
//必须设置
player1.setUrl(VOD_URL_1);
VideoPlayerBuilder.Builder builder = VideoPlayerBuilder.newBuilder();
builder.setEnableAudioFocus(false);
VideoPlayerBuilder videoPlayerBuilder = new VideoPlayerBuilder(builder);
player1.setVideoBuilder(videoPlayerBuilder);
BasisVideoController controller1 = new BasisVideoController(this);
player1.setController(controller1);
mVideoViews.add(player1);
//必须设置
player2.setUrl(VOD_URL_2);
VideoPlayerBuilder.Builder builder2 = VideoPlayerBuilder.newBuilder();
builder.setEnableAudioFocus(false);
VideoPlayerBuilder videoPlayerBuilder2 = new VideoPlayerBuilder(builder2);
player2.setVideoBuilder(videoPlayerBuilder2);
BasisVideoController controller2 = new BasisVideoController(this);
player2.setController(controller2);
mVideoViews.add(player2);
}
@Override
protected void onPause() {
super.onPause();
for (VideoPlayer vv : mVideoViews) {
vv.pause();
}
}
@Override
protected void onResume() {
super.onResume();
for (VideoPlayer vv : mVideoViews) {
vv.pause();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
for (VideoPlayer vv : mVideoViews) {
vv.release();
}
}
@Override
public void onBackPressed() {
for (VideoPlayer vv : mVideoViews) {
if (vv.onBackPressed())
return;
}
super.onBackPressed();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/activity/NormalActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.activity;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.bumptech.glide.Glide;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.kernel.utils.PlayerConstant;
import com.yc.kernel.utils.PlayerFactoryUtils;
import com.yc.ycvideoplayer.BuriedPointEventImpl;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.player.OnVideoStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoPlayerBuilder;
import com.yc.video.player.VideoViewManager;
import com.yc.video.ui.view.BasisVideoController;
import com.yc.video.ui.view.CustomErrorView;
public class NormalActivity extends AppCompatActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private Button mBtnScaleNormal;
private Button mBtnScale169;
private Button mBtnScale43;
private Button mBtnScaleFull;
private Button mBtnScaleOriginal;
private Button mBtnScaleCrop;
private Button mBtnCrop;
private Button mBtnGif;
private BasisVideoController controller;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_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);
mBtnScaleFull = findViewById(R.id.btn_scale_full);
mBtnScaleOriginal = findViewById(R.id.btn_scale_original);
mBtnScaleCrop = findViewById(R.id.btn_scale_crop);
mBtnCrop = findViewById(R.id.btn_crop);
mBtnGif = findViewById(R.id.btn_gif);
}
private void initVideoPlayer() {
String url = getIntent().getStringExtra(IntentKeys.URL);
if (url==null || url.length()==0){
url = ConstantVideo.VideoPlayerList[0];
}
//创建基础视频播放器，一般播放器的功能
controller = new BasisVideoController(this);
//设置控制器
mVideoPlayer.setController(controller);
//设置视频播放链接地址
mVideoPlayer.setUrl(url);
//开始播放
mVideoPlayer.start();
mVideoPlayer.postDelayed(new Runnable() {
@Override
public void run() {
mVideoPlayer.start();
}
},300);
//设置视频背景图
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
}
private void initListener() {
mBtnScaleNormal.setOnClickListener(this);
mBtnScale169.setOnClickListener(this);
mBtnScale43.setOnClickListener(this);
mBtnScaleFull.setOnClickListener(this);
mBtnScaleOriginal.setOnClickListener(this);
mBtnScaleCrop.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 == mBtnScaleFull){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_MATCH_PARENT);
}else if (v == mBtnScaleOriginal){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_ORIGINAL);
}else if (v == mBtnScaleCrop){
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_CENTER_CROP);
}else if (v == mBtnCrop){
} else if (v == mBtnGif){
}
}
private void test(){
//VideoPlayer相关
VideoPlayerBuilder.Builder builder = VideoPlayerBuilder.newBuilder();
VideoPlayerBuilder videoPlayerBuilder = new VideoPlayerBuilder(builder);
//设置视频播放器的背景色
builder.setPlayerBackgroundColor(Color.BLACK);
//设置小屏的宽高
int[] mTinyScreenSize = {0, 0};
builder.setTinyScreenSize(mTinyScreenSize);
//是否开启AudioFocus监听， 默认开启
builder.setEnableAudioFocus(false);
mVideoPlayer.setVideoBuilder(videoPlayerBuilder);
//截图
Bitmap bitmap = mVideoPlayer.doScreenShot();
//移除所有播放状态监听
mVideoPlayer.clearOnStateChangeListeners();
//获取当前缓冲百分比
int bufferedPercentage = mVideoPlayer.getBufferedPercentage();
//获取当前播放器的状态
int currentPlayerState = mVideoPlayer.getCurrentPlayerState();
//获取当前的播放状态
int currentPlayState = mVideoPlayer.getCurrentPlayState();
//获取当前播放的位置
long currentPosition = mVideoPlayer.getCurrentPosition();
//获取视频总时长
long duration = mVideoPlayer.getDuration();
//获取倍速速度
float speed = mVideoPlayer.getSpeed();
//获取缓冲速度
long tcpSpeed = mVideoPlayer.getTcpSpeed();
//获取视频宽高
int[] videoSize = mVideoPlayer.getVideoSize();
//是否处于静音状态
boolean mute = mVideoPlayer.isMute();
//判断是否处于全屏状态
boolean fullScreen = mVideoPlayer.isFullScreen();
//是否是小窗口模式
boolean tinyScreen = mVideoPlayer.isTinyScreen();
//是否处于播放状态
boolean playing = mVideoPlayer.isPlaying();
//暂停播放
mVideoPlayer.pause();
//视频缓冲完毕，准备开始播放时回调
mVideoPlayer.onPrepared();
//重新播放
mVideoPlayer.replay(true);
//继续播放
mVideoPlayer.resume();
//调整播放进度
mVideoPlayer.seekTo(100);
//循环播放， 默认不循环播放
mVideoPlayer.setLooping(true);
//设置播放速度
mVideoPlayer.setSpeed(1.1f);
//设置音量 0.0f-1.0f 之间
mVideoPlayer.setVolume(1,1);
//开始播放
mVideoPlayer.start();
//进入全屏
mVideoPlayer.startFullScreen();
//退出全屏
mVideoPlayer.stopFullScreen();
//开启小屏
mVideoPlayer.startTinyScreen();
//退出小屏
mVideoPlayer.stopTinyScreen();
mVideoPlayer.setOnStateChangeListener(new OnVideoStateListener() {
/**
* 播放模式
* 普通模式，小窗口模式，正常模式三种其中一种
* MODE_NORMAL 普通模式
* MODE_FULL_SCREEN 全屏模式
* MODE_TINY_WINDOW 小屏模式
* @param playerState 播放模式
*/
@Override
public void onPlayerStateChanged(int playerState) {
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
//普通模式
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
//全屏模式
break;
case ConstantKeys.PlayMode.MODE_TINY_WINDOW:
//小屏模式
break;
}
}
/**
* 播放状态
* -1 播放错误
* 0 播放未开始
* 1 播放准备中
* 2 播放准备就绪
* 3 正在播放
* 4 暂停播放
* 5 正在缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，缓冲区数据足够后恢复播放)
* 6 暂停缓冲(播放器正在播放时，缓冲区数据不足，进行缓冲，此时暂停播放器，继续缓冲，缓冲区数据足够后恢复暂停
* 7 播放完成
* 8 开始播放中止
* @param playState 播放状态，主要是指播放器的各种状态
*/
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
//播放未开始，初始化
break;
case ConstantKeys.CurrentState.STATE_START_ABORT:
//开始播放中止
break;
case ConstantKeys.CurrentState.STATE_PREPARING:
//播放准备中
break;
case ConstantKeys.CurrentState.STATE_PREPARED:
//播放准备就绪
break;
case ConstantKeys.CurrentState.STATE_ERROR:
//播放错误
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
//正在缓冲
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
//正在播放
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
//暂停播放
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PAUSED:
//暂停缓冲
break;
case ConstantKeys.CurrentState.STATE_COMPLETED:
//播放完成
break;
}
}
});
//设置视频背景图
ImageView thumb = controller.getThumb();
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
//设置视频标题
controller.setTitle("视频标题");
//添加自定义视图。每添加一个视图，都是方式层级树的最上层
CustomErrorView customErrorView = new CustomErrorView(this);
controller.addControlComponent(customErrorView);
//移除控制组件
controller.removeControlComponent(customErrorView);
//移除所有的组件
controller.removeAllControlComponent();
//隐藏播放视图
controller.hide();
//显示播放视图
controller.show();
//是否开启根据屏幕方向进入/退出全屏
controller.setEnableOrientation(true);
//显示移动网络播放提示
controller.showNetWarning();
//刘海的高度
int cutoutHeight = controller.getCutoutHeight();
//是否有刘海屏
boolean b = controller.hasCutout();
//设置是否适配刘海屏
controller.setAdaptCutout(true);
//停止刷新进度
controller.stopProgress();
//开始刷新进度，注意：需在STATE_PLAYING时调用才会开始刷新进度
controller.startProgress();
//判断是否锁屏
boolean locked = controller.isLocked();
//设置是否锁屏
controller.setLocked(true);
//取消计时
controller.stopFadeOut();
//开始计时
controller.startFadeOut();
//设置播放视图自动隐藏超时
controller.setDismissTimeout(8);
//销毁
controller.destroy();
//播放器配置，注意：此为全局配置，按需开启
PlayerFactory player = PlayerFactoryUtils.getPlayer(PlayerConstant.PlayerType.TYPE_IJK);
VideoViewManager.setConfig(VideoPlayerConfig.newBuilder()
//设置上下文
.setContext(this)
//设置视频全局埋点事件
.setBuriedPointEvent(new BuriedPointEventImpl())
//调试的时候请打开日志，方便排错
.setLogEnabled(true)
//设置ijk
.setPlayerFactory(player)
//在移动环境下调用start()后是否继续播放，默认不继续播放
.setPlayOnMobileNetwork(false)
//是否开启AudioFocus监听， 默认开启
.setEnableAudioFocus(true)
//是否适配刘海屏，默认适配
.setAdaptCutout(true)
//监听设备方向来切换全屏/半屏， 默认不开启
.setEnableOrientation(false)
//设置自定义渲染view，自定义RenderView
//.setRenderViewFactory(null)
//创建
.build());
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/activity/TypeActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.activity;
import android.annotation.SuppressLint;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import org.yc.ycvideoplayer.R;
import com.yc.ycvideoplayer.newPlayer.ad.AdActivity;
import com.yc.ycvideoplayer.newPlayer.clarity.ClarityActivity;
import com.yc.ycvideoplayer.newPlayer.danmu.DanmuActivity;
import com.yc.ycvideoplayer.newPlayer.list.ContinuousVideoActivity;
import com.yc.ycvideoplayer.newPlayer.list.TestListActivity;
import com.yc.ycvideoplayer.newPlayer.pip.PipActivity;
import com.yc.ycvideoplayer.newPlayer.pip.PipListActivity;
import com.yc.ycvideoplayer.newPlayer.surface.TestSurfaceActivity;
import com.yc.ycvideoplayer.newPlayer.tiny.TestFullActivity;
import com.yc.ycvideoplayer.newPlayer.tiny.TinyScreenActivity;
import com.yc.video.config.ConstantKeys;
import com.yc.kernel.impl.exo.ExoMediaPlayer;
import com.yc.kernel.impl.exo.ExoPlayerFactory;
import com.yc.kernel.impl.ijk.IjkPlayerFactory;
import com.yc.kernel.impl.ijk.IjkVideoPlayer;
import com.yc.kernel.impl.media.AndroidMediaPlayer;
import com.yc.kernel.impl.media.MediaPlayerFactory;
import com.yc.kernel.factory.PlayerFactory;
import com.yc.video.config.VideoPlayerConfig;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.BaseToast;
import com.yc.video.tool.PlayerUtils;
import java.lang.reflect.Field;
public class TypeActivity extends AppCompatActivity implements View.OnClickListener {
private Toolbar mToolbar;
private TextView mTvTitle;
private TextView mTv11;
private TextView mTv12;
private TextView mTv13;
private TextView mTv21;
private TextView mTv22;
private TextView mTv23;
private TextView mTv31;
private TextView mTv32;
private TextView mTv33;
private TextView mTv41;
private TextView mTv42;
private TextView mTv43;
private TextView mTv61;
private TextView mTv62;
private TextView mTv63;
private TextView mTv64;
private TextView mTv65;
private TextView mTv66;
private TextView mTv71;
private TextView mTv81;
private TextView mTv101;
private TextView mTv111;
private TextView mTv131;
@SuppressLint("SetTextI18n")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_new);
initFindViewById();
initListener();
//检测当前是用的哪个播放器
Object factory = PlayerUtils.getCurrentPlayerFactory();
if (factory instanceof ExoPlayerFactory) {
mTvTitle.setText("视频内核：" + " (ExoPlayer)");
setTitle(getResources().getString(R.string.app_name) + " (ExoPlayer)");
} else if (factory instanceof IjkPlayerFactory) {
mTvTitle.setText("视频内核：" + " (IjkPlayer)");
} else if (factory instanceof MediaPlayerFactory) {
mTvTitle.setText("视频内核：" + " (MediaPlayer)");
} else {
mTvTitle.setText("视频内核：" + " (unknown)");
}
}
private void initFindViewById() {
mToolbar = findViewById(R.id.toolbar);
mTvTitle = findViewById(R.id.tv_title);
mTv11 = findViewById(R.id.tv_1_1);
mTv12 = findViewById(R.id.tv_1_2);
mTv13 = findViewById(R.id.tv_1_3);
mTv21 = findViewById(R.id.tv_2_1);
mTv22 = findViewById(R.id.tv_2_2);
mTv23 = findViewById(R.id.tv_2_3);
mTv31 = findViewById(R.id.tv_3_1);
mTv32 = findViewById(R.id.tv_3_2);
mTv33 = findViewById(R.id.tv_3_3);
mTv41 = findViewById(R.id.tv_4_1);
mTv42 = findViewById(R.id.tv_4_2);
mTv43 = findViewById(R.id.tv_4_3);
mTv61 = findViewById(R.id.tv_6_1);
mTv62 = findViewById(R.id.tv_6_2);
mTv63 = findViewById(R.id.tv_6_3);
mTv64 = findViewById(R.id.tv_6_4);
mTv65 = findViewById(R.id.tv_6_5);
mTv66 = findViewById(R.id.tv_6_6);
mTv71 = findViewById(R.id.tv_7_1);
mTv81 = findViewById(R.id.tv_8_1);
mTv101 = findViewById(R.id.tv_10_1);
mTv111 = findViewById(R.id.tv_11_1);
mTv131 = findViewById(R.id.tv_13_1);
}
private void initListener() {
mTv11.setOnClickListener(this);
mTv12.setOnClickListener(this);
mTv13.setOnClickListener(this);
mTv21.setOnClickListener(this);
mTv22.setOnClickListener(this);
mTv23.setOnClickListener(this);
mTv31.setOnClickListener(this);
mTv32.setOnClickListener(this);
mTv33.setOnClickListener(this);
mTv41.setOnClickListener(this);
mTv42.setOnClickListener(this);
mTv43.setOnClickListener(this);
mTv61.setOnClickListener(this);
mTv62.setOnClickListener(this);
mTv63.setOnClickListener(this);
mTv64.setOnClickListener(this);
mTv65.setOnClickListener(this);
mTv66.setOnClickListener(this);
mTv71.setOnClickListener(this);
mTv81.setOnClickListener(this);
mTv101.setOnClickListener(this);
mTv111.setOnClickListener(this);
mTv131.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v == mTv11){
//切换ijk
setChangeVideoType(ConstantKeys.VideoPlayerType.TYPE_IJK);
} else if (v == mTv12){
//切换exo
setChangeVideoType(ConstantKeys.VideoPlayerType.TYPE_EXO);
} else if (v == mTv13){
//切换原生
setChangeVideoType(ConstantKeys.VideoPlayerType.TYPE_NATIVE);
} else if (v == mTv21){
BaseToast.showRoundRectToast("待完善");
} else if (v == mTv22){
BaseToast.showRoundRectToast("待完善");
} else if (v == mTv23){
BaseToast.showRoundRectToast("待完善");
} else if (v == mTv31){
startActivity(new Intent(this,NormalActivity.class));
} else if (v == mTv32){
startActivity(new Intent(this, TestFullActivity.class));
} else if (v == mTv33){
startActivity(new Intent(this,MultipleActivity.class));
} else if (v == mTv41){
startActivity(new Intent(this, PipActivity.class));
} else if (v == mTv42){
startActivity(new Intent(this, PipListActivity.class));
} else if (v == mTv43){
startActivity(new Intent(this, TinyScreenActivity.class));
} else if (v == mTv61){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",0);
startActivity(intent);
} else if (v == mTv62){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",1);
startActivity(intent);
} else if (v == mTv63){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",2);
startActivity(intent);
} else if (v == mTv64){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",3);
startActivity(intent);
} else if (v == mTv65){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",4);
startActivity(intent);
} else if (v == mTv66){
Intent intent = new Intent(this, TestListActivity.class);
intent.putExtra("type",5);
startActivity(intent);
} else if (v == mTv71){
startActivity(new Intent(this, DanmuActivity.class));
} else if (v == mTv81){
startActivity(new Intent(this, AdActivity.class));
} else if (v == mTv101){
startActivity(new Intent(this, ContinuousVideoActivity.class));
} else if (v == mTv111){
startActivity(new Intent(this, ClarityActivity.class));
} else if (v == mTv131){
startActivity(new Intent(this, TestSurfaceActivity.class));
}
}
@SuppressLint("SetTextI18n")
private void setChangeVideoType(@ConstantKeys.PlayerType int type){
//切换播放核心，不推荐这么做，我这么写只是为了方便测试
VideoPlayerConfig config = VideoViewManager.getConfig();
try {
Field mPlayerFactoryField = config.getClass().getDeclaredField("mPlayerFactory");
mPlayerFactoryField.setAccessible(true);
PlayerFactory playerFactory = null;
switch (type) {
case ConstantKeys.VideoPlayerType.TYPE_IJK:
playerFactory = IjkPlayerFactory.create();
IjkVideoPlayer ijkVideoPlayer = (IjkVideoPlayer) playerFactory.createPlayer(this);
mTvTitle.setText("视频内核：" + " (IjkPlayer)");
break;
case ConstantKeys.VideoPlayerType.TYPE_EXO:
playerFactory = ExoPlayerFactory.create();
ExoMediaPlayer exoMediaPlayer = (ExoMediaPlayer) playerFactory.createPlayer(this);
mTvTitle.setText("视频内核：" + " (ExoPlayer)");
break;
case ConstantKeys.VideoPlayerType.TYPE_NATIVE:
playerFactory = MediaPlayerFactory.create();
AndroidMediaPlayer androidMediaPlayer = (AndroidMediaPlayer) playerFactory.createPlayer(this);
mTvTitle.setText("视频内核：" + " (MediaPlayer)");
break;
case ConstantKeys.VideoPlayerType.TYPE_RTC:
break;
}
mPlayerFactoryField.set(config, playerFactory);
} catch (Exception e) {
e.printStackTrace();
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/ad/AdActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.ad;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.bumptech.glide.Glide;
import com.yc.videocache.HttpProxyCacheServer;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.videocache.cache.ProxyVideoCacheManager;
import com.yc.video.config.ConstantKeys;
import com.yc.video.player.SimpleStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.BaseToast;
import com.yc.video.ui.view.BasisVideoController;
public class AdActivity extends AppCompatActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private Button mBtnScaleNormal;
private Button mBtnScale169;
private Button mBtnScale43;
private Button mBtnCrop;
private Button mBtnGif;
private static final String URL_AD = "https://gslb.miaopai.com/stream/IR3oMYDhrON5huCmf7sHCfnU5YKEkgO2.mp4";
BasisVideoController controller;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ad_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() {
controller = new BasisVideoController(this);
AdControlView adControlView = new AdControlView(this);
adControlView.setListener(new AdControlView.AdControlListener() {
@Override
public void onAdClick() {
BaseToast.showRoundRectToast( "广告点击跳转");
}
@Override
public void onSkipAd() {
playVideo();
}
});
controller.addControlComponent(adControlView);
//设置视频背景图
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
//设置控制器
mVideoPlayer.setController(controller);
HttpProxyCacheServer cacheServer = ProxyVideoCacheManager.getProxy(this);
String proxyUrl = cacheServer.getProxyUrl(URL_AD);
HttpProxyCacheServer server = new HttpProxyCacheServer(this);
String proxyVideoUrl = server.getProxyUrl(URL_AD);
mVideoPlayer.setUrl(proxyUrl);
mVideoPlayer.start();
//监听播放结束
mVideoPlayer.addOnStateChangeListener(new SimpleStateListener() {
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
playVideo();
}
}
});
}
/**
* 播放正片
*/
private void playVideo() {
mVideoPlayer.release();
controller.removeAllControlComponent();
controller.addDefaultControlComponent("正片");
//重新设置数据
mVideoPlayer.setUrl(ConstantVideo.VideoPlayerList[0]);
//开始播放
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/ad/AdControlView.java | Java | package com.yc.ycvideoplayer.newPlayer.ad;
import android.app.Activity;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import org.yc.ycvideoplayer.R;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.ui.view.InterControlView;
import com.yc.video.tool.PlayerUtils;
public class AdControlView extends FrameLayout implements InterControlView, View.OnClickListener {
private Context mContext;
protected TextView mAdTime, mAdDetail;
protected ImageView mBack, mVolume, mFullScreen, mPlayButton;
protected AdControlListener mListener;
private ControlWrapper mControlWrapper;
public AdControlView(@NonNull Context context) {
super(context);
init(context);
}
public AdControlView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
init(context);
}
public AdControlView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context){
this.mContext = context;
LayoutInflater.from(getContext()).inflate(R.layout.layout_ad_control_view, this, true);
mAdTime = findViewById(R.id.ad_time);
mAdDetail = findViewById(R.id.ad_detail);
mAdDetail.setText("了解详情>");
mBack = findViewById(R.id.back);
mBack.setVisibility(GONE);
mVolume = findViewById(R.id.iv_volume);
mFullScreen = findViewById(R.id.fullscreen);
mPlayButton = findViewById(R.id.iv_play);
mPlayButton.setOnClickListener(this);
mAdTime.setOnClickListener(this);
mAdDetail.setOnClickListener(this);
mBack.setOnClickListener(this);
mVolume.setOnClickListener(this);
mFullScreen.setOnClickListener(this);
this.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (mListener != null) mListener.onAdClick();
}
});
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_PLAYING:
mControlWrapper.startProgress();
mPlayButton.setSelected(true);
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
mPlayButton.setSelected(false);
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
switch (playerState) {
case ConstantKeys.PlayMode.MODE_NORMAL:
mBack.setVisibility(GONE);
mFullScreen.setSelected(false);
break;
case ConstantKeys.PlayMode.MODE_FULL_SCREEN:
mBack.setVisibility(VISIBLE);
mFullScreen.setSelected(true);
break;
}
//暂未实现全面屏适配逻辑，需要你自己补全
}
@Override
public void setProgress(int duration, int position) {
if (mAdTime != null)
mAdTime.setText(String.format("%s | 跳过", (duration - position) / 1000));
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
@Override
public void onClick(View v) {
int id = v.getId();
if (id == R.id.back | id == R.id.fullscreen) {
toggleFullScreen();
} else if (id == R.id.iv_volume) {
doMute();
} else if (id == R.id.ad_detail) {
if (mListener != null) mListener.onAdClick();
} else if (id == R.id.ad_time) {
if (mListener != null) mListener.onSkipAd();
} else if (id == R.id.iv_play) {
mControlWrapper.togglePlay();
}
}
private void doMute() {
mControlWrapper.setMute(!mControlWrapper.isMute());
mVolume.setImageResource(mControlWrapper.isMute() ? R.drawable.ic_player_volume_up : R.drawable.ic_player_volume_off);
}
/**
* 横竖屏切换
*/
private void toggleFullScreen() {
Activity activity = PlayerUtils.scanForActivity(getContext());
mControlWrapper.toggleFullScreen(activity);
}
public void setListener(AdControlListener listener) {
this.mListener = listener;
}
public interface AdControlListener {
void onAdClick();
void onSkipAd();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/clarity/ClarityActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.clarity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.bumptech.glide.Glide;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoPlayer;
import com.yc.video.ui.view.BasisVideoController;
import com.yc.video.ui.view.CustomBottomView;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
public class ClarityActivity extends AppCompatActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private Button mBtnScaleNormal;
private Button mBtnScale169;
private Button mBtnScale43;
private Button mBtnCrop;
private Button mBtnGif;
@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);
CustomBottomView bottomView = controller.getBottomView();
if (bottomView!=null){
controller.removeControlComponent(bottomView);
}
DefinitionControlView mDefinitionControlView = new DefinitionControlView(this);
mDefinitionControlView.setOnRateSwitchListener(new DefinitionControlView.OnRateSwitchListener() {
@Override
public void onRateChange(String url) {
mVideoPlayer.setUrl(url);
mVideoPlayer.replay(false);
}
});
List<VideoInfoBean> clarites = getClarites();
LinkedHashMap<String, String> videos = new LinkedHashMap<>();
for (int i=0 ; i<clarites.size() ; i++){
VideoInfoBean videoClarity = clarites.get(i);
videos.put(videoClarity.getGrade(),videoClarity.getVideoUrl());
}
mDefinitionControlView.setData(videos);
controller.addControlComponent(mDefinitionControlView);
//设置视频背景图
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
//设置控制器
mVideoPlayer.setController(controller);
mVideoPlayer.setUrl(clarites.get(0).getVideoUrl());
mVideoPlayer.start();
}
public List<VideoInfoBean> getClarites() {
List<VideoInfoBean> clarities = new ArrayList<>();
clarities.add(new VideoInfoBean("标题哈哈哈哈","标清", "270P", "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"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","高清", "480P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","超清", "720P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","蓝光", "1080P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
return clarities;
}
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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/clarity/DefinitionControlView.java | Java | package com.yc.ycvideoplayer.newPlayer.clarity;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.widget.LinearLayout;
import android.widget.PopupWindow;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.CustomBottomView;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
public class DefinitionControlView extends CustomBottomView {
private TextView mDefinition;
private PopupWindow mPopupWindow;
private List<String> mRateStr;
private LinearLayout mPopLayout;
private int mCurIndex;
private LinkedHashMap<String, String> mMultiRateData;
private OnRateSwitchListener mOnRateSwitchListener;
public DefinitionControlView(@NonNull Context context) {
super(context);
}
public DefinitionControlView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public DefinitionControlView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
{
mPopupWindow = new PopupWindow(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
mPopLayout = (LinearLayout) LayoutInflater.from(getContext()).inflate(R.layout.layout_rate_pop, this, false);
mPopupWindow.setContentView(mPopLayout);
mPopupWindow.setBackgroundDrawable(new ColorDrawable(0xffffffff));
mPopupWindow.setOutsideTouchable(true);
mPopupWindow.setClippingEnabled(false);
mDefinition = findViewById(R.id.tv_definition);
mDefinition.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showRateMenu();
}
});
}
private void showRateMenu() {
mPopLayout.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
mPopupWindow.showAsDropDown(mDefinition, -((mPopLayout.getMeasuredWidth() - mDefinition.getMeasuredWidth()) / 2),
-(mPopLayout.getMeasuredHeight() + mDefinition.getMeasuredHeight() + PlayerUtils.dp2px(getContext(), 10)));
}
@Override
protected int getLayoutId() {
return R.layout.layout_definition_control_view;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
super.onVisibilityChanged(isVisible, anim);
if (!isVisible) {
mPopupWindow.dismiss();
}
}
@Override
public void onPlayerStateChanged(int playerState) {
super.onPlayerStateChanged(playerState);
if (playerState == ConstantKeys.PlayMode.MODE_FULL_SCREEN) {
mDefinition.setVisibility(VISIBLE);
} else {
mDefinition.setVisibility(GONE);
mPopupWindow.dismiss();
}
}
public void setData(LinkedHashMap<String, String> multiRateData) {
mMultiRateData = multiRateData;
if (mDefinition != null && TextUtils.isEmpty(mDefinition.getText())) {
if (multiRateData == null) return;
mRateStr = new ArrayList<>();
int index = 0;
ListIterator<Map.Entry<String, String>> iterator = new ArrayList<>(multiRateData.entrySet()).listIterator(multiRateData.size());
while (iterator.hasPrevious()) {//反向遍历
Map.Entry<String, String> entry = iterator.previous();
mRateStr.add(entry.getKey());
TextView rateItem = (TextView) LayoutInflater.from(getContext()).inflate(R.layout.layout_rate_item, null);
rateItem.setText(entry.getKey());
rateItem.setTag(index);
rateItem.setOnClickListener(rateOnClickListener);
mPopLayout.addView(rateItem);
index++;
}
((TextView) mPopLayout.getChildAt(index - 1)).setTextColor(ContextCompat.getColor(getContext(), R.color.color_1));
mDefinition.setText(mRateStr.get(index - 1));
mCurIndex = index - 1;
}
}
private View.OnClickListener rateOnClickListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
int index = (int) v.getTag();
if (mCurIndex == index) return;
((TextView) mPopLayout.getChildAt(mCurIndex)).setTextColor(Color.BLACK);
((TextView) mPopLayout.getChildAt(index)).setTextColor(ContextCompat.getColor(getContext(), R.color.color_1));
mDefinition.setText(mRateStr.get(index));
switchDefinition(mRateStr.get(index));
mPopupWindow.dismiss();
mCurIndex = index;
}
};
private void switchDefinition(String s) {
mControlWrapper.hide();
mControlWrapper.stopProgress();
String url = mMultiRateData.get(s);
if (mOnRateSwitchListener != null){
mOnRateSwitchListener.onRateChange(url);
}
}
public interface OnRateSwitchListener {
void onRateChange(String url);
}
public void setOnRateSwitchListener(OnRateSwitchListener onRateSwitchListener) {
mOnRateSwitchListener = onRateSwitchListener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/danmu/CenteredImageSpan.java | Java | package com.yc.ycvideoplayer.newPlayer.danmu;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.text.style.ImageSpan;
/**
* 图文混排使图片文字基于中线对齐
*/
public class CenteredImageSpan extends ImageSpan {
public CenteredImageSpan(final Drawable drawable) {
super(drawable);
}
@Override
public int getSize(Paint paint, CharSequence text, int start, int end,
Paint.FontMetricsInt fm) {
Drawable d = getDrawable();
Rect rect = d.getBounds();
if (fm != null) {
Paint.FontMetricsInt fmPaint = paint.getFontMetricsInt();
int fontHeight = fmPaint.bottom - fmPaint.top;
int drHeight = rect.bottom - rect.top;
int top = drHeight / 2 - fontHeight / 4;
int bottom = drHeight / 2 + fontHeight / 4;
fm.ascent = -bottom;
fm.top = -bottom;
fm.bottom = top;
fm.descent = top;
}
return rect.right;
}
@Override
public void draw(Canvas canvas, CharSequence text, int start, int end,
float x, int top, int y, int bottom, Paint paint) {
Drawable b = getDrawable();
canvas.save();
int transY;
transY = ((bottom - top) - b.getBounds().bottom) / 2 + top;
canvas.translate(x, transY);
b.draw(canvas);
canvas.restore();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/danmu/DanmuActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.danmu;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.player.SimpleStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.ui.view.BasisVideoController;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class DanmuActivity extends BaseActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private LinearLayout mLayout;
private Button mBtnShow;
private Button mBtnHide;
private Button mBtnAddDan;
private Button mBtnAddCustomDan;
private MyDanmakuView mMyDanmakuView;
@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();
}
if (mHandler!=null){
mHandler.removeCallbacksAndMessages(null);
mHandler = null;
}
}
@Override
public void onBackPressed() {
if (mVideoPlayer == null || !mVideoPlayer.onBackPressed()) {
super.onBackPressed();
}
}
@Override
public int getContentView() {
return R.layout.activity_danmu_player;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
initFindViewById();
BasisVideoController controller = new BasisVideoController(this);
mMyDanmakuView = new MyDanmakuView(this);
controller.addControlComponent(mMyDanmakuView);
//设置视频背景图
Glide.with(this).load(R.drawable.image_default).into(controller.getThumb());
//设置控制器
mVideoPlayer.setController(controller);
mVideoPlayer.setUrl(ConstantVideo.VideoPlayerList[0]);
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9);
mVideoPlayer.start();
mVideoPlayer.addOnStateChangeListener(new SimpleStateListener() {
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_PREPARED) {
simulateDanmu();
} else if (playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
mHandler.removeCallbacksAndMessages(null);
}
}
});
}
private void initFindViewById() {
mVideoPlayer = findViewById(R.id.video_player);
mLayout = findViewById(R.id.layout);
mBtnShow = findViewById(R.id.btn_show);
mBtnHide = findViewById(R.id.btn_hide);
mBtnAddDan = findViewById(R.id.btn_add_dan);
mBtnAddCustomDan = findViewById(R.id.btn_add_custom_dan);
}
@Override
public void initListener() {
mBtnShow.setOnClickListener(this);
mBtnHide.setOnClickListener(this);
mBtnAddDan.setOnClickListener(this);
mBtnAddCustomDan.setOnClickListener(this);
}
@Override
public void initData() {
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_show:
mMyDanmakuView.show();
break;
case R.id.btn_hide:
mMyDanmakuView.hide();
break;
case R.id.btn_add_dan:
mMyDanmakuView.addDanmakuWithDrawable();
break;
case R.id.btn_add_custom_dan:
mMyDanmakuView.addDanmaku("小杨逗比自定义弹幕~", true);
break;
default:
break;
}
}
private Handler mHandler = new Handler();
/**
* 模拟弹幕
*/
private void simulateDanmu() {
mHandler.post(new Runnable() {
@Override
public void run() {
mMyDanmakuView.addDanmaku("awsl", false);
mHandler.postDelayed(this, 100);
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/danmu/MyDanmakuView.java | Java | package com.yc.ycvideoplayer.newPlayer.danmu;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.Animation;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
import org.yc.ycvideoplayer.R;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.ui.view.InterControlView;
import com.yc.video.tool.PlayerUtils;
import master.flame.danmaku.controller.DrawHandler;
import master.flame.danmaku.danmaku.model.BaseDanmaku;
import master.flame.danmaku.danmaku.model.DanmakuTimer;
import master.flame.danmaku.danmaku.model.IDanmakus;
import master.flame.danmaku.danmaku.model.IDisplayer;
import master.flame.danmaku.danmaku.model.android.DanmakuContext;
import master.flame.danmaku.danmaku.model.android.Danmakus;
import master.flame.danmaku.danmaku.model.android.SpannedCacheStuffer;
import master.flame.danmaku.danmaku.parser.BaseDanmakuParser;
import master.flame.danmaku.ui.widget.DanmakuView;
public class MyDanmakuView extends DanmakuView implements InterControlView {
private DanmakuContext mContext;
private BaseDanmakuParser mParser;
public MyDanmakuView(@NonNull Context context) {
super(context);
}
public MyDanmakuView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public MyDanmakuView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
{
// 设置最大显示行数
// HashMap<Integer, Integer> maxLinesPair = new HashMap<>();
// maxLinesPair.put(BaseDanmaku.TYPE_SCROLL_RL, 5); // 滚动弹幕最大显示5行
// 设置是否禁止重叠
// HashMap<Integer, Boolean> overlappingEnablePair = new HashMap<>();
// overlappingEnablePair.put(BaseDanmaku.TYPE_SCROLL_RL, true);
// overlappingEnablePair.put(BaseDanmaku.TYPE_FIX_TOP, true);
mContext = DanmakuContext.create();
mContext.setDanmakuStyle(IDisplayer.DANMAKU_STYLE_STROKEN, 3)
.setDuplicateMergingEnabled(false)
.setScrollSpeedFactor(1.2f)
.setScaleTextSize(1.2f)
// .setCacheStuffer(new SpannedCacheStuffer(), null) // 图文混排使用SpannedCacheStuffer
// .setCacheStuffer(new BackgroundCacheStuffer(), null) // 绘制背景使用BackgroundCacheStuffer
.setMaximumLines(null)
.preventOverlapping(null).setDanmakuMargin(40);
mParser = new BaseDanmakuParser() {
@Override
protected IDanmakus parse() {
return new Danmakus();
}
};
setCallback(new DrawHandler.Callback() {
@Override
public void prepared() {
start();
}
@Override
public void updateTimer(DanmakuTimer timer) {
}
@Override
public void danmakuShown(BaseDanmaku danmaku) {
}
@Override
public void drawingFinished() {
}
});
showFPS(true);
enableDanmakuDrawingCache(true);
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
release();
break;
case ConstantKeys.CurrentState.STATE_PREPARING:
if (isPrepared()) {
restart();
}
prepare(mParser, mContext);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
if (isPrepared() && isPaused()) {
resume();
}
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
if (isPrepared()) {
pause();
}
break;
case ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING:
clear();
clearDanmakusOnScreen();
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
/**
* 发送文字弹幕
*
* @param text 弹幕文字
* @param isSelf 是不是自己发的
*/
public void addDanmaku(String text, boolean isSelf) {
mContext.setCacheStuffer(new SpannedCacheStuffer(), null);
BaseDanmaku danmaku = mContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
if (danmaku == null) {
return;
}
danmaku.text = text;
danmaku.priority = 0; // 可能会被各种过滤器过滤并隐藏显示
danmaku.isLive = false;
danmaku.setTime(getCurrentTime() + 1200);
danmaku.textSize = PlayerUtils.sp2px(getContext(), 12);
danmaku.textColor = Color.WHITE;
danmaku.textShadowColor = Color.GRAY;
// danmaku.underlineColor = Color.GREEN;
danmaku.borderColor = isSelf ? Color.GREEN : Color.TRANSPARENT;
addDanmaku(danmaku);
}
/**
* 发送自定义弹幕
*/
public void addDanmakuWithDrawable() {
mContext.setCacheStuffer(new BackgroundCacheStuffer(), null);
BaseDanmaku danmaku = mContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
if (danmaku == null) {
return;
}
// for(int i=0;i<100;i++){
// }
Drawable drawable = ContextCompat.getDrawable(getContext(), R.mipmap.ic_launcher_round);
int size = PlayerUtils.dp2px(getContext(), 20);
drawable.setBounds(0, 0, size, size);
// danmaku.text = "这是一条弹幕";
danmaku.text = createSpannable(drawable);
// danmaku.padding = 5;
danmaku.priority = 0; // 可能会被各种过滤器过滤并隐藏显示
danmaku.isLive = false;
danmaku.setTime(getCurrentTime() + 1200);
danmaku.textSize = PlayerUtils.sp2px(getContext(), 12);
danmaku.textColor = Color.RED;
danmaku.textShadowColor = Color.WHITE;
// danmaku.underlineColor = Color.GREEN;
// danmaku.borderColor = Color.GREEN;
addDanmaku(danmaku);
}
private SpannableStringBuilder createSpannable(Drawable drawable) {
String text = "bitmap";
SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(text);
CenteredImageSpan span = new CenteredImageSpan(drawable);//ImageSpan.ALIGN_BOTTOM);
spannableStringBuilder.setSpan(span, 0, text.length(), Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
spannableStringBuilder.append(" 这是一条自定义弹幕~");
return spannableStringBuilder;
}
/**
* 绘制背景(自定义弹幕样式)
*/
private class BackgroundCacheStuffer extends SpannedCacheStuffer {
// 通过扩展SimpleTextCacheStuffer或SpannedCacheStuffer个性化你的弹幕样式
final Paint paint = new Paint();
@Override
public void measure(BaseDanmaku danmaku, TextPaint paint, boolean fromWorkerThread) {
// danmaku.padding = 5; // 在背景绘制模式下增加padding
super.measure(danmaku, paint, fromWorkerThread);
}
@Override
public void drawBackground(BaseDanmaku danmaku, Canvas canvas, float left, float top) {
paint.setAntiAlias(true);
paint.setColor(Color.parseColor("#65777777"));//黑色 普通
int radius = PlayerUtils.dp2px(getContext(), 10);
canvas.drawRoundRect(new RectF(left, top, left + danmaku.paintWidth, top + danmaku.paintHeight), radius, radius, paint);
}
@Override
public void drawStroke(BaseDanmaku danmaku, String lineText, Canvas canvas, float left, float top, Paint paint) {
// 禁用描边绘制
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/ContinuousVideoActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
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 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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/OnItemChildClickListener.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
public interface OnItemChildClickListener {
void onItemChildClick(int position);
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/OnItemClickListener.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
public interface OnItemClickListener {
void onItemClick(int position);
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/PlayerMonitor.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.view.View;
import android.view.animation.Animation;
import androidx.annotation.NonNull;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.ui.view.InterControlView;
import com.yc.video.tool.PlayerUtils;
public class PlayerMonitor implements InterControlView {
private ControlWrapper mControlWrapper;
private static final String TAG = "PlayerMonitor";
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return null;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
VideoLogUtils.d(TAG+ "---" +"onVisibilityChanged: " + isVisible);
}
@Override
public void onPlayStateChanged(int playState) {
VideoLogUtils.d(TAG+ "---" +"onPlayStateChanged: " + PlayerUtils.playState2str(playState));
}
@Override
public void onPlayerStateChanged(int playerState) {
VideoLogUtils.d(TAG+ "---" +"onPlayerStateChanged: " + PlayerUtils.playerState2str(playerState));
}
@Override
public void setProgress(int duration, int position) {
VideoLogUtils.d(TAG+ "---" +"setProgress: duration: " + duration + " position: " + position + " buffered percent: " + mControlWrapper.getBufferedPercentage());
VideoLogUtils.d(TAG+ "---" +"network speed: " + mControlWrapper.getTcpSpeed());
}
@Override
public void onLockStateChanged(boolean isLocked) {
VideoLogUtils.d(TAG+ "---" +"onLockStateChanged: " + isLocked);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/RecyclerView2Fragment.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.pagerlib.recycler.ScrollPageHelper;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
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 java.util.ArrayList;
import java.util.List;
import java.util.Objects;
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(Objects.requireNonNull(getActivity()).getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mCurPos = -1;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/RecyclerViewAutoPlayFragment.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.graphics.Rect;
import android.view.View;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
/**
* 滑动列表自动播放，仅包含自动播放的逻辑
*/
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 == 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/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/RecyclerViewFragment.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.SimpleStateListener;
import com.yc.video.player.VideoViewManager;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import java.util.ArrayList;
import java.util.List;
/**
* 普通的列表播放
*/
public class RecyclerViewFragment 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);
mRecyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
VideoLogUtils.i("addOnChildAttachStateChangeListener-----AttachedToWindow---"+view);
}
/**
* 当适配器创建的view（即列表项view）被窗口分离（即滑动离开了当前窗口界面）就会被调用
*
* @param view
*/
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
VideoLogUtils.i("addOnChildAttachStateChangeListener-----DetachedFromWindow---"+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() {
if (mVideoView.isFullScreen()) {
mVideoView.stopFullScreen();
}
mVideoView.release();
if(getActivity().getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mCurPos = -1;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/SeamlessPlayFragment.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.transition.Transition;
import android.view.View;
import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;
import androidx.core.app.ActivityOptionsCompat;
import org.yc.ycvideoplayer.R;
import com.yc.ycvideoplayer.newPlayer.activity.DetailActivity;
import com.yc.ycvideoplayer.newPlayer.activity.IntentKeys;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
/**
* 无缝播放
*/
public class SeamlessPlayFragment extends RecyclerViewAutoPlayFragment {
private boolean mSkipToDetail;
@Override
protected void initView(View view) {
super.initView(view);
//提前添加到VideoViewManager，供详情使用
VideoViewManager.instance().add(mVideoView, "seamless");
mAdapter.setOnItemClickListener(position -> {
mSkipToDetail = true;
Intent intent = new Intent(getActivity(), DetailActivity.class);
Bundle bundle = new Bundle();
VideoInfoBean videoBean = mVideos.get(position);
if (mCurPos == position) {
//需要无缝播放
bundle.putBoolean(IntentKeys.SEAMLESS_PLAY, true);
bundle.putString(IntentKeys.TITLE, videoBean.getTitle());
} else {
//无需无缝播放，把相应数据传到详情页
mVideoView.release();
//需要把控制器还原
mController.setPlayState(ConstantKeys.CurrentState.STATE_IDLE);
bundle.putBoolean(IntentKeys.SEAMLESS_PLAY, false);
bundle.putString(IntentKeys.URL, videoBean.getVideoUrl());
bundle.putString(IntentKeys.TITLE, videoBean.getTitle());
mCurPos = position;
}
intent.putExtras(bundle);
View sharedView = mLinearLayoutManager.findViewByPosition(position).findViewById(R.id.player_container);
//使用共享元素动画
ActivityOptionsCompat options = ActivityOptionsCompat
.makeSceneTransitionAnimation(getActivity(), sharedView, DetailActivity.VIEW_NAME_PLAYER_CONTAINER);
ActivityCompat.startActivity(getActivity(), intent, options.toBundle());
});
}
@Override
protected void startPlay(int position) {
mVideoView.setController(mController);
super.startPlay(position);
}
@Override
protected void pause() {
if (!mSkipToDetail) {
super.pause();
}
}
@Override
protected void resume() {
if (mSkipToDetail) {
mSkipToDetail = false;
} else {
super.resume();
}
}
@Override
public void onStart() {
super.onStart();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP || !addTransitionListener()) {
restoreVideoView();
}
}
@RequiresApi(21)
private boolean addTransitionListener() {
final Transition transition = getActivity().getWindow().getSharedElementExitTransition();
if (transition != null) {
transition.addListener(new Transition.TransitionListener() {
@Override
public void onTransitionEnd(Transition transition) {
restoreVideoView();
transition.removeListener(this);
}
@Override
public void onTransitionStart(Transition transition) {
}
@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;
}
private void restoreVideoView() {
//还原播放器
View itemView = mLinearLayoutManager.findViewByPosition(mCurPos);
VideoRecyclerViewAdapter.VideoHolder viewHolder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
mVideoView = VideoViewManager.instance().get("seamless");
PlayerUtils.removeViewFormParent(mVideoView);
viewHolder.mPlayerContainer.addView(mVideoView, 0);
mController.addControlComponent(viewHolder.mPrepareView, true);
mController.setPlayState(mVideoView.getCurrentPlayState());
mController.setPlayerState(mVideoView.getCurrentPlayerState());
mRecyclerView.postDelayed(new Runnable() {
@Override
public void run() {
mVideoView.setController(mController);
}
}, 100);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/TestListActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import com.yc.ycvideoplayer.BaseActivity;
import org.yc.ycvideoplayer.R;
import com.yc.ycvideoplayer.newPlayer.tiktok.TikTok1ListFragment;
import com.yc.ycvideoplayer.newPlayer.tiktok.TikTokListFragment;
import com.yc.video.old.other.VideoPlayerManager;
/**
* @author yc
*/
public class TestListActivity extends BaseActivity {
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) {
return;
}
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.activity_test_fragment;
}
@Override
public void initView() {
int type = getIntent().getIntExtra("type", 0);
if (type==0){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerViewFragment())
.commit();
} else if (type==1){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerViewAutoPlayFragment())
.commit();
} else if (type==2){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new TikTokListFragment())
.commit();
} else if (type==3){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new TikTok1ListFragment())
.commit();
}else if (type==4){
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new SeamlessPlayFragment())
.commit();
}else {
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new RecyclerView2Fragment())
.commit();
}
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/list/VideoRecyclerViewAdapter.java | Java | package com.yc.ycvideoplayer.newPlayer.list;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.ui.view.CustomPrepareView;
import java.util.List;
public class VideoRecyclerViewAdapter extends RecyclerView.Adapter<VideoRecyclerViewAdapter.VideoHolder> {
private List<VideoInfoBean> videos;
private OnItemChildClickListener mOnItemChildClickListener;
private OnItemClickListener mOnItemClickListener;
public VideoRecyclerViewAdapter(List<VideoInfoBean> videos) {
this.videos = videos;
}
@Override
@NonNull
public VideoHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_video, parent, false);
return new VideoHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull VideoHolder holder, int position) {
VideoInfoBean videoBean = videos.get(position);
Glide.with(holder.mThumb.getContext())
.load(videoBean.getCover())
.placeholder(android.R.color.darker_gray)
.into(holder.mThumb);
holder.mTitle.setText(videoBean.getTitle());
holder.mPosition = position;
}
@Override
public int getItemCount() {
return videos.size();
}
public void addData(List<VideoInfoBean> videoList) {
int size = videos.size();
videos.addAll(videoList);
//使用此方法添加数据，使用notifyDataSetChanged会导致正在播放的视频中断
notifyItemRangeChanged(size, videos.size());
}
public class VideoHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
public int mPosition;
public FrameLayout mPlayerContainer;
public TextView mTitle;
public ImageView mThumb;
public CustomPrepareView mPrepareView;
VideoHolder(View itemView) {
super(itemView);
mPlayerContainer = itemView.findViewById(R.id.player_container);
mTitle = itemView.findViewById(R.id.tv_title);
mPrepareView = itemView.findViewById(R.id.prepare_view);
mThumb = mPrepareView.getThumb();
if (mOnItemChildClickListener != null) {
mPlayerContainer.setOnClickListener(this);
}
if (mOnItemClickListener != null) {
itemView.setOnClickListener(this);
}
//通过tag将ViewHolder和itemView绑定
itemView.setTag(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.player_container) {
if (mOnItemChildClickListener != null) {
mOnItemChildClickListener.onItemChildClick(mPosition);
}
} else {
if (mOnItemClickListener != null) {
mOnItemClickListener.onItemClick(mPosition);
}
}
}
}
public void setOnItemChildClickListener(OnItemChildClickListener onItemChildClickListener) {
mOnItemChildClickListener = onItemChildClickListener;
}
public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
mOnItemClickListener = onItemClickListener;
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/pip/PipActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.pip;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.ImageView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.ui.pip.FloatVideoManager;
import com.yc.video.ui.view.BasisVideoController;
public class PipActivity extends AppCompatActivity{
private FloatVideoManager mPIPManager;
private FrameLayout mPlayerContainer;
private Button mBtnFloat;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pip_video);
initFindViewById();
initVideoPlayer();
initListener();
}
@Override
protected void onPause() {
super.onPause();
mPIPManager.pause();
}
@Override
protected void onResume() {
super.onResume();
mPIPManager.resume();
}
@Override
protected void onDestroy() {
super.onDestroy();
mPIPManager.reset();
}
@Override
public void onBackPressed() {
if (mPIPManager.onBackPress()) return;
super.onBackPressed();
}
private void initFindViewById() {
mPlayerContainer = findViewById(R.id.player_container);
mBtnFloat = findViewById(R.id.btn_float);
}
private void initVideoPlayer() {
mPIPManager = FloatVideoManager.getInstance(this);
VideoPlayer videoView = VideoViewManager.instance().get(FloatVideoManager.PIP);
BasisVideoController controller = new BasisVideoController(this);
videoView.setController(controller);
if (mPIPManager.isStartFloatWindow()) {
mPIPManager.stopFloatWindow();
controller.setPlayerState(videoView.getCurrentPlayerState());
controller.setPlayState(videoView.getCurrentPlayState());
} else {
mPIPManager.setActClass(PipActivity.class);
ImageView thumb = controller.getThumb();
Glide.with(this)
.load(R.drawable.image_default)
.placeholder(android.R.color.darker_gray)
.into(thumb);
videoView.setUrl(ConstantVideo.VideoPlayerList[0]);
}
mPlayerContainer.addView(videoView);
}
private void initListener() {
mBtnFloat.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPIPManager.startFloatWindow();
mPIPManager.resume();
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/pip/PipListActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.pip;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.View;
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.ycvideoplayer.ConstantVideo;
import com.yc.ycvideoplayer.newPlayer.list.OnItemChildClickListener;
import com.yc.ycvideoplayer.newPlayer.list.VideoRecyclerViewAdapter;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoPlayer;
import com.yc.video.player.VideoViewManager;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.pip.FloatVideoManager;
import com.yc.video.ui.view.BasisVideoController;
import java.util.List;
/**
* 悬浮播放终极版
*/
public class PipListActivity extends AppCompatActivity implements OnItemChildClickListener {
private FloatVideoManager mPIPManager;
private VideoPlayer mVideoView;
private BasisVideoController mController;
private List<VideoInfoBean> mVideos;
private LinearLayoutManager mLinearLayoutManager;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recycler_view);
initView();
}
protected void initView() {
mPIPManager = FloatVideoManager.getInstance(this);
mVideoView = VideoViewManager.instance().get(FloatVideoManager.PIP);
mController = new BasisVideoController(this);
initRecyclerView();
}
private void initRecyclerView() {
RecyclerView recyclerView = findViewById(R.id.recyclerView);
mLinearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(mLinearLayoutManager);
mVideos = ConstantVideo.getVideoList();
VideoRecyclerViewAdapter adapter = new VideoRecyclerViewAdapter(mVideos);
adapter.setOnItemChildClickListener(this);
recyclerView.setAdapter(adapter);
recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
VideoRecyclerViewAdapter.VideoHolder holder = (VideoRecyclerViewAdapter.VideoHolder) view.getTag();
int position = holder.mPosition;
if (position == mPIPManager.getPlayingPosition()) {
startPlay(position, false);
}
}
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
VideoRecyclerViewAdapter.VideoHolder holder = (VideoRecyclerViewAdapter.VideoHolder) view.getTag();
int position = holder.mPosition;
if (position == mPIPManager.getPlayingPosition()) {
startFloatWindow();
mController.setPlayState(ConstantKeys.CurrentState.STATE_IDLE);
}
}
});
}
private void startFloatWindow() {
mPIPManager.startFloatWindow();
}
@Override
protected void onPause() {
super.onPause();
mPIPManager.pause();
}
@Override
protected void onResume() {
super.onResume();
mPIPManager.resume();
}
@Override
protected void onDestroy() {
super.onDestroy();
mPIPManager.reset();
}
@Override
public void onBackPressed() {
if (mPIPManager.onBackPress()) return;
super.onBackPressed();
}
@Override
public void onItemChildClick(int position) {
startPlay(position, true);
}
/**
* 开始播放
*
* @param position 列表位置
*/
protected void startPlay(int position, boolean isRelease) {
if (mPIPManager.isStartFloatWindow())
mPIPManager.stopFloatWindow();
if (mPIPManager.getPlayingPosition() != -1 && isRelease) {
releaseVideoView();
}
VideoInfoBean videoBean = mVideos.get(position);
mVideoView.setUrl(videoBean.getVideoUrl());
View itemView = mLinearLayoutManager.findViewByPosition(position);
if (itemView == null) return;
//注意：要先设置控制才能去设置控制器的状态。
mVideoView.setController(mController);
mController.setPlayState(mVideoView.getCurrentPlayState());
VideoRecyclerViewAdapter.VideoHolder viewHolder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
//把列表中预置的PrepareView添加到控制器中，注意isPrivate此处只能为true。
mController.addControlComponent(viewHolder.mPrepareView, true);
PlayerUtils.removeViewFormParent(mVideoView);
viewHolder.mPlayerContainer.addView(mVideoView, 0);
mVideoView.start();
mPIPManager.setPlayingPosition(position);
}
private void releaseVideoView() {
mVideoView.release();
if (mVideoView.isFullScreen()) {
mVideoView.stopFullScreen();
}
if (getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mPIPManager.setPlayingPosition(-1);
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/surface/MySurfaceView.java | Java | package com.yc.ycvideoplayer.newPlayer.surface;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.drawable.BitmapDrawable;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.KeyEvent;
import android.view.MotionEvent;
import com.yc.kernel.utils.VideoLogUtils;
import org.yc.ycvideoplayer.R;
public class MySurfaceView extends SurfaceView implements Runnable, SurfaceHolder.Callback {
private final SurfaceHolder mHolder; // 用于控制SurfaceView
private Thread t; // 声明一条线程
private volatile boolean flag; // 线程运行的标识，用于控制线程
private Canvas mCanvas; // 声明一张画布
private Paint p; // 声明一支画笔
float m_circle_r = 10;
public MySurfaceView(Context context) {
super(context);
mHolder = getHolder(); // 获得SurfaceHolder对象
mHolder.addCallback(this); // 为SurfaceView添加状态监听
p = new Paint(); // 创建一个画笔对象
p.setColor(Color.WHITE); // 设置画笔的颜色为白色
setFocusable(true); // 设置焦点
}
/**
* 当SurfaceView创建的时候，调用此函数
*/
@Override
public void surfaceCreated(SurfaceHolder holder) {
// 创建一个线程对象
t = new Thread(this);
// 把线程运行的标识设置成true
flag = true;
// 启动线程
t.start();
}
/**
* 当SurfaceView的视图发生改变的时候，调用此函数
*/
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
/**
* 当SurfaceView销毁的时候，调用此函数
*/
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
// 把线程运行的标识设置成false
flag = false;
mHolder.removeCallback(this);
}
/**
* 当屏幕被触摸时调用
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
return true;
}
/**
* 当用户按键时调用
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
surfaceDestroyed(mHolder);
return super.onKeyDown(keyCode, event);
}
@Override
public void run() {
while (flag) {
try {
synchronized (mHolder) {
// 让线程休息100毫秒
Thread.sleep(100);
// 调用自定义画画方法
Draw();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (mCanvas != null) {
// mHolder.unlockCanvasAndPost(mCanvas);//结束锁定画图，并提交改变。
}
}
}
}
/**
* 自定义一个方法，在画布上画一个圆
*/
protected void Draw() {
// 获得画布对象，开始对画布画画
mCanvas = mHolder.lockCanvas();
if (mCanvas != null) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(Color.BLUE);
paint.setStrokeWidth(10);
paint.setStyle(Style.FILL);
if (m_circle_r >= (getWidth() / 10)) {
m_circle_r = 0;
} else {
m_circle_r++;
}
Bitmap pic = ((BitmapDrawable) getResources().getDrawable(R.drawable.ic_palyer_share)).getBitmap();
mCanvas.drawBitmap(pic, 0, 0, paint);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 8; j++) {
mCanvas.drawCircle(
(getWidth() / 5) * i + (getWidth() / 10),
(getHeight() / 8) * j + (getHeight() / 16),
m_circle_r, paint);
}
}
VideoLogUtils.e("MySurfaceView-----Draw");
System.out.println("MySurfaceView-----Draw");
// 完成画画，把画布显示在屏幕上
mHolder.unlockCanvasAndPost(mCanvas);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
VideoLogUtils.e("MySurfaceView-----onDraw");
System.out.println("MySurfaceView-----onDraw");
}
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
VideoLogUtils.e("MySurfaceView-----draw");
System.out.println("MySurfaceView-----draw");
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/surface/TestSurfaceActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.surface;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.widget.FrameLayout;
import android.widget.RelativeLayout;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import org.yc.ycvideoplayer.R;
public class TestSurfaceActivity extends AppCompatActivity {
private MySurfaceView mSurfaceView;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
FrameLayout fl = (FrameLayout) findViewById(R.id.fl);
mSurfaceView = new MySurfaceView(this);
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT);
fl.addView(mSurfaceView, params);
SurfaceHolder holder = mSurfaceView.getHolder();
//增加surfaceView的监听
holder.addCallback(new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder surfaceHolder) {
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int format, int width, int height) {
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTok1Activity.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.View;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.OrientationHelper;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.pagerlib.recycler.OnPagerListener;
import com.yc.pagerlib.recycler.PagerLayoutManager;
import com.yc.ycvideoplayer.ConstantVideo;
import com.yc.ycvideoplayer.newPlayer.list.OnItemChildClickListener;
import com.yc.ycvideoplayer.newPlayer.list.VideoRecyclerViewAdapter;
import org.yc.ycvideoplayer.R;
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 java.util.ArrayList;
import java.util.List;
/**
* 模仿抖音短视频，使用RecyclerView，实现了预加载功能
*/
public class TikTok1Activity extends AppCompatActivity {
protected List<VideoInfoBean> mVideos = new ArrayList<>();
protected VideoRecyclerViewAdapter mAdapter;
protected RecyclerView mRecyclerView;
protected PagerLayoutManager mLinearLayoutManager;
protected VideoPlayer mVideoView;
protected BasisVideoController mController;
/**
* 当前播放的位置
*/
protected int mCurPos = -1;
/**
* 上次播放的位置，用于页面切回来之后恢复播放
*/
protected int mLastPos = mCurPos;
private static final String KEY_INDEX = "index";
public static void start(Context context, int index) {
Intent i = new Intent(context, TikTok2Activity.class);
i.putExtra(KEY_INDEX, index);
context.startActivity(i);
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recycler_view);
mCurPos = getIntent().getIntExtra(KEY_INDEX, 0);
initView();
initData();
}
protected void initView() {
initVideoView();
mRecyclerView = findViewById(R.id.recyclerView);
mLinearLayoutManager= new PagerLayoutManager(this, OrientationHelper.VERTICAL);
mRecyclerView.setLayoutManager(mLinearLayoutManager);
mAdapter = new VideoRecyclerViewAdapter(mVideos);
mAdapter.setOnItemChildClickListener(new OnItemChildClickListener() {
@Override
public void onItemChildClick(int position) {
startPlay(position);
}
});
mRecyclerView.setAdapter(mAdapter);
mLinearLayoutManager.setOnViewPagerListener(new OnPagerListener() {
@Override
public void onInitComplete() {
System.out.println("OnPagerListener---onInitComplete--"+"初始化完成");
}
@Override
public void onPageRelease(boolean isNext, int position) {
System.out.println("OnPagerListener---onPageRelease--"+position+"-----"+isNext);
}
@Override
public void onPageSelected(int position, boolean isBottom) {
System.out.println("OnPagerListener---onPageSelected--"+position+"-----"+isBottom);
}
});
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(this);
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(this);
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(this.getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mCurPos = -1;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTok1ListAdapter.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import java.util.List;
public class TikTok1ListAdapter extends RecyclerView.Adapter<TikTok1ListAdapter.TikTokListViewHolder> {
public List<VideoInfoBean> data;
private int mId;
public TikTok1ListAdapter(List<VideoInfoBean> data) {
this.data = data;
}
@NonNull
@Override
public TikTokListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_tiktok_list, parent, false);
return new TikTokListViewHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull TikTokListViewHolder holder, int position) {
VideoInfoBean item = data.get(position);
holder.mTitle.setText(item.getTitle());
Glide.with(holder.mThumb.getContext())
.load(item.getCover())
.into(holder.mThumb);
holder.mPosition = position;
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
public void setImpl(int id) {
mId = id;
}
public class TikTokListViewHolder extends RecyclerView.ViewHolder {
public ImageView mThumb;
public TextView mTitle;
public int mPosition;
public TikTokListViewHolder(@NonNull View itemView) {
super(itemView);
mThumb = itemView.findViewById(R.id.iv_thumb);
mTitle = itemView.findViewById(R.id.tv_title);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
TikTok1Activity.start(itemView.getContext(), mPosition);
}
});
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTok1ListFragment.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import java.util.ArrayList;
import java.util.List;
public class TikTok1ListFragment extends Fragment {
private List<VideoInfoBean> data = new ArrayList<>();
private RecyclerView mRecyclerView;
private TikTok1ListAdapter mAdapter;
@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) {
mRecyclerView = view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 2));
mAdapter = new TikTok1ListAdapter(data);
mRecyclerView.setAdapter(mAdapter);
}
protected void initData() {
//模拟请求数据
new Thread(new Runnable() {
@Override
public void run() {
List<VideoInfoBean> tiktokBeans = ConstantVideo.getVideoList();
data.addAll(tiktokBeans);
mRecyclerView.post(new Runnable() {
@Override
public void run() {
mAdapter.notifyDataSetChanged();
}
});
}
}).start();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTok2Activity.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.pagerlib.pager.VerticalViewPager;
import com.yc.videocache.cache.PreloadManager;
import com.yc.videocache.cache.ProxyVideoCacheManager;
import com.yc.video.config.ConstantKeys;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.player.VideoPlayer;
import com.yc.video.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import java.util.ArrayList;
import java.util.List;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* 模仿抖音短视频，使用VerticalViewPager实现，实现了预加载功能
*/
public class TikTok2Activity extends AppCompatActivity {
/**
* 当前播放位置
*/
private int mCurPos;
private List<VideoInfoBean> mVideoList = new ArrayList<>();
private Tiktok2Adapter mTiktok2Adapter;
private VerticalViewPager mViewPager;
private PreloadManager mPreloadManager;
private VideoPlayer mVideoPlayer;
private BasisVideoController mController;
private static final String KEY_INDEX = "index";
public static void start(Context context, int index) {
Intent i = new Intent(context, TikTok2Activity.class);
i.putExtra(KEY_INDEX, index);
context.startActivity(i);
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mVideoPlayer != null) {
mVideoPlayer.release();
}
mPreloadManager.removeAllPreloadTask();
//清除缓存，实际使用可以不需要清除，这里为了方便测试
ProxyVideoCacheManager.clearAllCache(this);
}
@Override
protected void onResume() {
super.onResume();
if (mVideoPlayer != null) {
mVideoPlayer.resume();
}
}
@Override
protected void onPause() {
super.onPause();
if (mVideoPlayer != null) {
mVideoPlayer.pause();
}
}
@Override
public void onBackPressed() {
if (mVideoPlayer == null || !mVideoPlayer.onBackPressed()) {
super.onBackPressed();
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tiktok2);
StateAppBar.translucentStatusBar(this, true);
initFindViewById();
initListener();
initView();
}
private void initFindViewById() {
mViewPager = findViewById(R.id.vvp);
}
private void initListener() {
}
protected void initView() {
initViewPager();
initVideoView();
mPreloadManager = PreloadManager.getInstance(this);
addData(null);
Intent extras = getIntent();
int index = extras.getIntExtra(KEY_INDEX, 0);
mViewPager.setCurrentItem(index);
mViewPager.post(new Runnable() {
@Override
public void run() {
startPlay(index);
}
});
}
private void initVideoView() {
mVideoPlayer = new VideoPlayer(this);
mVideoPlayer.setLooping(true);
//以下只能二选一，看你的需求
mVideoPlayer.setRenderViewFactory(TikTokRenderViewFactory.create());
mController = new BasisVideoController(this);
mVideoPlayer.setController(mController);
}
private void initViewPager() {
mViewPager = findViewById(R.id.vvp);
mViewPager.setOffscreenPageLimit(4);
mTiktok2Adapter = new Tiktok2Adapter(mVideoList);
mViewPager.setAdapter(mTiktok2Adapter);
mViewPager.setOverScrollMode(View.OVER_SCROLL_NEVER);
mViewPager.setOnPageChangeListener(new ViewPager.SimpleOnPageChangeListener() {
private int mCurItem;
/**
* VerticalViewPager是否反向滑动
*/
private boolean mIsReverseScroll;
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
super.onPageScrolled(position, positionOffset, positionOffsetPixels);
if (position == mCurItem) {
return;
}
mIsReverseScroll = position < mCurItem;
}
@Override
public void onPageSelected(int position) {
super.onPageSelected(position);
if (position == mCurPos) return;
startPlay(position);
}
@Override
public void onPageScrollStateChanged(int state) {
super.onPageScrollStateChanged(state);
if (state == VerticalViewPager.SCROLL_STATE_DRAGGING) {
mCurItem = mViewPager.getCurrentItem();
}
if (state == VerticalViewPager.SCROLL_STATE_IDLE) {
mPreloadManager.resumePreload(mCurPos, mIsReverseScroll);
} else {
mPreloadManager.pausePreload(mCurPos, mIsReverseScroll);
}
}
});
// RecyclerView recyclerView = new RecyclerView(this);
// recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
// /**
// * 是否反向滑动
// */
// private boolean mIsReverseScroll;
//
// @Override
// public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
// super.onScrolled(recyclerView, dx, dy);
// if (dy>0){
// //表示下滑
// mIsReverseScroll = false;
// } else {
// //表示上滑
// mIsReverseScroll = true;
// }
// }
//
// @Override
// public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
// super.onScrollStateChanged(recyclerView, newState);
// if (newState == VerticalViewPager.SCROLL_STATE_IDLE) {
// mPreloadManager.resumePreload(mCurPos, mIsReverseScroll);
// } else {
// mPreloadManager.pausePreload(mCurPos, mIsReverseScroll);
// }
// }
// });
}
private void startPlay(int position) {
int count = mViewPager.getChildCount();
for (int i = 0; i < count; i ++) {
View itemView = mViewPager.getChildAt(i);
Tiktok2Adapter.ViewHolder viewHolder = (Tiktok2Adapter.ViewHolder) itemView.getTag();
if (viewHolder.mPosition == position) {
mVideoPlayer.release();
PlayerUtils.removeViewFormParent(mVideoPlayer);
VideoInfoBean tiktokBean = mVideoList.get(position);
String playUrl = mPreloadManager.getPlayUrl(tiktokBean.getVideoUrl());
VideoLogUtils.i("startPlay: " + "position: " + position + " url: " + playUrl);
mVideoPlayer.setUrl(playUrl);
mVideoPlayer.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9);
mController.addControlComponent(viewHolder.mTikTokView, true);
viewHolder.mPlayerContainer.addView(mVideoPlayer, 0);
mVideoPlayer.start();
mCurPos = position;
break;
}
}
}
public void addData(View view) {
mVideoList.addAll(ConstantVideo.getVideoList());
mTiktok2Adapter.notifyDataSetChanged();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTokListAdapter.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import java.util.List;
public class TikTokListAdapter extends RecyclerView.Adapter<TikTokListAdapter.TikTokListViewHolder> {
public List<VideoInfoBean> data;
private int mId;
public TikTokListAdapter(List<VideoInfoBean> data) {
this.data = data;
}
@NonNull
@Override
public TikTokListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_tiktok_list, parent, false);
return new TikTokListViewHolder(itemView);
}
@Override
public void onBindViewHolder(@NonNull TikTokListViewHolder holder, int position) {
VideoInfoBean item = data.get(position);
holder.mTitle.setText(item.getTitle());
Glide.with(holder.mThumb.getContext())
.load(item.getCover())
.into(holder.mThumb);
holder.mPosition = position;
}
@Override
public int getItemCount() {
return data == null ? 0 : data.size();
}
public void setImpl(int id) {
mId = id;
}
public class TikTokListViewHolder extends RecyclerView.ViewHolder {
public ImageView mThumb;
public TextView mTitle;
public int mPosition;
public TikTokListViewHolder(@NonNull View itemView) {
super(itemView);
mThumb = itemView.findViewById(R.id.iv_thumb);
mTitle = itemView.findViewById(R.id.tv_title);
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
TikTok2Activity.start(itemView.getContext(), mPosition);
}
});
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTokListFragment.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import java.util.ArrayList;
import java.util.List;
public class TikTokListFragment extends Fragment {
private List<VideoInfoBean> data = new ArrayList<>();
private RecyclerView mRecyclerView;
private TikTokListAdapter mAdapter;
@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) {
mRecyclerView = view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 2));
mAdapter = new TikTokListAdapter(data);
mRecyclerView.setAdapter(mAdapter);
}
protected void initData() {
//模拟请求数据
new Thread(new Runnable() {
@Override
public void run() {
List<VideoInfoBean> tiktokBeans = ConstantVideo.getVideoList();
data.addAll(tiktokBeans);
mRecyclerView.post(new Runnable() {
@Override
public void run() {
mAdapter.notifyDataSetChanged();
}
});
}
}).start();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTokRenderView.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.graphics.Bitmap;
import android.view.View;
import androidx.annotation.NonNull;
import com.yc.kernel.inter.AbstractVideoPlayer;
import com.yc.video.config.ConstantKeys;
import com.yc.video.surface.InterSurfaceView;
/**
* TikTok专用RenderView，横屏视频默认显示，竖屏视频居中裁剪
* 使用代理模式实现
*/
public class TikTokRenderView implements InterSurfaceView {
private InterSurfaceView mProxyRenderView;
TikTokRenderView(@NonNull InterSurfaceView renderView) {
this.mProxyRenderView = renderView;
}
@Override
public void attachToPlayer(@NonNull AbstractVideoPlayer player) {
mProxyRenderView.attachToPlayer(player);
}
@Override
public void setVideoSize(int videoWidth, int videoHeight) {
if (videoWidth > 0 && videoHeight > 0) {
mProxyRenderView.setVideoSize(videoWidth, videoHeight);
if (videoHeight > videoWidth) {
//竖屏视频，使用居中裁剪
mProxyRenderView.setScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_CENTER_CROP);
} else {
//横屏视频，使用默认模式
mProxyRenderView.setScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_DEFAULT);
}
}
}
@Override
public void setVideoRotation(int degree) {
mProxyRenderView.setVideoRotation(degree);
}
@Override
public void setScaleType(int scaleType) {
// 置空，不要让外部去设置ScaleType
}
@Override
public View getView() {
return mProxyRenderView.getView();
}
@Override
public Bitmap doScreenShot() {
return mProxyRenderView.doScreenShot();
}
@Override
public void release() {
mProxyRenderView.release();
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTokRenderViewFactory.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.content.Context;
import com.yc.video.surface.InterSurfaceView;
import com.yc.video.surface.SurfaceFactory;
import com.yc.video.surface.RenderTextureView;
public class TikTokRenderViewFactory extends SurfaceFactory {
public static TikTokRenderViewFactory create() {
return new TikTokRenderViewFactory();
}
@Override
public InterSurfaceView createRenderView(Context context) {
return new TikTokRenderView(new RenderTextureView(context));
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/TikTokView.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.yc.kernel.utils.VideoLogUtils;
import org.yc.ycvideoplayer.R;
import com.yc.video.bridge.ControlWrapper;
import com.yc.video.config.ConstantKeys;
import com.yc.video.ui.view.InterControlView;
public class TikTokView extends FrameLayout implements InterControlView {
private ImageView thumb;
private ImageView mPlayBtn;
private ControlWrapper mControlWrapper;
private int mScaledTouchSlop;
private int mStartX, mStartY;
public TikTokView(@NonNull Context context) {
super(context);
}
public TikTokView(@NonNull Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
public TikTokView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
{
LayoutInflater.from(getContext()).inflate(R.layout.layout_tiktok_controller, this, true);
thumb = findViewById(R.id.iv_thumb);
mPlayBtn = findViewById(R.id.play_btn);
setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
mControlWrapper.togglePlay();
}
});
mScaledTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
}
/**
* 解决点击和VerticalViewPager滑动冲突问题
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
mStartX = (int) event.getX();
mStartY = (int) event.getY();
return true;
case MotionEvent.ACTION_UP:
int endX = (int) event.getX();
int endY = (int) event.getY();
if (Math.abs(endX - mStartX) < mScaledTouchSlop
&& Math.abs(endY - mStartY) < mScaledTouchSlop) {
performClick();
}
break;
}
return false;
}
@Override
public void attach(@NonNull ControlWrapper controlWrapper) {
mControlWrapper = controlWrapper;
}
@Override
public View getView() {
return this;
}
@Override
public void onVisibilityChanged(boolean isVisible, Animation anim) {
}
@Override
public void onPlayStateChanged(int playState) {
switch (playState) {
case ConstantKeys.CurrentState.STATE_IDLE:
VideoLogUtils.e("STATE_IDLE " + hashCode());
thumb.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PLAYING:
VideoLogUtils.e("STATE_PLAYING " + hashCode());
thumb.setVisibility(GONE);
mPlayBtn.setVisibility(GONE);
break;
case ConstantKeys.CurrentState.STATE_PAUSED:
VideoLogUtils.e("STATE_PAUSED " + hashCode());
thumb.setVisibility(GONE);
mPlayBtn.setVisibility(VISIBLE);
break;
case ConstantKeys.CurrentState.STATE_PREPARED:
VideoLogUtils.e("STATE_PREPARED " + hashCode());
break;
case ConstantKeys.CurrentState.STATE_ERROR:
VideoLogUtils.e("STATE_ERROR " + hashCode());
Toast.makeText(getContext(), R.string.error_message, Toast.LENGTH_SHORT).show();
break;
}
}
@Override
public void onPlayerStateChanged(int playerState) {
}
@Override
public void setProgress(int duration, int position) {
}
@Override
public void onLockStateChanged(boolean isLocked) {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiktok/Tiktok2Adapter.java | Java | package com.yc.ycvideoplayer.newPlayer.tiktok;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.viewpager.widget.PagerAdapter;
import com.bumptech.glide.Glide;
import org.yc.ycvideoplayer.R;
import com.yc.videocache.cache.PreloadManager;
import com.yc.video.config.VideoInfoBean;
import java.util.ArrayList;
import java.util.List;
public class Tiktok2Adapter extends PagerAdapter {
/**
* View缓存池，从ViewPager中移除的item将会存到这里面，用来复用
*/
private List<View> mViewPool = new ArrayList<>();
/**
* 数据源
*/
private List<VideoInfoBean> mVideoBeans;
public Tiktok2Adapter(List<VideoInfoBean> videoBeans) {
this.mVideoBeans = videoBeans;
}
@Override
public int getCount() {
return mVideoBeans == null ? 0 : mVideoBeans.size();
}
@Override
public boolean isViewFromObject(@NonNull View view, @NonNull Object o) {
return view == o;
}
@NonNull
@Override
public Object instantiateItem(@NonNull ViewGroup container, int position) {
Context context = container.getContext();
View view = null;
if (mViewPool.size() > 0) {//取第一个进行复用
view = mViewPool.get(0);
mViewPool.remove(0);
}
ViewHolder viewHolder;
if (view == null) {
view = LayoutInflater.from(context).inflate(R.layout.item_tik_tok, container, false);
viewHolder = new ViewHolder(view);
} else {
viewHolder = (ViewHolder) view.getTag();
}
VideoInfoBean item = mVideoBeans.get(position);
//开始预加载
PreloadManager.getInstance(context).addPreloadTask(item.getVideoUrl(), position);
Glide.with(context)
.load(item.getCover())
.placeholder(android.R.color.white)
.into(viewHolder.mThumb);
viewHolder.mTitle.setText(item.getTitle());
viewHolder.mTitle.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(context, "点击了标题", Toast.LENGTH_SHORT).show();
}
});
viewHolder.mPosition = position;
container.addView(view);
return view;
}
@Override
public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
View itemView = (View) object;
container.removeView(itemView);
VideoInfoBean item = mVideoBeans.get(position);
//取消预加载
PreloadManager.getInstance(container.getContext()).removePreloadTask(item.getVideoUrl());
//保存起来用来复用
mViewPool.add(itemView);
}
/**
* 借鉴ListView item复用方法
*/
public static class ViewHolder {
public int mPosition;
public TextView mTitle;//标题
public ImageView mThumb;//封面图
public TikTokView mTikTokView;
public FrameLayout mPlayerContainer;
ViewHolder(View itemView) {
mTikTokView = itemView.findViewById(R.id.tiktok_View);
mTitle = mTikTokView.findViewById(R.id.tv_title);
mThumb = mTikTokView.findViewById(R.id.iv_thumb);
mPlayerContainer = itemView.findViewById(R.id.container);
itemView.setTag(this);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiny/TestFullActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.tiny;
import android.os.Build;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.player.OnVideoStateListener;
import com.yc.video.player.VideoPlayer;
import com.yc.video.ui.view.BasisVideoController;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestFullActivity extends BaseActivity implements View.OnClickListener {
private VideoPlayer mVideoPlayer;
private Button mBtnTiny1;
private Button mBtnTiny2;
@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();
}
}
@Override
public int getContentView() {
return R.layout.activity_full_video1;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
adaptCutoutAboveAndroidP();
mVideoPlayer = findViewById(R.id.video_player);
mBtnTiny1 = (Button) findViewById(R.id.btn_tiny_1);
mBtnTiny2 = (Button) findViewById(R.id.btn_tiny_2);
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.setScreenScaleType(ConstantKeys.PlayerScreenScaleType.SCREEN_SCALE_16_9);
mVideoPlayer.start();
}
@Override
public void initListener() {
mBtnTiny1.setOnClickListener(this);
mBtnTiny2.setOnClickListener(this);
}
@Override
public void initData() {
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_tiny_1:
mVideoPlayer.startFullScreen();
break;
case R.id.btn_tiny_2:
mVideoPlayer.startTinyScreen();
break;
default:
break;
}
}
private void adaptCutoutAboveAndroidP() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
WindowManager.LayoutParams lp = getWindow().getAttributes();
lp.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
getWindow().setAttributes(lp);
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/newPlayer/tiny/TinyScreenActivity.java | Java | package com.yc.ycvideoplayer.newPlayer.tiny;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.View;
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.ycvideoplayer.ConstantVideo;
import com.yc.ycvideoplayer.newPlayer.list.OnItemChildClickListener;
import com.yc.ycvideoplayer.newPlayer.list.VideoRecyclerViewAdapter;
import org.yc.ycvideoplayer.R;
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.tool.PlayerUtils;
import com.yc.video.ui.view.BasisVideoController;
import java.util.List;
/**
* 小窗播放
*/
public class TinyScreenActivity extends AppCompatActivity implements OnItemChildClickListener {
private BasisVideoController mController;
private List<VideoInfoBean> mVideos;
private LinearLayoutManager mLinearLayoutManager;
private VideoPlayer mVideoPlayer;
private int mCurPos = -1;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.base_recycler_view);
initView();
}
@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();
}
}
protected void initView() {
mVideoPlayer = new VideoPlayer(this);
mVideoPlayer.setOnStateChangeListener(new SimpleStateListener() {
@Override
public void onPlayStateChanged(int playState) {
if (playState == ConstantKeys.CurrentState.STATE_BUFFERING_PLAYING) {
if (mVideoPlayer.isTinyScreen()) {
mVideoPlayer.stopTinyScreen();
releaseVideoView();
}
}
}
});
mController = new BasisVideoController(this);
initRecyclerView();
}
private void initRecyclerView() {
RecyclerView recyclerView = findViewById(R.id.recyclerView);
mLinearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(mLinearLayoutManager);
mVideos = ConstantVideo.getVideoList();
VideoRecyclerViewAdapter adapter = new VideoRecyclerViewAdapter(mVideos);
adapter.setOnItemChildClickListener(this);
recyclerView.setAdapter(adapter);
recyclerView.addOnChildAttachStateChangeListener(new RecyclerView.OnChildAttachStateChangeListener() {
@Override
public void onChildViewAttachedToWindow(@NonNull View view) {
VideoRecyclerViewAdapter.VideoHolder holder = (VideoRecyclerViewAdapter.VideoHolder) view.getTag();
int position = holder.mPosition;
if (position == mCurPos) {
startPlay(position, false);
}
}
@Override
public void onChildViewDetachedFromWindow(@NonNull View view) {
VideoRecyclerViewAdapter.VideoHolder holder = (VideoRecyclerViewAdapter.VideoHolder) view.getTag();
int position = holder.mPosition;
if (position == mCurPos && !mVideoPlayer.isFullScreen()) {
mVideoPlayer.startTinyScreen();
mVideoPlayer.setController(null);
mController.setPlayState(ConstantKeys.CurrentState.STATE_IDLE);
}
}
});
}
@Override
public void onItemChildClick(int position) {
startPlay(position, true);
}
/**
* 开始播放
*
* @param position 列表位置
*/
protected void startPlay(int position, boolean isRelease) {
if (mVideoPlayer.isTinyScreen())
mVideoPlayer.stopTinyScreen();
if (mCurPos != -1 && isRelease) {
releaseVideoView();
}
VideoInfoBean videoBean = mVideos.get(position);
mVideoPlayer.setUrl(videoBean.getVideoUrl());
View itemView = mLinearLayoutManager.findViewByPosition(position);
if (itemView == null) return;
//注意：要先设置控制才能去设置控制器的状态。
mVideoPlayer.setController(mController);
mController.setPlayState(mVideoPlayer.getCurrentPlayState());
VideoRecyclerViewAdapter.VideoHolder viewHolder = (VideoRecyclerViewAdapter.VideoHolder) itemView.getTag();
//把列表中预置的PrepareView添加到控制器中，注意isPrivate此处只能为true。
mController.addControlComponent(viewHolder.mPrepareView, true);
PlayerUtils.removeViewFormParent(mVideoPlayer);
viewHolder.mPlayerContainer.addView(mVideoPlayer, 0);
mVideoPlayer.start();
mCurPos = position;
}
private void releaseVideoView() {
mVideoPlayer.release();
if (mVideoPlayer.isFullScreen()) {
mVideoPlayer.stopFullScreen();
}
if (getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
mCurPos = -1;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/FloatPlayerView.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.content.Context;
import android.graphics.Color;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.FrameLayout;
import com.yc.kernel.utils.VideoLogUtils;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.listener.OnPlayerStatesListener;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import com.yc.videoview.SmallWindowTouch;
/**
* <pre>
* @author yangchong
* blog : https://github.com/yangchong211
* time : 2018/8/29
* desc : 适配了悬浮窗的view
* revise:
* </pre>
*/
public class FloatPlayerView extends FrameLayout {
private OldVideoPlayer mVideoPlayer;
public FloatPlayerView(Context context) {
super(context);
init();
}
public FloatPlayerView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public FloatPlayerView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
private void init() {
LayoutInflater inflater = (LayoutInflater) this.getContext()
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view ;
if (inflater != null) {
view = inflater.inflate(com.yc.video.R.layout.old_view_window_dialog, this);
mVideoPlayer = view.findViewById(com.yc.video.R.id.video_player);
mVideoPlayer.setUp(path,null);
mVideoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
//创建视频控制器
VideoPlayerController controller = new VideoPlayerController(getContext());
controller.setTopVisibility(false);
controller.setLoadingType(ConstantKeys.Loading.LOADING_QQ);
controller.imageView().setBackgroundColor(Color.BLACK);
controller.setOnPlayerStatesListener(new OnPlayerStatesListener() {
@Override
public void onPlayerStates(int states) {
if (states == ConstantKeys.PlayerStatesType.COMPLETED){
VideoPlayerManager.instance().releaseVideoPlayer();
if(mCompletedListener!=null){
mCompletedListener.Completed();
}
}
}
});
//controller.onPlayModeChanged(ConstantKeys.PlayMode.MODE_TINY_WINDOW);
mVideoPlayer.setController(controller);
//mVideoPlayer.enterTinyWindow();
mVideoPlayer.postDelayed(new Runnable() {
@Override
public void run() {
mVideoPlayer.start();
}
},300);
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
VideoLogUtils.d("点击事件"+mVideoPlayer.getCurrentState());
if(mVideoPlayer.isPlaying()){
mVideoPlayer.pause();
}else if(mVideoPlayer.isPaused()){
mVideoPlayer.restart();
}
VideoLogUtils.d("点击事件"+mVideoPlayer.getCurrentState());
}
});
view.setOnTouchListener(new SmallWindowTouch(view,0,0));
}
}
private static String path;
public static void setUrl(String url) {
path = url;
}
public interface CompletedListener{
/**
* 播放完成
*/
void Completed();
}
/**
* 监听视频播放完成事件
*/
private CompletedListener mCompletedListener;
public void setCompletedListener(CompletedListener listener){
this.mCompletedListener = listener;
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/HomeKeyWatcher.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
/**
* 监听Home键按下的Wathcer
*/
public class HomeKeyWatcher {
private Context mContext;
private IntentFilter mFilter;
private OnHomePressedListener mListener;
private HomeReceiver mReceiver;
public interface OnHomePressedListener {
//短按Home键
void onHomePressed();
//长按Home键
//void onHomeLongPressed();
}
public HomeKeyWatcher(Context context) {
mContext = context;
mFilter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
}
/**
* 设置监听
* @param listener
*/
public void setOnHomePressedListener(OnHomePressedListener listener) {
mListener = listener;
mReceiver = new HomeReceiver();
}
/**
* 开始监听，注册广播
*/
public void startWatch() {
if (mReceiver != null) {
mContext.registerReceiver(mReceiver, mFilter);
}
}
/**
* 停止监听，注销广播
*/
public void stopWatch() {
if (mReceiver != null) {
mContext.unregisterReceiver(mReceiver);
}
}
class HomeReceiver extends BroadcastReceiver {
final String SYSTEM_DIALOG_REASON_KEY = "reason";
final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action!=null && action.equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
String reason = intent.getStringExtra(SYSTEM_DIALOG_REASON_KEY);
if (reason != null) {
if (mListener != null) {
if (reason.equals(SYSTEM_DIALOG_REASON_HOME_KEY)) {
// 短按home键
mListener.onHomePressed();
} else if (reason.equals(SYSTEM_DIALOG_REASON_RECENT_APPS)) {
// 长按home键
//mListener.onHomeLongPressed();
}
}
}
}
}
}
} | yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/OldActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import com.yc.ycvideoplayer.newPlayer.list.TestListActivity;
import com.yc.ycvideoplayer.newPlayer.surface.TestSurfaceActivity;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* ================================================
* 作 者：杨充
* 版 本：1.0
* 创建日期：2017/11/18
* 描 述：Main主页面
* 修订历史：
* ================================================
*/
@Deprecated
public class OldActivity extends AppCompatActivity implements View.OnClickListener {
private long exitTime;
private Toolbar mToolbar;
private TextView mTv0;
private TextView mTv1;
private TextView mTv2;
private TextView mTv3;
private TextView mTv4;
private TextView mTv5;
private TextView mTv6;
private TextView mTv7;
private TextView mTv8;
private TextView mTv9;
private TextView mTv10;
private TextView mTv11;
private TextView mTv12;
private TextView mTv13;
private TextView mTv14;
private TextView mTv15;
private TextView mTv16;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_old);
StateAppBar.setStatusBarLightMode(this, Color.WHITE);
initView();
}
@Override
protected void onDestroy() {
super.onDestroy();
}
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) {
return;
}
super.onBackPressed();
}
private void initView() {
mToolbar = (Toolbar) findViewById(R.id.toolbar);
mTv0 = (TextView) findViewById(R.id.tv_0);
mTv1 = (TextView) findViewById(R.id.tv_1);
mTv2 = (TextView) findViewById(R.id.tv_2);
mTv3 = (TextView) findViewById(R.id.tv_3);
mTv4 = (TextView) findViewById(R.id.tv_4);
mTv5 = (TextView) findViewById(R.id.tv_5);
mTv6 = (TextView) findViewById(R.id.tv_6);
mTv7 = (TextView) findViewById(R.id.tv_7);
mTv8 = (TextView) findViewById(R.id.tv_8);
mTv9 = (TextView) findViewById(R.id.tv_9);
mTv10 = (TextView) findViewById(R.id.tv_10);
mTv11 = (TextView) findViewById(R.id.tv_11);
mTv12 = (TextView) findViewById(R.id.tv_12);
mTv13 = (TextView) findViewById(R.id.tv_13);
mTv14 = (TextView) findViewById(R.id.tv_14);
mTv15 = (TextView) findViewById(R.id.tv_15);
mTv16 = (TextView) findViewById(R.id.tv_16);
mTv0.setOnClickListener(this);
mTv1.setOnClickListener(this);
mTv2.setOnClickListener(this);
mTv3.setOnClickListener(this);
mTv4.setOnClickListener(this);
mTv5.setOnClickListener(this);
mTv6.setOnClickListener(this);
mTv7.setOnClickListener(this);
mTv8.setOnClickListener(this);
mTv9.setOnClickListener(this);
mTv10.setOnClickListener(this);
mTv11.setOnClickListener(this);
mTv12.setOnClickListener(this);
mTv13.setOnClickListener(this);
mTv14.setOnClickListener(this);
mTv15.setOnClickListener(this);
mTv16.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.tv_0:
break;
case R.id.tv_1:
startActivity(TestNormalActivity.class);
break;
case R.id.tv_2:
startActivity(TestFullActivity2.class);
break;
case R.id.tv_3:
startActivity(TestTinyActivity.class);
break;
case R.id.tv_4:
startActivity(TestWindowActivity.class);
break;
case R.id.tv_5:
startActivity(TestClarityActivity.class);
break;
case R.id.tv_6:
startActivity(TestFragmentActivity.class);
break;
case R.id.tv_7:
startActivity(TestRecyclerActivity.class);
break;
case R.id.tv_8:
startActivity(TestEightVideoActivity.class);
break;
case R.id.tv_9:
startActivity(TestListActivity.class);
break;
case R.id.tv_10:
break;
case R.id.tv_11:
startActivity(TestWindowActivity.class);
break;
case R.id.tv_12:
startActivity(TestSavePosActivity.class);
break;
case R.id.tv_13:
startActivity(TestSurfaceActivity.class);
break;
case R.id.tv_14:
break;
case R.id.tv_15:
break;
case R.id.tv_16:
break;
default:
break;
}
}
private void startActivity(Class c){
startActivity(new Intent(this,c));
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestClarityActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.view.View;
import android.widget.Button;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.BaseActivity;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.VideoInfoBean;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.ArrayList;
import java.util.List;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestClarityActivity extends BaseActivity implements View.OnClickListener {
private OldVideoPlayer videoPlayer;
private Button mBtnTiny1;
private Button mBtnTiny2;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) return;
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.activity_test_video3;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
videoPlayer = (OldVideoPlayer) findViewById(R.id.nice_video_player);
mBtnTiny1 = (Button) findViewById(R.id.btn_tiny_1);
mBtnTiny2 = (Button) findViewById(R.id.btn_tiny_2);
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
VideoPlayerController controller = new VideoPlayerController(this);
controller.setTitle("Beautiful China...");
controller.setLength(117000);
controller.setClarity(getClarites(), 0);
Glide.with(this)
.load("http://imgsrc.baidu.com/image/c0%3Dshijue%2C0%2C0%2C245%2C40/sign=304dee3ab299a9012f38537575fc600e/91529822720e0cf3f8b77cd50046f21fbe09aa5f.jpg")
.placeholder(R.drawable.image_default)
.into(controller.imageView());
controller.setTopPadding(24);
videoPlayer.continueFromLastPosition(false);
videoPlayer.setController(controller);
}
@Override
public void initListener() {
mBtnTiny1.setText("1. 全屏播放时可以切换清晰度");
mBtnTiny2.setText("2. 全屏播放");
mBtnTiny1.setOnClickListener(this);
mBtnTiny2.setOnClickListener(this);
}
@Override
public void initData() {
}
public List<VideoInfoBean> getClarites() {
List<VideoInfoBean> clarities = new ArrayList<>();
clarities.add(new VideoInfoBean("标题哈哈哈哈","标清", "270P", "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"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","高清", "480P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","超清", "720P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
clarities.add(new VideoInfoBean("标题哈哈哈哈","蓝光", "1080P", "http://play.g3proxy.lecloud.com/vod/v2/MjQ5LzM3LzIwL2xldHYtdXRzLzE0L3Zlcl8wMF8yMi0xMTA3NjQxMzkwLWF2Yy00MTk4MTAtYWFjLTQ4MDAwLTUyNjExMC0zMTU1NTY1Mi00ZmJjYzFkNzA1NWMyNDc4MDc5OTYxODg1N2RjNzEwMi0xNDk4NTU3OTYxNzQ4Lm1wNA==?b=479&mmsid=65565355&tm=1499247143&key=98c7e781f1145aba07cb0d6ec06f6c12&platid=3&splatid=345&playid=0&tss=no&vtype=13&cvid=2026135183914&payff=0&pip=08cc52f8b09acd3eff8bf31688ddeced&format=0&sign=mb&dname=mobile&expect=1&tag=mobile&xformat=super"));
return clarities;
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_tiny_1:
break;
case R.id.btn_tiny_2:
break;
default:
break;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestEightVideoActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.os.Bundle;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.ArrayList;
import java.util.List;
/**
* @author yc
*/
public class TestEightVideoActivity extends BaseActivity {
RecyclerView recyclerView;
private boolean pressedHome;
private HomeKeyWatcher mHomeKeyWatcher;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHomeKeyWatcher = new HomeKeyWatcher(this);
mHomeKeyWatcher.setOnHomePressedListener(new HomeKeyWatcher.OnHomePressedListener() {
@Override
public void onHomePressed() {
pressedHome = true;
}
});
pressedHome = false;
mHomeKeyWatcher.startWatch();
}
@Override
protected void onStop() {
// 在OnStop中是release还是suspend播放器，需要看是不是因为按了Home键
if (pressedHome) {
VideoPlayerManager.instance().suspendVideoPlayer();
} else {
VideoPlayerManager.instance().releaseVideoPlayer();
}
super.onStop();
mHomeKeyWatcher.stopWatch();
}
@Override
protected void onRestart() {
mHomeKeyWatcher.startWatch();
pressedHome = false;
super.onRestart();
VideoPlayerManager.instance().resumeVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) {
return;
}
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.base_recycler_view;
}
@Override
public void initView() {
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setHasFixedSize(true);
VideoAdapter adapter;
List<Video> list = new ArrayList<>();
for (int a = 0; a< ConstantVideo.VideoPlayerList.length ; a++){
Video video = new Video(ConstantVideo.VideoPlayerTitle[a],ConstantVideo.VideoPlayerList[a]);
list.add(video);
}
adapter = new VideoAdapter(this, list);
recyclerView.setAdapter(adapter);
recyclerView.setRecyclerListener(new RecyclerView.RecyclerListener() {
@Override
public void onViewRecycled(RecyclerView.ViewHolder holder) {
OldVideoPlayer VideoPlayer = ((VideoAdapter.VideoViewHolder) holder).mVideoPlayer;
if (VideoPlayer == VideoPlayerManager.instance().getCurrentVideoPlayer()) {
VideoPlayerManager.instance().releaseVideoPlayer();
}
}
});
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestFragment.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.ArrayList;
import java.util.List;
/**
* 如果你需要在播放的时候按下Home键能暂停，回调此Fragment又继续的话，需要继承自CompatHomeKeyFragment
* @author yc
*/
public class TestFragment extends Fragment {
private RecyclerView mRecyclerView;
@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);
init(view);
}
private void init(View view) {
mRecyclerView = (RecyclerView) view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
mRecyclerView.setHasFixedSize(true);
List<Video> list = new ArrayList<>();
for (int a = 0; a< ConstantVideo.VideoPlayerList.length ; a++){
Video video = new Video(ConstantVideo.VideoPlayerTitle[a],ConstantVideo.VideoPlayerList[a]);
list.add(video);
}
VideoAdapter adapter = new VideoAdapter(getActivity(), list);
mRecyclerView.setAdapter(adapter);
mRecyclerView.setRecyclerListener(new RecyclerView.RecyclerListener() {
@Override
public void onViewRecycled(RecyclerView.ViewHolder holder) {
OldVideoPlayer videoPlayer = ((VideoAdapter.VideoViewHolder) holder).mVideoPlayer;
if (videoPlayer == VideoPlayerManager.instance().getCurrentVideoPlayer()) {
VideoPlayerManager.instance().releaseVideoPlayer();
}
}
});
}
@Override
public void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestFragmentActivity.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import com.yc.ycvideoplayer.BaseActivity;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
/**
* @author yc
*/
public class TestFragmentActivity extends BaseActivity {
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) {
return;
}
super.onBackPressed();
}
@Override
public int getContentView() {
return R.layout.activity_test_fragment;
}
@Override
public void initView() {
getSupportFragmentManager()
.beginTransaction()
.add(R.id.container, new TestFragment())
.commit();
}
@Override
public void initListener() {
}
@Override
public void initData() {
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestFullActivity2.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.view.View;
import android.widget.Button;
import com.bumptech.glide.Glide;
import com.yc.ycvideoplayer.BaseActivity;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.config.ConstantKeys;
import com.yc.video.old.listener.OnVideoControlListener;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.controller.VideoPlayerController;
import com.yc.video.old.player.OldVideoPlayer;
import cn.ycbjie.ycstatusbarlib.bar.StateAppBar;
/**
* @author yc
*/
public class TestFullActivity2 extends BaseActivity implements View.OnClickListener {
private OldVideoPlayer videoPlayer;
private Button mBtnTiny1;
private Button mBtnTiny2;
@Override
protected void onStop() {
super.onStop();
VideoPlayerManager.instance().suspendVideoPlayer();
}
@Override
protected void onDestroy() {
super.onDestroy();
VideoPlayerManager.instance().releaseVideoPlayer();
}
@Override
public void onBackPressed() {
if (VideoPlayerManager.instance().onBackPressed()) {
return;
} else {
VideoPlayerManager.instance().releaseVideoPlayer();
}
super.onBackPressed();
}
@Override
protected void onRestart() {
super.onRestart();
VideoPlayerManager.instance().resumeVideoPlayer();
}
@Override
public int getContentView() {
return R.layout.activity_full_video2;
}
@Override
public void initView() {
StateAppBar.translucentStatusBar(this, true);
videoPlayer = (OldVideoPlayer) findViewById(R.id.nice_video_player);
mBtnTiny1 = (Button) findViewById(R.id.btn_tiny_1);
mBtnTiny2 = (Button) findViewById(R.id.btn_tiny_2);
videoPlayer.setPlayerType(ConstantKeys.VideoPlayerType.TYPE_IJK);
videoPlayer.setUp(ConstantVideo.VideoPlayerList[0], null);
VideoPlayerController controller = new VideoPlayerController(this);
controller.setTitle("办公室小野开番外了，居然在办公室开澡堂！老板还点赞？");
controller.setLength(98000);
Glide.with(this)
.load("http://tanzi27niu.cdsb.mobi/wps/wp-content/uploads/2017/05/2017-05-17_17-30-43.jpg")
.placeholder(R.drawable.image_default)
.into(controller.imageView());
//设置中间播放按钮是否显示
controller.setTopPadding(24.0f);
controller.setTopVisibility(true);
controller.setOnVideoControlListener(new OnVideoControlListener() {
@Override
public void onVideoControlClick(int type) {
switch (type){
case ConstantKeys.VideoControl.DOWNLOAD:
//BaseToast.showRoundRectToast("下载");
break;
case ConstantKeys.VideoControl.SHARE:
//BaseToast.showRoundRectToast("分享");
break;
case ConstantKeys.VideoControl.MENU:
//BaseToast.showRoundRectToast("更多");
break;
case ConstantKeys.VideoControl.AUDIO:
//BaseToast.showRoundRectToast("下载");
break;
default:
break;
}
}
});
videoPlayer.setController(controller);
videoPlayer.continueFromLastPosition(false);
videoPlayer.postDelayed(new Runnable() {
@Override
public void run() {
videoPlayer.start();
}
},500);
}
@Override
public void initListener() {
mBtnTiny1.setOnClickListener(this);
mBtnTiny2.setOnClickListener(this);
}
@Override
public void initData() {
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_tiny_1:
if (videoPlayer.isIdle()) {
videoPlayer.start();
}
videoPlayer.enterVerticalScreenScreen();
break;
case R.id.btn_tiny_2:
if (videoPlayer.isIdle()) {
videoPlayer.start();
}
videoPlayer.enterFullScreen();
break;
default:
break;
}
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Demo/src/main/java/com/yc/ycvideoplayer/oldPlayer/TestListFragment.java | Java | package com.yc.ycvideoplayer.oldPlayer;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.yc.ycvideoplayer.ConstantVideo;
import org.yc.ycvideoplayer.R;
import com.yc.video.old.other.VideoPlayerManager;
import com.yc.video.old.player.OldVideoPlayer;
import java.util.ArrayList;
import java.util.List;
/**
* 如果你需要在播放的时候按下Home键能暂停，回调此Fragment又继续的话，需要继承自CompatHomeKeyFragment
*/
public class TestListFragment extends Fragment {
RecyclerView mRecyclerView;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
View view = inflater.inflate(getContentView(),container,false);
initView(view);
return view;
}
public int getContentView() {
return R.layout.base_recycler_view;
}
public void initView(View view) {
mRecyclerView = view.findViewById(R.id.recyclerView);
mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
mRecyclerView.setHasFixedSize(true);
List<Video> list = new ArrayList<>();
for (int a = 0; a< ConstantVideo.VideoPlayerList.length ; a++){
Video video = new Video(ConstantVideo.VideoPlayerTitle[a],ConstantVideo.VideoPlayerList[a]);
list.add(video);
}
VideoAdapter adapter = new VideoAdapter(getActivity(), list);
mRecyclerView.setAdapter(adapter);
mRecyclerView.setRecyclerListener(new RecyclerView.RecyclerListener() {
@Override
public void onViewRecycled(RecyclerView.ViewHolder holder) {
OldVideoPlayer niceVideoPlayer = ((VideoAdapter.VideoViewHolder) holder).mVideoPlayer;
if (niceVideoPlayer == VideoPlayerManager.instance().getCurrentVideoPlayer()) {
VideoPlayerManager.instance().releaseVideoPlayer();
}
}
});
}
}
| yangchong211/YCVideoPlayer | 2,245 | 🔥🔥🔥 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer原生MediaPlayer可以自由切换内核；该播放器整体架构：播放器内核(自由切换) + 视频播放器 + 边播边缓存 + 高度定制播放器UI视图层。支持视频简单播放，列表播放，仿抖音滑动播放，自动切换播放，使用案例丰富，拓展性强。 | Java | yangchong211 | 杨充 | Tencent |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.