推荐页剧集添加指定看剧集数

video/app/src/main/AndroidManifest.xml

@@ -188,7 +188,7 @@
             android:screenOrientation="portrait" />
 
         <activity
-            android:name=".video.tx.NewTxVideoActivity"
+            android:name=".video.tx.newrecommend.NewTxVideoActivity"
             android:exported="false"
             android:hardwareAccelerated="true"
             android:screenOrientation="portrait" />

video/app/src/main/java/com/mints/helivideo/manager/LocalVedioManager.kt

@@ -11,11 +11,10 @@ import com.mints.helivideo.ad.express.ExpressManager
 import com.mints.library.utils.json.JsonUtil
 import com.mints.helivideo.common.Constant
 import com.mints.helivideo.mvp.model.VedioBean
-import com.mints.helivideo.ui.activitys.RecommendActivity
 import com.mints.helivideo.utils.AppPreferencesManager
 import com.mints.helivideo.utils.ToastUtil
 import com.mints.helivideo.video.csj.DramaApiDetailActivity
-import com.mints.helivideo.video.tx.NewTxVideoActivity
+import com.mints.helivideo.video.tx.newrecommend.NewTxVideoActivity
 import com.mints.helivideo.video.tx.TxVideoActivity
 
 /**

video/app/src/main/java/com/mints/helivideo/mvp/model/IndexList.java

@@ -34,13 +34,21 @@ public class IndexList implements Serializable {
         this.list = list;
     }
 
-
     public class VedioEpisodeBean implements Serializable {
         private String vedioUrl;
         private int vedioIndex;
         private boolean lock;
         private String title;
         private int vedioId;
+        private String dos;
+
+        public String getDos() {
+            return dos;
+        }
+
+        public void setDos(String dos) {
+            this.dos = dos;
+        }
 
         public String getVedioUrl() {
             return vedioUrl;

video/app/src/main/java/com/mints/helivideo/mvp/model/Vedio3dos.kt

+package com.mints.helivideo.mvp.model
+
+const val VEDIO3DOS_AD = "ad"
+const val VEDIO3DOS_FREE = "free"
+const val VEDIO3DOS_PAY = "pay"
+
+data class Vedio3dos(
+    val list: List<String>,
+    val num: Int
+)
\ No newline at end of file

video/app/src/main/java/com/mints/helivideo/mvp/model/VideoMultiItemEntity.kt

@@ -25,3 +25,10 @@ data class VideoMultiItemEntity3(
     var videos: List<VedioBean>?,
     var adView: FrameLayout?
 ) : MultiItemEntity, java.io.Serializable
+
+data class VideoMultiItemEntity4(
+    override var itemType: Int,
+    var video: IndexList.VedioEpisodeBean?,
+    var videoModel: VideoModel?,
+    var type: String?
+) : MultiItemEntity, java.io.Serializable
\ No newline at end of file

video/app/src/main/java/com/mints/helivideo/mvp/presenters/VideoPresenter.kt

@@ -54,6 +54,44 @@ class VideoPresenter : BasePresenter<VideoView>() {
                 })
     }
 
+    fun getIndexList2(thirdId: String, csj: Boolean = false) {
+        val vo = HashMap<String, Any>()
+        vo["vedioId"] = thirdId
+        AppHttpManager.getInstance(loanApplication)
+            .call(loanService.getIndexList2(vo),
+                object : BaseSubscriber<BaseResponse<IndexList>>() {
+                    override fun onCompleted() {
+                        if (isLinkView) return
+                        view.hideLoading()
+                    }
+
+                    override fun onNext(baseResponse: BaseResponse<IndexList>) {
+                        if (isLinkView) return
+
+                        view.hideLoading()
+                        val code = baseResponse.status
+                        val message = baseResponse.message
+
+                        when (code) {
+                            200 -> view.getIndexListSuc(baseResponse.data)
+                            else -> {
+                                view.getIndexListFail()
+                                view.showToast(message)
+                            }
+                        }
+                    }
+
+                    override fun onError(e: Throwable?) {
+                        if (isLinkView) return
+                        view.hideLoading()
+                        view.showToast(e?.message)
+
+                        view.getIndexListFail()
+                    }
+
+                })
+    }
+
 
     fun collect(videoId: String) {
         val vo = HashMap<String, Any>()

video/app/src/main/java/com/mints/helivideo/net/LoanService.java

@@ -206,6 +206,14 @@ public interface LoanService {
     @POST("api/vedio/getIndexList")
     Observable<BaseResponse<IndexList>> getIndexList(@Body Map<String, Object> vo);
 
+    /**
+     * 优选剧 剧情列表
+     *
+     * @return
+     */
+    @POST("api/vedio/getIndexList/vedio3")
+    Observable<BaseResponse<IndexList>> getIndexList2(@Body Map<String, Object> vo);
+
     /**
      * 播放链接
      *

video/app/src/main/java/com/mints/helivideo/ui/activitys/RecommendActivity.kt

@@ -13,9 +13,7 @@ import com.mints.helivideo.R
 import com.mints.helivideo.common.Constant
 import com.mints.helivideo.mvp.model.RecommendBean
 import com.mints.helivideo.ui.activitys.base.BaseActivity
-import com.mints.helivideo.utils.LogUtil
-import com.mints.helivideo.video.tx.NewTxVideoActivity
-import com.mints.helivideo.video.tx.TXVideoBaseView
+import com.mints.helivideo.video.tx.newrecommend.NewTxVideoActivity
 import com.mints.helivideo.video.tx.TXVodPlayerWrapper
 import com.mints.helivideo.video.tx.VideoModel
 import com.mints.library.utils.json.JsonUtil

video/app/src/main/java/com/mints/helivideo/ui/widgets/NewVideoEpisodeDialog.kt

+package com.mints.helivideo.ui.widgets
+
+import android.app.Dialog
+import android.content.Context
+import android.view.*
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.core.content.ContextCompat
+import androidx.viewpager2.widget.ViewPager2
+import com.google.android.material.tabs.TabLayout
+import com.google.android.material.tabs.TabLayoutMediator
+import com.mints.helivideo.R
+import com.mints.helivideo.mvp.model.EpisodeBean
+import com.mints.helivideo.mvp.model.VEDIO3DOS_FREE
+import com.mints.helivideo.mvp.model.VedioBean
+import com.mints.helivideo.mvp.model.VideoMultiItemEntity4
+import com.mints.helivideo.ui.adapter.VideoEpisodeAdapter
+import com.mints.helivideo.utils.CommonUtils
+
+/**
+ *  @author Assen
+ *  @date 2023/7/5
+ *  @desc
+ */
+class NewVideoEpisodeDialog(
+    context: Context,
+    val vedioBean: VedioBean?,
+    val data: List<VideoMultiItemEntity4>
+) :
+    Dialog(context, R.style.dialog) {
+
+    private var mRealSeeIndex = 0
+
+    private val lp: WindowManager.LayoutParams
+
+    private val vp2: ViewPager2
+    private val tab: TabLayout
+    private val ivClose: ImageView
+
+    private val mData = mutableListOf<EpisodeBean>()
+    private var adapter: VideoEpisodeAdapter? = null
+
+    init {
+        setContentView(R.layout.dialog_video_episode)
+        // 设置window属性
+        lp = window!!.attributes
+        lp.gravity = Gravity.BOTTOM
+        lp.width = WindowManager.LayoutParams.MATCH_PARENT
+        lp.height = WindowManager.LayoutParams.WRAP_CONTENT
+        lp.windowAnimations = R.style.DialogAnimBottom
+        //		lp.dimAmount = 0; // 去背景遮盖
+        // lp.alpha = 1.0f;//透明效果
+        window!!.attributes = lp
+
+        // 设置外部不可关闭
+        setCancelable(true)
+        setCanceledOnTouchOutside(true)
+        setOnKeyListener { _, i, _ ->
+            i == KeyEvent.KEYCODE_BACK
+        }
+
+        vp2 = findViewById(R.id.vp2_episode)
+        tab = findViewById(R.id.tab_episode)
+        ivClose = findViewById(R.id.close_iv)
+        ivClose.setOnClickListener { dismiss() }
+
+        findViewById<TextView>(R.id.title_tv).text = vedioBean?.title
+        findViewById<TextView>(R.id.label_tv).text =
+            if (vedioBean?.completeStatus == 0) "已完结" else "更新中"
+
+        initVp()
+    }
+
+    private fun initVp() {
+        if (vedioBean == null) return
+        for (i in 0 until vedioBean.vedioTotal) {
+            if (data[i].type == VEDIO3DOS_FREE) {
+                var playing = false
+                if (vedioBean.seeIndex == i) {
+                    playing = true
+                }
+                mData.add(EpisodeBean(false, playing, "" + (i + 1)))
+            } else {
+                mData.add(EpisodeBean(lock = true, playing = false, title = "" + (i + 1)))
+            }
+        }
+        val subList = CommonUtils.getSubList(30, mData)
+        adapter = VideoEpisodeAdapter()
+        adapter?.setNewInstance(subList)
+        vp2.adapter = adapter
+        TabLayoutMediator(tab, vp2) { tab, position ->
+            // 初始化Tab
+            tab.id = position
+            tab.customView =
+                getTabView(
+                    subList[position][0].title + "-"
+                            + subList[position][subList[position].size - 1].title,
+                    position
+                )
+        }.attach()
+        tab.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
+            override fun onTabSelected(tab: TabLayout.Tab?) {
+                updateTab(tab, true)
+            }
+
+            override fun onTabUnselected(tab: TabLayout.Tab?) {
+                updateTab(tab, false)
+            }
+
+            override fun onTabReselected(tab: TabLayout.Tab?) {
+            }
+        })
+
+        if (mRealSeeIndex == 0) {
+            tab.getTabAt(vedioBean.seeIndex / 30)?.select()
+        } else {
+            tab.getTabAt(mRealSeeIndex / 30)?.select()
+        }
+    }
+
+
+    private fun getTabView(text: String, position: Int): View {
+        val view = LayoutInflater.from(context).inflate(R.layout.item_epsiode_tab, null)
+        val viewText = view.findViewById<TextView>(R.id.item_tv)
+        viewText.text = text
+        return view
+    }
+
+    private fun updateTab(tab: TabLayout.Tab?, isSelected: Boolean) {
+        tab?.customView?.let {
+            val text = it.findViewById<TextView>(R.id.item_tv)
+            if (isSelected) {
+                text.setTextColor(ContextCompat.getColor(context, R.color.red))
+            } else {
+                text.setTextColor(ContextCompat.getColor(context, R.color.black))
+            }
+        }
+    }
+
+    fun changeLockStatus(unlockIndex: Int) {
+        for (i in 0 until mData.size) {
+            mData[i].lock = i > unlockIndex
+        }
+        adapter?.notifyDataSetChanged()
+    }
+
+    fun setCurrentIndex(position: Int) {
+        mRealSeeIndex = position
+        for (mDatum in mData) {
+            mDatum.playing = false
+        }
+        if (mData.size > position) {
+            mData[position].playing = true
+            adapter?.notifyDataSetChanged()
+        }
+
+    }
+
+    private var mOnEpisodeClickListener: VideoEpisodeAdapter.OnEpisodeClickListener? = null
+
+    fun setOnEpisodeClickListener(onEpisodeClickListener: VideoEpisodeAdapter.OnEpisodeClickListener) {
+        mOnEpisodeClickListener = onEpisodeClickListener
+        adapter?.setOnEpisodeClickListener(mOnEpisodeClickListener)
+    }
+
+}
\ No newline at end of file

video/app/src/main/java/com/mints/helivideo/video/tx/newrecommend/NewSuperShortVideoView.java

+package com.mints.helivideo.video.tx.newrecommend;
+
+import static com.mints.helivideo.mvp.model.Vedio3dosKt.VEDIO3DOS_FREE;
+import static com.mints.helivideo.mvp.model.VideoMultiItemEntityKt.MULTI_ITEM_1;
+import static com.mints.helivideo.mvp.model.VideoMultiItemEntityKt.MULTI_ITEM_2;
+import static com.mints.helivideo.mvp.model.VideoMultiItemEntityKt.MULTI_ITEM_3;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.PagerSnapHelper;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.mints.helivideo.R;
+import com.mints.helivideo.mvp.model.VedioBean;
+import com.mints.helivideo.mvp.model.VideoMultiItemEntity4;
+import com.mints.helivideo.video.tx.PlayerManager;
+import com.mints.helivideo.video.tx.TXVideoBaseView;
+import com.mints.helivideo.video.tx.TXVodPlayerWrapper;
+import com.mints.helivideo.video.tx.VideoModel;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+public class NewSuperShortVideoView extends RelativeLayout {
+
+    private static final String TAG = "NewSuperShortVideoView";
+    private static final int MAX_PLAYER_COUNT_ON_PASS = 3;
+
+    private RecyclerView mRecyclerView;
+    private NewTxVideoAdapter mAdapter;
+    private LinearLayoutManager mLayoutManager;
+    private PagerSnapHelper mSnapHelper;
+    private int mLastPositionInIDLE = -1;
+    private TXVideoBaseView mBaseItemView;
+    private boolean mIsOnDestroy;
+    private PlayerManager mPlayerManager;
+
+    private int mCurrentPosition = 0;
+
+    public NewSuperShortVideoView(Context context) {
+        this(context, null);
+    }
+
+    public NewSuperShortVideoView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public NewSuperShortVideoView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context);
+    }
+
+    public void loadData(VedioBean vedioBean, List<VideoMultiItemEntity4> list, int currentPosition) {
+        mLastPositionInIDLE = -1;
+        this.mCurrentPosition = currentPosition;
+        mAdapter.setVedioBean(vedioBean);
+        mAdapter.setNewInstance(list);
+
+        onItemClick(mCurrentPosition);
+    }
+
+    public void updateData(int currentPosition) {
+        this.mCurrentPosition = currentPosition;
+
+        VideoMultiItemEntity4 videoMultiItemEntity4 = getData().get(currentPosition);
+        videoMultiItemEntity4.setItemType(MULTI_ITEM_1);
+        videoMultiItemEntity4.setType(VEDIO3DOS_FREE);
+        mAdapter.setData(currentPosition, videoMultiItemEntity4);
+
+        onItemClick(mCurrentPosition);
+    }
+
+    public void init(Context context) {
+        View mRootView = LayoutInflater.from(context).inflate(R.layout.super_short_video_view, null);
+        addView(mRootView);
+        mPlayerManager = new PlayerManager(getContext());
+        mRecyclerView = mRootView.findViewById(R.id.rv_super_short_video);
+        mSnapHelper = new PagerSnapHelper();
+        mSnapHelper.attachToRecyclerView(mRecyclerView);
+        mAdapter = new NewTxVideoAdapter();
+        mAdapter.setNewInstance(new ArrayList<>());
+        mAdapter.setOnVideoEndListener(() -> onItemClick(mCurrentPosition + 1, true));
+        mLayoutManager = new LinearLayoutManager(getContext(), LinearLayoutManager.VERTICAL, false) {
+            @Override
+            protected int getExtraLayoutSpace(RecyclerView.State state) {
+                return 300;
+            }
+        };
+        mRecyclerView.setLayoutManager(mLayoutManager);
+        mRecyclerView.setItemViewCacheSize(6);
+        mRecyclerView.setHasFixedSize(true);
+        mRecyclerView.setDrawingCacheEnabled(true);
+        mRecyclerView.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_LOW);
+        mRecyclerView.setAdapter(mAdapter);
+        addListener();
+    }
+
+    private void addListener() {
+        mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
+            @Override
+            public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
+                if (!recyclerView.canScrollVertically(1) || !recyclerView.canScrollVertically(-1)) {
+                    onScrollStateChanged(recyclerView, RecyclerView.SCROLL_STATE_IDLE);
+                }
+            }
+
+            @Override
+            public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
+                switch (newState) {
+                    case RecyclerView.SCROLL_STATE_IDLE://停止滚动
+
+                        View view = mSnapHelper.findSnapView(mLayoutManager);
+                        int position = recyclerView.getChildAdapterPosition(view);
+                        if (position == mCurrentPosition || position == RecyclerView.NO_POSITION)
+                            return;
+                        Log.i(TAG, "[SCROLL_STATE_IDLE] mLastPositionInIDLE " + mLastPositionInIDLE + " position " + position);
+
+                        mCurrentPosition = position;
+                        onPageSelectedMethod(position);
+
+                        if (isLuckPosition(position)) {
+                            mAdapter.notifyItemChanged(position);
+                        }
+                        break;
+                    case RecyclerView.SCROLL_STATE_DRAGGING://拖动
+                        break;
+                    case RecyclerView.SCROLL_STATE_SETTLING://惯性滑动
+                        break;
+                }
+            }
+        });
+    }
+
+    private void onPageSelectedMethod(int position) {
+        if (mOnPageChangeListener != null) mOnPageChangeListener.onPageChange(position);
+
+        if (position >= getData().size() || getData().get(position).getItemType() != MULTI_ITEM_1)
+            return;
+
+        if (position == getData().size()) {
+            if (mBaseItemView != null) {
+                mLastPositionInIDLE = -1;
+                mBaseItemView.stopForPlaying();
+            }
+            return;
+        }
+
+        if (mLastPositionInIDLE != position) {
+            View view = mSnapHelper.findSnapView(mLayoutManager);
+            if (view == null) {
+                return;
+            }
+            mBaseItemView = view.findViewById(R.id.baseItemView);
+            Log.i(TAG, "onPageSelected " + position);
+            List<VideoModel> tempUrlList = initUrlList(position, MAX_PLAYER_COUNT_ON_PASS);
+            mPlayerManager.updateManager(tempUrlList);
+            TXVodPlayerWrapper txVodPlayerWrapper = mPlayerManager.getPlayer(getData().get(position).getVideoModel());
+            if (txVodPlayerWrapper != null && mBaseItemView != null) {
+                Log.i(TAG, "txVodPlayerWrapper " + txVodPlayerWrapper + "url-- " + getData().get(position).getVideoModel().videoURL);
+                Log.i(TAG, "txVodPlayerWrapper " + txVodPlayerWrapper);
+                mBaseItemView.setTXVodPlayer(txVodPlayerWrapper);
+            }
+            mLastPositionInIDLE = position;
+        }
+        if (mBaseItemView != null && !mIsOnDestroy) {
+            mBaseItemView.startPlay();
+        }
+    }
+
+    /**
+     * 初始化向PlayManager传递的urlList
+     *
+     * @param startIndex 开始的索引
+     * @param maxCount   传递的urlList的数目
+     * @return
+     */
+    private List<VideoModel> initUrlList(int startIndex, int maxCount) {
+        List<VideoModel> videoModels = new ArrayList<>();
+        for (VideoMultiItemEntity4 videoMultiItemEntity : getData()) {
+            videoModels.add(videoMultiItemEntity.getVideoModel());
+        }
+        int i = startIndex - 1;
+        if (i + maxCount > videoModels.size()) {
+            i = videoModels.size() - maxCount;
+        }
+        if (i < 0) {
+            i = 0;
+        }
+        int addedCount = 0;
+        List<VideoModel> cacheList = new ArrayList<>();
+        while (i < videoModels.size() && addedCount < maxCount) {
+            cacheList.add(videoModels.get(i));
+            addedCount++;
+            i++;
+        }
+        return cacheList;
+    }
+
+    public void resume() {
+        if (mBaseItemView != null && !isLuckPosition(mCurrentPosition) && !isAdPosition(mCurrentPosition)) {
+            mBaseItemView.startPlay();
+        }
+    }
+
+    public void pause() {
+        if (mBaseItemView != null) {
+            mBaseItemView.pausePlayer();
+        }
+    }
+
+    public void releasePlayer() {
+        if (mBaseItemView != null) {
+            mBaseItemView.stopPlayer();
+        }
+        mPlayerManager.releasePlayer();
+    }
+
+    public void onItemClick(final int position) {
+        onItemClick(position, false);
+    }
+
+    public void onItemClick(final int position, boolean isVideoEnd) {
+        if (getData() == null || position >= getData().size()) return;
+
+        if (isVideoEnd) {
+            changeLayoutPosition(position);
+            // 执行 onScrollListener
+            mRecyclerView.smoothScrollToPosition(position);
+        } else {
+            mRecyclerView.scrollToPosition(position);
+            mRecyclerView.post(() -> {
+                Log.i(TAG, "onItemClick");
+                mCurrentPosition = position;
+
+                onPageSelectedMethod(position);
+            });
+        }
+    }
+
+    private void changeLayoutPosition(int position) {
+        try {
+            Class<LinearLayoutManager> lm = LinearLayoutManager.class;
+            Field mPendingScrollPosition = lm.getDeclaredField("mPendingScrollPosition");
+            mPendingScrollPosition.setAccessible(true);
+            mPendingScrollPosition.set(mLayoutManager, position);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public List<VideoMultiItemEntity4> getData() {
+        return mAdapter.getData();
+    }
+
+    public int getRealSeeIndex() {
+        if (getData() != null && getData().size() > 0) {
+            VideoMultiItemEntity4 videoMultiItemEntity = getData().get(mCurrentPosition);
+            if (videoMultiItemEntity.getItemType() == MULTI_ITEM_1) {
+                return videoMultiItemEntity.getVideo().getVedioIndex() - 1;
+            }
+        }
+        return mCurrentPosition;
+    }
+
+    public int getCurrentPosition() {
+        return mCurrentPosition;
+    }
+
+    public void setOnCustomChildClickListener(NewTxVideoAdapter.OnCustomChildClickListener onCustomChildClickListener) {
+        mAdapter.setOnCustomChildClickListener(onCustomChildClickListener);
+    }
+
+    public void onDestroy() {
+        mIsOnDestroy = true;
+    }
+
+    public interface OnPageChangeListener {
+        void onPageChange(int position);
+    }
+
+    private OnPageChangeListener mOnPageChangeListener;
+
+    public void setOnPageChangeListener(OnPageChangeListener onPageChangeListener) {
+        this.mOnPageChangeListener = onPageChangeListener;
+    }
+
+    public boolean isAdPosition(int position) {
+        if (getData() != null && getData().size() > 0 && position < getData().size()) {
+            return getData().get(position).getItemType() == MULTI_ITEM_3;
+        }
+        return false;
+    }
+
+    public boolean isLuckPosition(int position) {
+        if (getData() != null && getData().size() > 0 && position < getData().size()) {
+            return getData().get(position).getItemType() == MULTI_ITEM_2;
+        }
+        return false;
+    }
+}

video/app/src/main/java/com/mints/helivideo/video/tx/NewTxVideoActivity.kt → video/app/src/main/java/com/mints/helivideo/video/tx/newrecommend/NewTxVideoActivity.kt

-package com.mints.helivideo.video.tx
+package com.mints.helivideo.video.tx.newrecommend
 
-import android.app.Dialog
 import android.os.Bundle
 import android.view.View
+import androidx.core.content.ContextCompat
 import com.google.gson.Gson
 import com.mints.helivideo.R
 import com.mints.helivideo.ad.AdManager
@@ -16,14 +16,15 @@ import com.mints.helivideo.mvp.model.*
 import com.mints.helivideo.mvp.model.IndexList.VedioEpisodeBean
 import com.mints.helivideo.mvp.presenters.VideoPresenter
 import com.mints.helivideo.mvp.views.VideoView
+import com.mints.helivideo.ui.activitys.NineActivity
 import com.mints.helivideo.ui.activitys.VipActivity
 import com.mints.helivideo.ui.activitys.base.BaseActivity
 import com.mints.helivideo.ui.adapter.VideoEpisodeAdapter
-import com.mints.helivideo.ui.widgets.DialogListener
-import com.mints.helivideo.ui.widgets.VideoEpisodeDialog
+import com.mints.helivideo.ui.widgets.NewVideoEpisodeDialog
 import com.mints.helivideo.utils.AppPreferencesManager
 import com.mints.helivideo.utils.SpanUtils
-import com.mints.helivideo.video.tx.adapter.TxVideoAdapter
+import com.mints.helivideo.video.tx.VideoModel
+import com.mints.library.utils.GlideUtils
 import com.mints.library.utils.nodoubleclick.AntiShake
 import kotlinx.android.synthetic.main.activity_new_tx_video.*
 
@@ -31,45 +32,35 @@ import kotlinx.android.synthetic.main.activity_new_tx_video.*
  * 推荐剧集二级页
  */
 class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
-    VideoEpisodeAdapter.OnEpisodeClickListener, TxVideoAdapter.OnCustomChildClickListener {
+    VideoEpisodeAdapter.OnEpisodeClickListener, NewTxVideoAdapter.OnCustomChildClickListener {
 
     private var mVipFlag = UserManager.getInstance().vipFlag
 
-    private var mShowData = arrayListOf<VedioEpisodeBean>()
-
     private var mAllData = arrayListOf<VedioEpisodeBean>()
 
-    private var dialog: VideoEpisodeDialog? = null
+    private var dialog: NewVideoEpisodeDialog? = null
 
     private val videoPresenter by lazy { VideoPresenter() }
 
     private var mVedioBean: VedioBean? = null
     private var indexBean: IndexList? = null
-    private var tipList: ArrayList<String>? = null
     private var orderTagsList: ArrayList<String>? = null
 
-    private var isPlayNext = false
     private var playIndex = 1
 
     override fun getContentViewLayoutID() = R.layout.activity_new_tx_video
 
     override fun initViewsAndEvents() {
         videoPresenter.attachView(this)
-        mVedioBean?.let { videoPresenter.getIndexList("" + it.vedioId) }
+        mVedioBean?.let { videoPresenter.getIndexList2("" + it.vedioId) }
         initView()
     }
 
     override fun getBundleExtras(extras: Bundle?) {
         val json = extras?.getString(Constant.VEDIO_BEAN)
-        isPlayNext = extras?.getBoolean(Constant.VEDIO_NEXT, false) == true
         mVedioBean = Gson().fromJson(json, VedioBean::class.java)
         mVedioBean?.isRecommendVedio = true
         orderTagsList = mVedioBean?.orderTags
-        if (isPlayNext) {
-            mVedioBean?.let {
-                it.recommendIndex = it.recommendIndex + 1
-            }
-        }
         super.getBundleExtras(extras)
     }
 
@@ -77,27 +68,26 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
 
     override fun onResume() {
         super.onResume()
-        super_short_video_view.resume()
+        new_super_short_video_view.resume()
 
         videoPresenter.showTurn()
 
         if (mVipFlag != UserManager.getInstance().vipFlag && UserManager.getInstance().vipFlag) {
             // 重置状态
-            isPlayNext = false
-            playIndex = super_short_video_view.currentPosition
-            mVedioBean?.let { videoPresenter.getIndexList("" + it.vedioId) }
+            playIndex = new_super_short_video_view.currentPosition
+            mVedioBean?.let { videoPresenter.getIndexList2("" + it.vedioId) }
         }
     }
 
     override fun onPause() {
         super.onPause()
-        super_short_video_view.pause()
+        new_super_short_video_view.pause()
     }
 
     override fun onDestroy() {
-        super_short_video_view.onDestroy()
+        new_super_short_video_view.onDestroy()
         super.onDestroy()
-        super_short_video_view.releasePlayer()
+        new_super_short_video_view.releasePlayer()
 
         ExpressManager.instance.destroy()
         videoPresenter.detachView()
@@ -114,18 +104,21 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
             if (mVedioBean?.completeStatus == 0) "已完结" else "更新中"
         )
 
-        super_short_video_view.setOnCustomChildClickListener(this)
-        super_short_video_view.setOnPageChangeListener {
-            if (super_short_video_view.isAdPosition(it) || super_short_video_view.isLuckPosition(it)) {
-                fm_bottom.visibility = View.GONE
-                super_short_video_view.pause()
+        new_super_short_video_view.setOnCustomChildClickListener(this)
+        new_super_short_video_view.setOnPageChangeListener {
+            if (new_super_short_video_view.isAdPosition(it) || new_super_short_video_view.isLuckPosition(
+                    it
+                )
+            ) {
+//                fm_bottom.visibility = View.GONE
+                new_super_short_video_view.pause()
                 return@setOnPageChangeListener
             }
 
-            fm_bottom.visibility = View.VISIBLE
+//            fm_bottom.visibility = View.VISIBLE
 
             // videoIndex -> seeIndex
-            val data = super_short_video_view.data
+            val data = new_super_short_video_view.data
             if (data.size > it && data[it].itemType == MULTI_ITEM_1) {
                 mVedioBean!!.seeIndex = data[it].video!!.vedioIndex
                 mVedioBean!!.orderTags = orderTagsList
@@ -136,17 +129,15 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
 
         fm_bottom.setOnClickListener(this)
         close_iv.setOnClickListener(this)
+        ll_lucky.setOnClickListener(this)
     }
 
     override fun onClick(v: View?) {
         if (AntiShake.check(v?.id)) return
         when (v?.id) {
-            R.id.close_iv -> {
-                finish()
-            }
-            R.id.fm_bottom -> {
-                showEpisodeDialog()
-            }
+            R.id.close_iv -> finish()
+            R.id.fm_bottom -> showEpisodeDialog()
+            R.id.ll_lucky -> readyGo(NineActivity::class.java)
             else -> {}
         }
     }
@@ -156,53 +147,28 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
 
         val vedioBean = VedioBean()
         mVedioBean?.let {
-            if (!UserManager.getInstance().vipFlag) {
-                vedioBean.unlockIndex = mShowData.size
-            } else {
-                vedioBean.unlockIndex = it.unlockIndex
-            }
             vedioBean.title = it.title
-            vedioBean.completeStatus = it.completeStatus
             vedioBean.vedioTotal = it.vedioTotal
             vedioBean.seeIndex = it.seeIndex
             vedioBean.vedioTotal = it.vedioTotal
         }
 
-        dialog = VideoEpisodeDialog(this, vedioBean, object : DialogListener() {
-            override fun onClick(dialog: Dialog?, v: View?) {
-                super.onClick(dialog, v)
-                dialog?.dismiss()
-            }
-        })
-        dialog?.setCurrentIndex(super_short_video_view.realSeeIndex)
+        dialog = NewVideoEpisodeDialog(this, vedioBean, new_super_short_video_view.data)
+        dialog?.setCurrentIndex(new_super_short_video_view.realSeeIndex)
         dialog?.setOnEpisodeClickListener(this)
         dialog?.show()
     }
 
     override fun getIndexListSuc(indexList: IndexList) {
         // 处理推荐页跳转自动播放下一集逻辑
-        if (isPlayNext) {
-            playIndex = mVedioBean!!.recommendIndex - 1
-            if (playIndex >= mVedioBean!!.unlockIndex - 1) {
-                playIndex = mVedioBean!!.unlockIndex - 1
-            }
-        } else {
-            playIndex = mVedioBean!!.seeIndex - 1
-        }
-        if (playIndex > mVedioBean!!.vedioTotal || playIndex <= 0) playIndex = 0
-
-        tipList = indexList.tip
         mVedioBean = indexList.vedioMsg
+        playIndex = mVedioBean!!.seeIndex - 1
         mVedioBean?.isRecommendVedio = true
         indexBean = indexList
         mAllData.clear()
         mAllData.addAll(indexList.list)
 
-        if (!UserManager.getInstance().vipFlag) {
-            mShowData.add(mAllData[0])
-        }
-
-        super_short_video_view.loadData(mVedioBean, getAdapterData(), playIndex)
+        new_super_short_video_view.loadData(mVedioBean, getAdapterData(), playIndex)
     }
 
     override fun getIndexListFail() {
@@ -231,53 +197,82 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
     override fun showTurnSuc(data: NineShowBean) {
         AppPreferencesManager.get()
             .put(Constant.LUCKY_FLAG, data.isShow)
-        if (data.isShow) {
-            val complete = data.complete
-            val need = data.need
-            if (complete >= need) {
-                tv_lucky_status.text = SpanUtils()
-                    .append("可领取")
-                    .setForegroundColor(resources.getColor(R.color.apk_uninstalled))
-                    .create()
-            } else {
-                tv_lucky_status.text = SpanUtils()
-                    .append(complete.toString())
-                    .setForegroundColor(resources.getColor(R.color.red))
-                    .append("/")
-                    .append(need.toString())
-                    .create()
-            }
+
+        if (!data.isShow || UserManager.getInstance().vipFlag) {
+            ll_lucky.visibility = View.GONE
+            return
+        } else {
+            ll_lucky.visibility = View.VISIBLE
+            context?.let { GlideUtils.loadRoundImageViewGif(it, R.drawable.ic_nine, iv_lucky_gif) }
+        }
+
+        val complete = data.complete
+        val need = data.need
+        if (complete >= need) {
+            tv_lucky_status.text = SpanUtils()
+                .append("可领取")
+                .setForegroundColor(ContextCompat.getColor(this, R.color.apk_uninstalled))
+                .create()
+        } else {
+            tv_lucky_status.text = SpanUtils()
+                .append(complete.toString())
+                .setForegroundColor(ContextCompat.getColor(this, R.color.red))
+                .append("/")
+                .append(need.toString())
+                .create()
         }
     }
 
     override fun onEpisodeClick(position: Int) {
         dialog?.dismiss()
-        val data = super_short_video_view.data
-        if (position >= mVedioBean!!.unlockIndex) {
-            super_short_video_view.onItemClick(data.size - 1)
-            return
-        }
+//        val data = new_super_short_video_view.data
+//        if (position >= mVedioBean!!.unlockIndex) {
+//            new_super_short_video_view.onItemClick(data.size - 1)
+//            return
+//        }
 
-        val readPosition = getRealPosition(position + 1)
+//        val readPosition = getRealPosition(position + 1)
+        val readPosition = position
 
-        super_short_video_view.onItemClick(readPosition)
+        new_super_short_video_view.onItemClick(readPosition)
     }
 
-    private fun getAdapterData(): MutableList<VideoMultiItemEntity> {
-        val data = mutableListOf<VideoMultiItemEntity>()
-        if (mShowData.size > 0) {
-            for (video in mShowData) {
-                val item = VideoMultiItemEntity(MULTI_ITEM_1, video, VideoModel(video.vedioUrl))
-                data.add(item)
-            }
-            if (mVedioBean!!.unlockIndex < mVedioBean!!.vedioTotal) {
-                val item =
-                    VideoMultiItemEntity(
-                        MULTI_ITEM_2,
-                        mShowData[0],
-                        VideoModel(mShowData[0].vedioUrl)
+    private fun getAdapterData(): MutableList<VideoMultiItemEntity4> {
+        val data = mutableListOf<VideoMultiItemEntity4>()
+        for (i in 0 until mAllData.size) {
+            val item = mAllData[i]
+            when (mAllData[i].dos) {
+                VEDIO3DOS_FREE -> {
+                    data.add(
+                        i,
+                        VideoMultiItemEntity4(
+                            MULTI_ITEM_1,
+                            item,
+                            VideoModel(item.vedioUrl),
+                            VEDIO3DOS_FREE
+                        )
+                    )
+                }
+                VEDIO3DOS_AD -> {
+                    data.add(
+                        i, VideoMultiItemEntity4(
+                            MULTI_ITEM_2,
+                            item,
+                            VideoModel(item.vedioUrl),
+                            VEDIO3DOS_AD
+                        )
+                    )
+                }
+                VEDIO3DOS_PAY -> {
+                    data.add(
+                        i, VideoMultiItemEntity4(
+                            MULTI_ITEM_2,
+                            item,
+                            VideoModel(item.vedioUrl),
+                            VEDIO3DOS_PAY
+                        )
                     )
-                data.add(item)
+                }
             }
         }
         return data
@@ -316,13 +311,13 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
                                     }
 
                                     override fun adClose(vo: HashMap<String, Any>?) {
-                                        addEpisodeData(position)
+                                        updateEpisodeData(position, vo)
                                     }
                                 })
                         }
 
                         override fun adClose(vo: HashMap<String, Any>?) {
-                            addEpisodeData(position)
+                            updateEpisodeData(position, vo)
                         }
                     })
             }
@@ -339,16 +334,22 @@ class NewTxVideoActivity : BaseActivity(), View.OnClickListener, VideoView,
         }
     }
 
-    private fun addEpisodeData(position: Int) {
+    private fun updateEpisodeData(position: Int, vo: HashMap<String, Any>?) {
+        vo?.let {
+            // 解锁剧集
+            vo["vedioId"] = mVedioBean!!.vedioId
+            vo["num"] = (position + 1)
+            videoPresenter.unlock(vo)
+        }
+
         if (position >= mAllData.size) return
-        mShowData.add(mAllData[position])
-        super_short_video_view.loadMoreData(getAdapterData())
+        new_super_short_video_view.updateData(position)
     }
 
     // 用于点击匹配当前剧集对应的具体下标
     private fun getRealPosition(position: Int): Int {
         var readPosition = position
-        val data = super_short_video_view.data
+        val data = new_super_short_video_view.data
         if (data != null && data.size > 0) {
             for (i in 0 until data.size) {
                 if (data[i].itemType == MULTI_ITEM_1) {

video/app/src/main/java/com/mints/helivideo/video/tx/newrecommend/NewTxVideoAdapter.kt

+package com.mints.helivideo.video.tx.newrecommend
+
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.airbnb.lottie.LottieAnimationView
+import com.airbnb.lottie.LottieComposition
+import com.airbnb.lottie.LottieCompositionFactory
+import com.airbnb.lottie.LottieDrawable
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.chad.library.adapter.base.BaseMultiItemQuickAdapter
+import com.chad.library.adapter.base.viewholder.BaseViewHolder
+import com.mints.helivideo.R
+import com.mints.helivideo.ad.express.ExpressAdCallback
+import com.mints.helivideo.ad.express.ExpressManager
+import com.mints.helivideo.manager.UserManager
+import com.mints.helivideo.mvp.model.*
+import com.mints.helivideo.utils.UIUtils
+import com.mints.helivideo.video.tx.TXVideoBaseView
+
+class NewTxVideoAdapter : BaseMultiItemQuickAdapter<VideoMultiItemEntity4, BaseViewHolder>() {
+
+    private var vedioBean: VedioBean? = null
+
+    init {
+        addItemType(MULTI_ITEM_1, R.layout.player_item_short_video_play)
+        addItemType(MULTI_ITEM_2, R.layout.item_block_view)
+    }
+
+    override fun convert(holder: BaseViewHolder, item: VideoMultiItemEntity4) {
+        when (holder.itemViewType) {
+            MULTI_ITEM_1 -> {
+                initVideoHolder(holder, item.video)
+            }
+            MULTI_ITEM_2 -> {
+                initLockHolder(holder, item.type)
+            }
+        }
+    }
+
+    private fun initLockHolder(holder: BaseViewHolder, type: String?) {
+        Glide.with(context).load(vedioBean?.coverImage)
+            .into(holder.getView(R.id.iv_bg))
+        val vipBtn = holder.getView<View>(R.id.vip)
+        if (UserManager.getInstance().newFlag) {
+            // 匹配
+            vipBtn.visibility = View.VISIBLE
+            vipBtn.setOnClickListener {
+                mOnCustomChildClickListener?.onCustomChildClick(it, holder.adapterPosition)
+            }
+        } else {
+            // 未匹配
+            vipBtn.visibility = View.GONE
+        }
+
+        val adBtn = holder.getView<View>(R.id.unlock)
+        vedioBean?.let {
+            when (type) {
+                VEDIO3DOS_AD -> { // 观看激励视频解锁
+                    vipBtn.visibility = View.GONE
+                    adBtn.visibility = View.VISIBLE
+                    holder.getView<TextView>(R.id.tv_title).text = String.format(
+                        "解锁%s·第%d集",
+                        it.title,
+                        holder.adapterPosition + 1
+                    )
+                    holder.getView<TextView>(R.id.tv_info).text = String.format(
+                        "看激励视频解锁1集剧情\n请按照顺序解锁"
+                    )
+                }
+                VEDIO3DOS_PAY -> { // 开通会员解锁
+                    adBtn.visibility = View.GONE
+                    vipBtn.visibility = View.VISIBLE
+
+                    holder.getView<TextView>(R.id.tv_info).visibility = View.GONE
+                    vipBtn.setBackgroundResource(R.mipmap.bg_detail_bottom_vip)
+                    holder.getView<TextView>(R.id.tv_title).text =
+                        String.format("解锁%s·全集", it.title)
+                }
+                else -> {
+                    adBtn.visibility = View.VISIBLE
+
+                    holder.getView<TextView>(R.id.tv_title).text = String.format(
+                        "解锁%s·第%d-%d集",
+                        it.title,
+                        it.unlockIndex + 1,
+                        it.unlockIndex + it.adGiveVedioNum
+                    )
+                    holder.getView<TextView>(R.id.tv_info).text = String.format(
+                        "看激励视频解锁%d集剧情\n请按照顺序解锁",
+                        it.adGiveVedioNum
+                    )
+                }
+            }
+
+            holder.getView<TextView>(R.id.unlock).text = String.format("查看激励视频")
+            holder.getView<View>(R.id.unlock).setOnClickListener { it2 ->
+                mOnCustomChildClickListener?.onCustomChildClick(it2, holder.adapterPosition)
+            }
+        }
+
+        ExpressManager.instance.getAdView(
+            object : ExpressAdCallback {
+                override fun loadSuccess(adView: FrameLayout?) {
+                    adView?.let {
+                        UIUtils.removeFromParent(it)
+                        val fmAd = holder.getView<FrameLayout>(R.id.fl_ad)
+                        fmAd.removeAllViews()
+                        fmAd.addView(it)
+                    }
+
+                    ExpressManager.instance.preLoadAd()
+                }
+
+                override fun renderSuccess(adView: FrameLayout?): Boolean {
+                    adView?.let {
+                        UIUtils.removeFromParent(it)
+                        val fmAd = holder.getView<FrameLayout>(R.id.fl_ad)
+                        fmAd.removeAllViews()
+                        fmAd.addView(it)
+                    }
+
+                    ExpressManager.instance.preLoadAd()
+                    return false
+                }
+
+                override fun loadFail() {
+                }
+            })
+    }
+
+    private fun initVideoHolder(holder: BaseViewHolder, item: IndexList.VedioEpisodeBean?) {
+        //标题
+        holder.setText(R.id.title_tv, vedioBean?.title)
+        //集数
+        holder.setText(R.id.info_tv, "第" + item?.vedioIndex + "集")
+
+        //缩略图
+        Glide.with(context).load(vedioBean?.coverImage)
+            .skipMemoryCache(true)
+            .diskCacheStrategy(DiskCacheStrategy.ALL).centerCrop()
+            .into(holder.getView<TXVideoBaseView>(R.id.baseItemView).findViewById(R.id.iv_cover))
+
+        vedioBean?.let {
+            if (it.isRecommendVedio) {
+                holder.getView<LinearLayout>(R.id.ll_collect).visibility = View.GONE
+            } else {
+                holder.getView<LinearLayout>(R.id.ll_collect).visibility = View.VISIBLE
+
+                //收藏数量
+                holder.setText(R.id.zan_num_tv, "" + it.hot)
+                if (vedioBean?.collect == 0) {
+                    // 未收藏
+                    setCollectImage(holder.getView(R.id.zan_iv))
+                } else {
+                    // 已收藏
+                    setCancelCollectImage(holder.getView(R.id.zan_iv))
+                }
+
+                holder.getView<LinearLayout>(R.id.ll_collect).setOnClickListener { it2 ->
+                    mOnCustomChildClickListener?.onCustomChildClick(it2, holder.adapterPosition)
+                    if (it.collect == 0) {
+                        playCollectAnim(holder.getView(R.id.zan_iv))
+                    } else {
+                        playCancelCollectAnim(holder.getView(R.id.zan_iv))
+                    }
+                }
+            }
+        }
+
+        holder.getView<TXVideoBaseView>(R.id.baseItemView)
+            .setOnVideoEndListener(mOnVideoEndListener)
+
+    }
+
+    override fun onViewDetachedFromWindow(holder: BaseViewHolder) {
+        super.onViewDetachedFromWindow(holder)
+        if (holder.itemViewType == MULTI_ITEM_1) {
+            vedioBean?.let {
+                if (it.seeIndex == data[holder.layoutPosition].video!!.vedioIndex) {
+                    holder.getView<TXVideoBaseView>(R.id.baseItemView).pausePlayer()
+                    holder.getView<TXVideoBaseView>(R.id.baseItemView).stopForPlaying()
+                }
+            }
+        }
+    }
+
+    override fun onViewRecycled(holder: BaseViewHolder) {
+        super.onViewRecycled(holder)
+        if (holder.itemViewType == MULTI_ITEM_1) {
+            Glide.with(context).clear(holder.getView<View>(R.id.iv_cover))
+        }
+    }
+
+    private fun setCollectImage(view: LottieAnimationView) {
+        val lottieDrawable = LottieDrawable()
+        LottieCompositionFactory.fromAsset(context, "home_collect.json")
+            .addListener { result: LottieComposition? ->
+                lottieDrawable.setImagesAssetsFolder("images/")
+                lottieDrawable.composition = result
+            }
+        view.setImageDrawable(lottieDrawable)
+    }
+
+    private fun setCancelCollectImage(view: LottieAnimationView) {
+        val lottieDrawable = LottieDrawable()
+        LottieCompositionFactory.fromAsset(context, "home_cancel_collect.json")
+            .addListener { result: LottieComposition? ->
+                lottieDrawable.setImagesAssetsFolder("images/")
+                lottieDrawable.composition = result
+            }
+        view.setImageDrawable(lottieDrawable)
+    }
+
+    private fun playCollectAnim(view: LottieAnimationView) {
+        val lottieDrawable = LottieDrawable()
+        LottieCompositionFactory.fromAsset(context, "home_collect.json")
+            .addListener { result: LottieComposition? ->
+                lottieDrawable.setImagesAssetsFolder("images/")
+                lottieDrawable.composition = result
+                lottieDrawable.loop(false)
+                lottieDrawable.playAnimation()
+            }
+        view.setImageDrawable(lottieDrawable)
+    }
+
+    private fun playCancelCollectAnim(view: LottieAnimationView) {
+        val lottieDrawable = LottieDrawable()
+        LottieCompositionFactory.fromAsset(context, "home_cancel_collect.json")
+            .addListener { result: LottieComposition? ->
+                lottieDrawable.setImagesAssetsFolder("images/")
+                lottieDrawable.composition = result
+                lottieDrawable.loop(false)
+                lottieDrawable.playAnimation()
+            }
+        view.setImageDrawable(lottieDrawable)
+    }
+
+    private var mOnVideoEndListener: TXVideoBaseView.OnVideoEndListener? = null
+
+    fun setOnVideoEndListener(onVideoEndListener: TXVideoBaseView.OnVideoEndListener) {
+        this.mOnVideoEndListener = onVideoEndListener
+    }
+
+    private var mOnCustomChildClickListener: OnCustomChildClickListener? = null
+
+    fun setOnCustomChildClickListener(onCustomChildClickListener: OnCustomChildClickListener) {
+        this.mOnCustomChildClickListener = onCustomChildClickListener
+    }
+
+    interface OnCustomChildClickListener {
+        fun onCustomChildClick(view: View, position: Int)
+    }
+
+    fun setVedioBean(vedioBean: VedioBean) {
+        this.vedioBean = vedioBean
+    }
+}
+
+ 
\ No newline at end of file

video/app/src/main/res/layout/activity_new_tx_video.xml

 <?xml version="1.0" encoding="utf-8"?>
 <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:background="@color/black"
     android:orientation="vertical">
 
-    <com.mints.helivideo.video.tx.SuperShortVideoView
-        android:id="@+id/super_short_video_view"
+    <com.mints.helivideo.video.tx.newrecommend.NewSuperShortVideoView
+        android:id="@+id/new_super_short_video_view"
         android:layout_width="match_parent"
         android:layout_height="match_parent" />
 
@@ -59,16 +58,17 @@
         </LinearLayout>
 
     </FrameLayout>
+
     <LinearLayout
         android:id="@+id/ll_lucky"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_marginEnd="1dp"
-        android:visibility="gone"
         android:layout_gravity="bottom|right"
+        android:layout_marginEnd="1dp"
         android:layout_marginBottom="220dp"
         android:gravity="center"
-        android:orientation="vertical">
+        android:orientation="vertical"
+        android:visibility="gone">
 
         <ImageView
             android:id="@+id/iv_lucky_gif"