Android弹幕实现：基于B站弹幕开源系统（3）
本文在附录1，2的基础上再次对异步获取弹幕并显示弹幕完善逻辑和代码，集中在上层Java代码部分：
package zhangphil.danmaku;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import master.flame.danmaku.danmaku.model.BaseDanmaku;
import master.flame.danmaku.danmaku.model.DanmakuTimer;
import master.flame.danmaku.danmaku.model.IDisplayer;
import master.flame.danmaku.danmaku.model.android.DanmakuContext;
import master.flame.danmaku.ui.widget.DanmakuView;

public class MainActivity extends Activity {

    private DanmakuView mDanmakuView;
    private DanmakuContext mContext;
    private AcFunDanmakuParser mParser;

    private final int MAX_DANMAKU_LINES = 8; //弹幕在屏幕显示的最大行数

    private ScheduledThreadPoolExecutor mScheduledThreadPoolExecutor = null;
    private ConcurrentLinkedQueue<DanmakuMsg> mQueue = null; //所有的弹幕数据存取队列，在这里做线程的弹幕取和存
    private ArrayList<DanmakuMsg> danmakuLists = null;//每次请求最新的弹幕数据后缓存list

    private final int WHAT_GET_LIST_DATA = 0xffa01;
    private final int WHAT_DISPLAY_SINGLE_DANMAKU = 0xffa02;

    private final int BASE_TIME = 400;
    private final int BASE_TIME_ADD = 100;

    //标志文本弹幕的序列号
    //区别不同弹幕
    private static int danmakuTextMsgId = 0;

    private final int[] colors = {Color.RED, Color.YELLOW, Color.BLUE, Color.GREEN, Color.CYAN, Color.DKGRAY};

    private Handler mDanmakuHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case WHAT_GET_LIST_DATA:
                    mDanmakuHandler.removeMessages(WHAT_GET_LIST_DATA);

                    if (danmakuLists != null && !danmakuLists.isEmpty()) {
                        mQueue.addAll(danmakuLists);
                        danmakuLists.clear();

                        if (!mQueue.isEmpty())
                            mDanmakuHandler.sendEmptyMessage(WHAT_DISPLAY_SINGLE_DANMAKU);
                    }

                    break;

                case WHAT_DISPLAY_SINGLE_DANMAKU:
                    mDanmakuHandler.removeMessages(WHAT_DISPLAY_SINGLE_DANMAKU);
                    displayDanmaku();
                    break;
            }
        }
    };

    /**
     * 弹幕数据封装的类（bean）
     */
    private class DanmakuMsg {
        public String msg;
    }

    private void displayDanmaku() {
        boolean p = mDanmakuView.isPaused();
        //如果当前的弹幕由于Android生命周期的原因进入暂停状态，那么不应该不停的消耗弹幕数据
        //要知道，在这里发出一个handler消息，那么将会消费（删掉）ConcurrentLinkedQueue头部的数据
        if (!mQueue.isEmpty() && !p) {
            DanmakuMsg dm = mQueue.poll();
            if (!TextUtils.isEmpty(dm.msg)) {
                addDanmaku(dm.msg, true);
            }

            mDanmakuHandler.sendEmptyMessageDelayed(WHAT_DISPLAY_SINGLE_DANMAKU, (long) (Math.random() * BASE_TIME) + BASE_TIME_ADD);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        danmakuLists = new ArrayList<>();
        mQueue = new ConcurrentLinkedQueue<>();
        mDanmakuView = (DanmakuView) findViewById(R.id.danmakuView);

        initDanmaku();

        mScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
        GetDanmakuMessageTask mTask = new GetDanmakuMessageTask();
        //延迟0秒执行，每隔若干秒周期执行一次任务
        mScheduledThreadPoolExecutor.scheduleAtFixedRate(mTask, 0, 5, TimeUnit.SECONDS);

        Button show = (Button) findViewById(R.id.show);
        Button hide = (Button) findViewById(R.id.hide);
        Button sendText = (Button) findViewById(R.id.sendText);
        Button pause = (Button) findViewById(R.id.pause);
        Button resume = (Button) findViewById(R.id.resume);
        Button clear = (Button) findViewById(R.id.clear);

        show.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mDanmakuView.show();
            }
        });

        hide.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mDanmakuView.hide();
            }
        });

        sendText.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //每点击一次按钮发送一条弹幕
                sendTextMessage();
            }
        });

        pause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mDanmakuView.pause();
            }
        });

        resume.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mDanmakuView.resume();
            }
        });

        clear.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                clearDanmaku();
            }
        });
    }

    /**
     * 假设该线程任务模拟的就是从网络中取弹幕数据的耗时操作
     * 假设这些弹幕数据序列是有序的。
     */
    private class GetDanmakuMessageTask implements Runnable {
        @Override
        public void run() {
            danmakuLists.clear();

            int count = (int) (Math.random() * 50);
            for (int i = 0; i < count; i++) {
                DanmakuMsg message = new DanmakuMsg();
                message.msg = "弹幕:" + danmakuTextMsgId;
                danmakuLists.add(message);

                danmakuTextMsgId++;
            }

            if (!danmakuLists.isEmpty()) {
                Message msg = mDanmakuHandler.obtainMessage();
                msg.what = WHAT_GET_LIST_DATA;
                mDanmakuHandler.sendMessage(msg);
            }
        }
    }

    /**
     * 驱动弹幕显示机制重新运作起来
     */
    private void resumeDanmaku() {
        if (!mQueue.isEmpty())
            mDanmakuHandler.sendEmptyMessageDelayed(WHAT_DISPLAY_SINGLE_DANMAKU, (int) (Math.random() * BASE_TIME) + BASE_TIME_ADD);
    }

    private void clearDanmaku() {
        if (danmakuLists != null && !danmakuLists.isEmpty()) {
            danmakuLists.clear();
        }

        if (mQueue != null && !mQueue.isEmpty())
            mQueue.clear();

        mDanmakuView.clearDanmakusOnScreen();
        mDanmakuView.clear();
    }

    private void initDanmaku() {
        mContext = DanmakuContext.create();

        // 设置最大显示行数
        HashMap<Integer, Integer> maxLinesPair = new HashMap<>();
        maxLinesPair.put(BaseDanmaku.TYPE_SCROLL_RL, MAX_DANMAKU_LINES); // 滚动弹幕最大显示5行

        // 设置是否禁止重叠
        HashMap<Integer, Boolean> overlappingEnablePair = new HashMap<>();
        overlappingEnablePair.put(BaseDanmaku.TYPE_SCROLL_RL, true);
        overlappingEnablePair.put(BaseDanmaku.TYPE_FIX_TOP, true);

        //普通文本弹幕也描边设置样式
        //如果是图文混合编排编排，最后不要描边
        mContext.setDanmakuStyle(IDisplayer.DANMAKU_STYLE_STROKEN, 10) //描边的厚度
                .setDuplicateMergingEnabled(false)
                .setScrollSpeedFactor(1.2f) //弹幕的速度。注意！此值越小，速度越快！值越大，速度越慢。// by phil
                .setScaleTextSize(1.2f)  //缩放的值
//        .setCacheStuffer(new BackgroundCacheStuffer())  // 绘制背景使用BackgroundCacheStuffer
                .setMaximumLines(maxLinesPair)
                .preventOverlapping(overlappingEnablePair);

        mParser = new AcFunDanmakuParser();
        mDanmakuView.prepare(mParser, mContext);

        //mDanmakuView.showFPS(true);
        mDanmakuView.enableDanmakuDrawingCache(true);

        if (mDanmakuView != null) {
            mDanmakuView.setCallback(new master.flame.danmaku.controller.DrawHandler.Callback() {
                @Override
                public void updateTimer(DanmakuTimer timer) {
                }

                @Override
                public void drawingFinished() {

                }

                @Override
                public void danmakuShown(BaseDanmaku danmaku) {
                    //Log.d("弹幕文本", "danmakuShown text=" + danmaku.text);
                }

                @Override
                public void prepared() {
                    mDanmakuView.start();
                }
            });
        }
    }

    private void sendTextMessage() {
        addDanmaku("zhangphil@csdn: " + System.currentTimeMillis(), true);
    }

    private void addDanmaku(CharSequence cs, boolean islive) {
        BaseDanmaku danmaku = mContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
        if (danmaku == null || mDanmakuView == null) {
            return;
        }

        danmaku.text = cs;
        danmaku.padding = 5;
        danmaku.priority = 0;  // 可能会被各种过滤器过滤并隐藏显示
        danmaku.isLive = islive;
        danmaku.setTime(mDanmakuView.getCurrentTime() + 1200);
        danmaku.textSize = 20f * (mParser.getDisplayer().getDensity() - 0.6f); //文本弹幕字体大小
        danmaku.textColor = getRandomColor(); //文本的颜色
        danmaku.textShadowColor = getRandomColor(); //文本弹幕描边的颜色
        //danmaku.underlineColor = Color.DKGRAY; //文本弹幕下划线的颜色
        danmaku.borderColor = getRandomColor(); //边框的颜色

        mDanmakuView.addDanmaku(danmaku);
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mDanmakuView != null && mDanmakuView.isPrepared()) {
            mDanmakuView.pause();
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (mDanmakuView != null && mDanmakuView.isPrepared() && mDanmakuView.isPaused()) {
            mDanmakuView.resume();

            //重新启动handler消息机制，触发弹幕显示
            //如果没有这一个方法，那么显示弹幕的机制将失灵（失去驱动）
            //这个方法就是重新激发弹幕显示的handler机制。
            resumeDanmaku();
        }
    }

    private void closeGetDanmakuMessage() {
        if (mScheduledThreadPoolExecutor != null)
            mScheduledThreadPoolExecutor.shutdown();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mDanmakuView != null) {
            // dont forget release!
            mDanmakuView.release();
            mDanmakuView = null;
        }

        closeGetDanmakuMessage();
    }

    /**
     * 从一系列颜色中随机选择一种颜色
     *
     * @return
     */
    private int getRandomColor() {
        int i = ((int) (Math.random() * 10)) % colors.length;
        return colors[i];
    }
}


代码运行结果如图：

附录：
1，《Android弹幕实现：基于B站弹幕开源系统（1）》链接：http://blog.csdn.net/zhangphil/article/details/68067100 
2,《Android弹幕实现：基于B站弹幕开源系统（2）》链接：http://blog.csdn.net/zhangphil/article/details/68114226 
3，《Java ConcurrentLinkedQueue队列线程安全操作》链接：http://blog.csdn.net/zhangphil/article/details/65936066


Android弹幕实现：基于B站弹幕开源系统（4）-重构
弹幕在视频播放的APP中比较常见，但是逻辑比较复杂，现在在附录1,2,3的基础上，我再次对弹幕进行抽象和重构，把弹幕从底向上抽象成不同的层，便于复用。
第一步，抽象数据层。
通常弹幕的来源是来源于后台的数据接口请求，在实时直播时候，是通过网络的轮询机制获取数据，那么，我把这部分代码抽出来设计成一个MGDanmakuHttpController，该类专注于数据的获取与分发：
package zhangphil.danmaku;

import android.os.Handler;
import android.os.Message;
import android.support.annotation.NonNull;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.Callable;

import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.schedulers.Schedulers;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/**
 * Created by Phil on 2017/3/31.
 */

public class MGDanmakuHttpController {

    //private final String TAG = getClass().getName() + String.valueOf(UUID.randomUUID());

    private int msgId = 0;

    private DataMessageListener mDataMessageListener = null;
    private OkHttpClient mOkHttpClient;

    public MGDanmakuHttpController() {
        mOkHttpClient = new OkHttpClient();
    }

    private final int WHAT_START = 0xff0a;
    //private final int WHAT_STOP = WHAT_START + 1;

    private boolean promise = false;

    private int interval = 0;

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            if (msg.what == WHAT_START) {
                handler.removeMessages(WHAT_START);

                try {
                    if (promise)
                        startRequestDanmaku();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    };


    public void startRequestDanmaku() throws Exception {
        promise = true;

        Observable mObservable = Observable.fromCallable(new Callable<List<DanmakuMsg>>() {
            @Override
            public List<DanmakuMsg> call() throws Exception {
                //同步方法返回观察者需要的数据结果
                //在这里处理线程化的操作
                return fetchData();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());

        mObservable.subscribe(new DisposableObserver<List<DanmakuMsg>>() {

            @Override
            public void onNext(@NonNull List<DanmakuMsg> lists) {
                if (mDataMessageListener != null && promise) {
                    mDataMessageListener.onDataMessageListener(lists);
                }
            }

            @Override
            public void onComplete() {
                fireRequest();
            }

            @Override
            public void onError(Throwable e) {
                fireRequest();
            }
        });
    }

    public void stopRequestDanmaku() {
        promise = false;
    }

    /**
     * 设置轮询的间隔时间
     *
     * @param interval 单位毫秒 默认是0
     */
    public void setHttpRequestInterval(int interval) {
        this.interval = interval;
    }

    private void fireRequest() {
        //这里将触发重启数据请求，在这里可以调节重启数据请求的节奏。
        //比如可以设置一定的时延
        handler.sendEmptyMessageDelayed(WHAT_START, interval);
    }

    private List<DanmakuMsg> fetchData() {
        //同步方法返回观察者需要的数据结果
        //在这里处理线程化的操作
//        String url = "http://blog.csdn.net/zhangphil";
//        try {
//            Request request = new Request.Builder().url(url).build();
//            Response response = mOkHttpClient.newCall(request).execute();
//            if (response.isSuccessful()) {
//                byte[] bytes = response.body().bytes();
//                String data = new String(bytes, 0, bytes.length);


        try {
            Thread.sleep((int) (Math.random() * 500));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        int count = (int) (Math.random() * 10);

        //装配模拟数据
        List<DanmakuMsg> danmakuMsgs = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            DanmakuMsg danmakuMsg = new DanmakuMsg();
            danmakuMsg.msg = String.valueOf(msgId++);
            danmakuMsgs.add(danmakuMsg);
        }

        return danmakuMsgs;
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//
//        return null;
    }


    public interface DataMessageListener {
        void onDataMessageListener(@NonNull List<DanmakuMsg> lists);
    }

    public void setDataMessageListener(DataMessageListener listener) {
        mDataMessageListener = listener;
    }
}


第二步，通过一个模型把弹幕的view和数据用胶水粘合在一起，我写了一个MGDanmaku：
package zhangphil.danmaku;

import android.graphics.Color;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.util.Log;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ConcurrentLinkedQueue;

import master.flame.danmaku.danmaku.model.BaseDanmaku;
import master.flame.danmaku.danmaku.model.DanmakuTimer;
import master.flame.danmaku.danmaku.model.IDisplayer;
import master.flame.danmaku.danmaku.model.android.DanmakuContext;
import master.flame.danmaku.ui.widget.DanmakuView;

/**
 * Created by Phil on 2017/4/1.
 */

public class MGDanmaku {
    private final String TAG = getClass().getName() + UUID.randomUUID();

    private MGDanmakuHttpController mMGDanmakuHttpController;
    private DanmakuView mDanmakuView;
    private AcFunDanmakuParser mParser;

    private DanmakuContext mDanmakuContext;

    private final int MAX_DANMAKU_LINES = 8; //弹幕在屏幕显示的最大行数

    private ConcurrentLinkedQueue<DanmakuMsg> mQueue = null; //所有的弹幕数据存取队列，在这里做线程的弹幕取和存
    private ArrayList<DanmakuMsg> danmakuLists = null;//每次请求最新的弹幕数据后缓存list

    private final int WHAT_GET_LIST_DATA = 0xffab01;
    private final int WHAT_DISPLAY_SINGLE_DANMAKU = 0xffab02;

    /**
     * 每次弹幕的各种颜色从这里面随机的选一个
     */
    private final int[] colors = {
            Color.RED,
            Color.YELLOW,
            Color.BLUE,
            Color.GREEN,
            Color.CYAN,
            Color.DKGRAY};

    //弹幕开关总控制
    // true正常显示和请求
    // false则取消
    private boolean isDanmukuEnable = false;

    public MGDanmaku(@NonNull DanmakuView view, @NonNull MGDanmakuHttpController controller) {
        this.mDanmakuView = view;
        this.mMGDanmakuHttpController = controller;

        initDanmaku();

        danmakuLists = new ArrayList<>();
        mQueue = new ConcurrentLinkedQueue<>();

        mMGDanmakuHttpController.setDataMessageListener(new MGDanmakuHttpController.DataMessageListener() {
            @Override
            public void onDataMessageListener(@NonNull List<DanmakuMsg> lists) {
                danmakuLists = (ArrayList<DanmakuMsg>) lists;
                //for (int i = 0; i < danmakuLists.size(); i++) {
                    //Log.d("获得数据", danmakuLists.get(i).msg);
                //}

                addListData();
            }
        });

        Log.d(getClass().getName(), TAG);
    }

    private Handler mDanmakuHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case WHAT_GET_LIST_DATA:
                    addListData();
                    break;

                case WHAT_DISPLAY_SINGLE_DANMAKU:
                    mDanmakuHandler.removeMessages(WHAT_DISPLAY_SINGLE_DANMAKU);
                    displayDanmaku();
                    break;
            }
        }
    };

    private void addListData() {
        if (danmakuLists != null && !danmakuLists.isEmpty()) {
            mDanmakuHandler.removeMessages(WHAT_GET_LIST_DATA);

            mQueue.addAll(danmakuLists);
            danmakuLists.clear();

            mDanmakuHandler.sendEmptyMessage(WHAT_DISPLAY_SINGLE_DANMAKU);
        }
    }


    private void initDanmaku() {
        // 设置最大显示行数
        HashMap<Integer, Integer> maxLinesPair = new HashMap<>();
        maxLinesPair.put(BaseDanmaku.TYPE_SCROLL_RL, MAX_DANMAKU_LINES); // 滚动弹幕最大显示5行

        // 设置是否禁止重叠
        HashMap<Integer, Boolean> overlappingEnablePair = new HashMap<>();
        overlappingEnablePair.put(BaseDanmaku.TYPE_SCROLL_RL, true);
        overlappingEnablePair.put(BaseDanmaku.TYPE_FIX_TOP, true);

        mDanmakuContext = DanmakuContext.create();

        //普通文本弹幕也描边设置样式
        //如果是图文混合编排编排，最后不要描边
        mDanmakuContext.setDanmakuStyle(IDisplayer.DANMAKU_STYLE_STROKEN, 10) //描边的厚度
                .setDuplicateMergingEnabled(false)
                .setScrollSpeedFactor(1.2f) //弹幕的速度。注意！此值越小，速度越快！值越大，速度越慢。// by phil
                .setScaleTextSize(1.2f)  //缩放的值
//        .setCacheStuffer(new BackgroundCacheStuffer())  // 绘制背景使用BackgroundCacheStuffer
                .setMaximumLines(maxLinesPair)
                .preventOverlapping(overlappingEnablePair);

        mParser = new AcFunDanmakuParser();
        mDanmakuView.prepare(mParser, mDanmakuContext);

        //mDanmakuView.showFPS(true);
        mDanmakuView.enableDanmakuDrawingCache(true);

        if (mDanmakuView != null) {
            mDanmakuView.setCallback(new master.flame.danmaku.controller.DrawHandler.Callback() {
                @Override
                public void updateTimer(DanmakuTimer timer) {
                }

                @Override
                public void drawingFinished() {

                }

                @Override
                public void danmakuShown(BaseDanmaku danmaku) {
                    Log.d("弹幕文本", "显示 text=" + danmaku.text);
                }

                @Override
                public void prepared() {
                    mDanmakuView.start();
                }
            });
        }
    }

    /**
     * 驱动弹幕显示机制重新运作起来
     */
    private void startDanmaku() {
        mDanmakuView.show();
        //mDanmakuView.start();

        mDanmakuHandler.sendEmptyMessage(WHAT_GET_LIST_DATA);
        mDanmakuHandler.sendEmptyMessage(WHAT_DISPLAY_SINGLE_DANMAKU);
    }

    private void stopDanmaku() {
        if (mDanmakuView != null) {
            mDanmakuView.hide();
            mDanmakuView.clearDanmakusOnScreen();
            mDanmakuView.clear();
        }

        mDanmakuHandler.removeMessages(WHAT_GET_LIST_DATA);
        mDanmakuHandler.removeMessages(WHAT_DISPLAY_SINGLE_DANMAKU);

        danmakuLists.clear();
        mQueue.clear();
    }

    public void setDanmakuRunning(boolean enable) {
        //如果是重复设置，则跳过
        if (isDanmukuEnable == enable) {
            return;
        }

        this.isDanmukuEnable = enable;

        //Log.d("isDanmukuEnable", String.valueOf(isDanmukuEnable));

        if (isDanmukuEnable) {
            startDanmaku();

            try {
                mMGDanmakuHttpController.startRequestDanmaku();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            stopDanmaku();
            mMGDanmakuHttpController.stopRequestDanmaku();
        }
    }


    public boolean getDanmakuRunning() {
        return isDanmukuEnable;
    }

    public void sendMsg(@NonNull DanmakuMsg danmakuMsg) {
        displayDanmaku(danmakuMsg);
    }

    public void onResume() {
        if (mDanmakuView != null && mDanmakuView.isPrepared() && mDanmakuView.isPaused()) {
            mDanmakuView.resume();
        }
    }

    public void onPause() {
        if (mDanmakuView != null && mDanmakuView.isPrepared()) {
            mDanmakuView.pause();
        }
    }

    public void onDestroy() {
        if (mDanmakuView != null) {
            // dont forget release!
            mDanmakuView.release();
            mDanmakuView = null;
        }

        stopDanmaku();
    }

    private void displayDanmaku(@NonNull DanmakuMsg dm) {
        //如果当前的弹幕由于Android生命周期的原因进入暂停状态，那么不应该不停的消耗弹幕数据
        //要知道，在这里发出一个handler消息，那么将会消费（删掉）ConcurrentLinkedQueue头部的数据
        if (isDanmukuEnable) {
            if (!TextUtils.isEmpty(dm.msg)) {
                addDanmaku(dm.msg, dm.islive);
            }
        }
    }

    private void displayDanmaku() {
        //如果当前的弹幕由于Android生命周期的原因进入暂停状态，那么不应该不停的消耗弹幕数据
        //要知道，在这里发出一个handler消息，那么将会消费（删掉）ConcurrentLinkedQueue头部的数据
        boolean b = !mQueue.isEmpty() && getDanmakuRunning();
        if (b) {
            DanmakuMsg dm = mQueue.poll();
            if (!TextUtils.isEmpty(dm.msg)) {
                addDanmaku(dm.msg, dm.islive);//可以在此之后再加一行代码，驱动弹幕继续显示单个弹幕 mDanmakuHandler.sendEmptyMessageDelayed(WHAT_DISPLAY_SINGLE_DANMAKU, (long) (Math.random() * 400) + 100);
            }
        }
    }

    private void addDanmaku(CharSequence cs, boolean islive) {
        BaseDanmaku danmaku = mDanmakuContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
        if (danmaku == null || mDanmakuView == null) {
            return;
        }

        danmaku.text = cs;
        danmaku.padding = 5;
        danmaku.priority = 0;  // 可能会被各种过滤器过滤并隐藏显示
        danmaku.isLive = islive;
        danmaku.setTime(mDanmakuView.getCurrentTime());
        danmaku.textSize = 20f * (mParser.getDisplayer().getDensity() - 0.6f); //文本弹幕字体大小
        danmaku.textColor = getRandomColor(); //文本的颜色
        danmaku.textShadowColor = getRandomColor(); //文本弹幕描边的颜色
        //danmaku.underlineColor = Color.DKGRAY; //文本弹幕下划线的颜色
        danmaku.borderColor = getRandomColor(); //边框的颜色

        mDanmakuView.addDanmaku(danmaku);
    }

    /**
     * 从一系列颜色中随机选择一种颜色
     *
     * @return
     */
    private int getRandomColor() {
        int i = ((int) (Math.random() * 10)) % colors.length;
        return colors[i];
    }
}



第三步，直接拿来在上层的activity用：
package zhangphil.danmaku;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.CompoundButton;

import master.flame.danmaku.ui.widget.DanmakuView;

public class MainActivity extends Activity {
    private MGDanmaku mMGDanmaku;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(getClass().getName(),"onCreate");

        DanmakuView mDanmakuView = (DanmakuView) findViewById(R.id.danmakuView);

        MGDanmakuHttpController mMGDanmakuHttpController = new MGDanmakuHttpController();
        mMGDanmakuHttpController.setHttpRequestInterval(0);
        mMGDanmaku = new MGDanmaku(mDanmakuView, mMGDanmakuHttpController);

        CheckBox checkBox = (CheckBox) findViewById(R.id.checkBox);
        checkBox.setChecked(mMGDanmaku.getDanmakuRunning());
        checkBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                mMGDanmaku.setDanmakuRunning(isChecked);
            }
        });

        Button sendText = (Button) findViewById(R.id.sendText);
        sendText.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DanmakuMsg msg = new DanmakuMsg();
                msg.msg = "zhangphil: " + System.currentTimeMillis();

                mMGDanmaku.sendMsg(msg);
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        mMGDanmaku.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mMGDanmaku.onPause();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mMGDanmaku.onDestroy();
    }
}



一个简单的弹幕数据消息封装包：
package zhangphil.danmaku;

/**
 * Created by Phil on 2017/3/31.
 */

import java.io.Serializable;

/**
 * 弹幕数据封装的类（bean）
 */
public class DanmakuMsg implements Serializable {
    public String id = "";
    public String msg = null;
    public boolean islive = true;
    public String point = "";
}



测试的MainActivity布局文件：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <CheckBox
        android:id="@+id/checkBox"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="弹幕开关" />

    <Button
        android:id="@+id/sendText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="发送文本弹幕" />

    <master.flame.danmaku.ui.widget.DanmakuView
        android:id="@+id/danmakuView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>


注意！需要配置Activity在AndroidManifest.xml的属性configChanges和launchMode，以适应弹幕在横竖屏切换时的状态正确，配置如：
 <activity android:name=".MainActivity"
            android:configChanges="orientation|keyboardHidden|screenSize|fontScale"
            android:launchMode="singleTask">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>


代码运行结果如图：

附录：
1，《Android弹幕实现：基于B站弹幕开源系统（1）》链接：http://blog.csdn.net/zhangphil/article/details/68067100  
2，《Android弹幕实现：基于B站弹幕开源系统（2）》链接：http://blog.csdn.net/zhangphil/article/details/68114226  
3，《Android弹幕实现：基于B站弹幕开源系统（3）-文本弹幕的完善和细节调整》链接：http://blog.csdn.net/zhangphil/article/details/68485505 
4，《Java ConcurrentLinkedQueue队列线程安全操作》链接：http://blog.csdn.net/zhangphil/article/details/65936066 

前言
    现在很多的视屏网站，像优酷、acfun，甚至直播网站都实现了弹（dàn）幕技术。弹幕的添加，使得观看视屏的实时评论可以被同时观看这个视屏的其他用户所看到，并且可以加入到讨论当中。完全改变了以往看视屏的方式。相信大家在观看视屏时也有所体会。那么这篇博客将记录怎么实现简单弹幕的过程。


分析
    在使用的弹幕视频网中，我们可以简单的分析弹幕的基本逻辑。当用户发送一条文本消息时，这条文本消息就会出现在视频的上方，从右往左过渡。通过查看源代码可以知道，那些大型的弹幕视屏网站时通过Flash实现弹幕的。


再看源代码，这条链接打开其实是一个Flash的播放器，连发送文本消息的文本框都是内嵌到播放器上的，所以想看它怎么处理文本看不了。




如果熟悉弹幕这方面的大神看到我分析错了，请纠错，但请轻喷，我还只是个孩子~。


既然看不了怎么处理文本的，没办法，就自己想办法解决咯。just do it，搞起。
我想到的一个方案就是，在视屏上再覆盖一层透明的div，暂且称为"文字层"，用来过渡弹幕。如果有其他方案欢迎提出~


实现
弹幕的实现又分为两个小块实现，一个是播放视屏，一个是文本输入框。播放视屏直接用的是HTML5的新标签<video>，这个标签的用法这里就不再熬述了，想了解的可以查阅其他资料。播放视频上不要忘了，还要覆盖一层"文字层"。第二块，文本输入框用的是<textarer>具体的还是看代码。
HTML：
<div class="mv_play">
    <video width="750px" height="" src="source/yilu.mp4" controls="controls" ></video>
        <div id="fontdiv" class="fontdiv"></div>
</div>
<div class="pushtext">
    <textarea id="message" maxlength="15" ></textarea>
    <div οnclick="pushtext()" class="pushbtn">发送</div>
</div>


CSS：
.mv_play {
    margin-left: 20px;
    position: relative;
}

.fontdiv {
    position: absolute;
    z-index: 120;
    width: 750px;
    height: 386px;
    top: 0px;
    color: white;
    overflow: hidden;
}
.pushtext {
    margin-left: 20px;
    margin-top: 15px;
    height: 50px;
}
.pushtext > textarea {
    width: 678px;
    height: 16px;
    border: 1px solid #433B38;
    border-radius: 4px 0 0 4px;
    resize: none;
    outline: none;
    padding: 12px;
    padding-left: 15px;
    line-height: 15px;
    float: left;
}
.pushbtn {
    display: block;
    width: 43px;
    height: 42px;
    border-radius: 0 4px 4px 0;
    line-height: 45px;
    background: #433B38;
    color: #fff;
    font-size: 14px;
    float: left;
    text-align: center;
    cursor: pointer;
}

.changmessage{
    transition:right linear 6s;
    right: 750px;
    animation:toleft 5.5s  linear;
}

@keyframes toleft{
    0%{
        transform:translateX(0);
    }
    100%{
        transform:translateX(-1200px);
    }
}
.oldp{
    position: absolute;
    border: 2px solid cadetblue;
    margin-top: 5px;
    left: 750px;
    font-size: 20px;
}






这里说明一下，要想文字层覆盖在视屏层上，在他们两个层的父级（这里就是class=mv_play的div）的positive要设置为relative。然后文字层positive属性设置的absolute才会根据父级相对调整位置，还要设置overflow为hidden，当弹幕还没出现在播放区域内时隐藏。然后就是用z-index来实现覆盖，这个属性设置的数值越大，所设置的这个层就表示越在上面。


最后就是功能的实现了，这里只是实现简单的弹幕效果，并没有后端处理。
大概的思路就是首先获取文本框的内容，放进<pre>标签内，然后往“文本层”添加这个<pre>标签。在添加的同时给<pre>标签添加一个移动的类changemessage，文本就会往左边移动。别忘了在移动完后还要隐藏掉这个文本，所以要设置一个时间调度器，在一定时间后隐藏文本。具体看以下代码。


js：
 function messaction(ppp) {
        ppp.addClass("changmessage");
    }

    function messstop(ppp) {
        ppp.hide();
    }

    function pushtext(){
        var message=$("#message").val();
		if(message.length>0){
			$("#fontdiv").append("<pre class='oldp' style='width: "+message.length+"em'>"+message+"</pre>");
			$("#message").val("");
			var ppp= $("pre").last();
			//移动弹幕
			setTimeout(function(){
				messaction(ppp);
			},100);
			//隐藏弹幕
			setTimeout(function(){
				messstop(ppp);
			},8500);
		}
    };

    document.οnkeydοwn=function(event){
        var e = event || window.event || arguments.callee.caller.arguments[0];
        if(e&&e.keyCode==13){
            //要做的事情
			e.preventDefault();
			var messvalue=$("#message").val();
			if(messvalue.length>0){
				pushtext();
			}
        }
    };

结语

最后还是上个效果图吧


大概的思路就是以上所说，但实际用起来还是有问题的，比如文本多少时间后才隐藏、消耗内存、视屏没有播放弹幕也依然过渡等。如果真要用到实际开发，还可能需要用到ajax等技术就不多说了。

相信大家看视频的时候都会有弹幕效果，这似乎已经成为视频软件的标配，接下来让我们来看看如何实现这个弹幕效果。




一.弹幕效果分析




我可以看到，弹幕效果是在屏幕上方飘过，即从屏幕外一端出现，一直在屏幕中飘动至屏幕另一端，我们将其实现逻辑进行分解如下：

1.一个viewGroup中包含多个textView

2.textView包含平移动画

经过分解发现其逻辑一点也不复杂，分析完






二.实现

上面我们分析了自定义弹幕效果View的逻辑：

这里我们让我们自定义的的BarrageView继承RelateLayout，并实现onLayout方法。

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        int childCount = this.getChildCount();
        for(int i = 0; i < childCount; i++){
            final View view = getChildAt(i);
            if (view != null){
                RelativeLayout.LayoutParams lp = (LayoutParams) view.getLayoutParams();
                if (lp.leftMargin <= 0){
                    if(mDirection == FROM_RIGNG_TO_LEFT){
                        view.layout(mScreenWidth,lp.topMargin,mScreenWidth+view.getMeasuredWidth(),
                                lp.topMargin+view.getMeasuredHeight());
                    }else if(mDirection == FROM_LEFT_TO_RIGHT){
                        view.layout(-view.getMeasuredWidth(),lp.topMargin,0,
                                lp.topMargin+view.getMeasuredHeight());
                    }
                }
            }
        }
    }

这里很多人可能会问为什么是实现onLayout方法，我们的BarrageView继承了RelateLayout,即继承了一个viewGroup,而飘屏的弹幕均属于这个viewGroup的子View，我们的弹幕效果要实现必须在我们需要的时候往这个BarrageView中添加一个子view,添加子view我们就必须要为其指定在父控件中的位置。而每当我们像BarrageView中加入一个子view，就会执行其onLayout方法，所以我们最终就在onLayout中确定子view的初始位置


    从代码中我们可以看到这边我支持了两个方向，从左到右（FROM_LEFT_TO_RIGHT）和从右到左（FROM_RIGNG_TO_LEFT），这里我们分析从右到左，毕竟目前较多的软件都是从右到左飘屏
view.layout(mScreenWidth,lp.topMargin,mScreenWidth+view.getMeasuredWidth(),
                                lp.topMargin+view.getMeasuredHeight());
这段代码写的很清晰，既然是从右到左飘屏，那我们添加的子view最开始的位置当然就是在屏幕外右端，如下图










接下来我们要添加子view，并为其设置相应的动画效果，使其达到飘屏的效果

	private void createBarrageItemView(Context context,String text,int textSize,int textColor){
        final TextView textView = new TextView(context);
        textView.setBackgroundResource(R.drawable.barrage_item_bg);
        if (textColor != 0){
            textView.setTextColor(getResources().getColor(textColor));
        }
        if (textSize != 0){
            textView.setTextSize(textSize);
        }
        textView.setText(text);

        int w = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);
        int h = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);
        textView.measure(w, h);
        int height =textView.getMeasuredHeight();
        int width = textView.getMeasuredWidth();
        int row = new Random().nextInt(100) % mRowNum;
        while (needResetRow(row)){
            row = new Random().nextInt(100) % mRowNum;
        }
        mRowPosList.add(row);

        RelativeLayout.LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT,LayoutParams.WRAP_CONTENT);
        lp.topMargin = row * (height + ToolUtils.dip2px(context,10));
//        lastRow = row;
        textView.setLayoutParams(lp);
        textView.setPadding(ToolUtils.dip2px(context,15), ToolUtils.dip2px(context,2), ToolUtils.dip2px(context,15), ToolUtils.dip2px(context,2));
        textView.getBackground().setAlpha(mAlpha);
        this.addView(textView);
        ViewPropertyAnimator animator = null;

        if(mDirection == FROM_RIGNG_TO_LEFT){
            animator = textView.animate()
                    .translationXBy(-(mScreenWidth + width + 80));
        }else if(mDirection == FROM_LEFT_TO_RIGHT){
            animator = textView.animate()
                    .translationXBy(mScreenWidth + width + 80);
        }
        animator.setDuration(mDuration);
        animator.setInterpolator(new LinearInterpolator());
        animator.start();
        animator.setListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
//                mChildView.remove(textView);
                BarrageView.this.removeView(textView);
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        mChildView.add(textView);
    }

添加子view需要注意一下几点：


利用随机数，生成子view出现在第几行，
	int row = new Random().nextInt(100) % mRowNum;
        while (needResetRow(row)){
            row = new Random().nextInt(100) % mRowNum;
        }
        mRowPosList.add(row);
然后在判断子view是否需要重新设置所在行（需要设置是为了不让后面的子view与前面的子view重叠），其实现如下：

    public boolean needResetRow(int row){
        int size = mRowPosList.size();
        int sameRowPos =-1;
        for(int i = size; i > 0; i--){
            if (row == mRowPosList.get(i-1)){
                sameRowPos = i-1;
                break;
            }
        }
        if (sameRowPos != -1){
            TextView tv = mChildView.get(sameRowPos);
            if (mScreenWidth -tv.getX() < tv.getWidth()){
                return true;
            }
        }
        return false;
    }
该逻辑思想为，从所有子view中遍历，找到与当前需要添加的子view同一行的最后一个添加的子view，（我们用sameRowView表示），判断sameRowView是否显示完全，如果未显示完全就继续生成随机行数。（图画的丑
 ，能看懂就行....）




这里指的一提的是，以上逻辑是存在问题的，如果每个子view都很长的话，当全部子view占满屏幕且都没显示完全时，我们将会陷入一个死循环，这样我们的应用就会卡死（为了制作gif图好看，采用这种方式），通过上网查阅，给出的方案是，只记录最后一个子view所在的位置，判断当前新家的子view是否与上一个子view同行，若是，则重选行数。

	int row = new Random().nextInt(100) % mRowNum;
        while (mLastRow == row){
            row = new Random().nextInt(100) % mRowNum;
        }
        mLastRow = row;

很遗憾的是，上述的方法虽然不会卡死（不会卡死就很重要了，毕竟能卡死应用已经很严重，所以实际使用推荐使用这种方式，或者有其他更好的方式欢迎交流） 但是没有解决子view间相互覆盖的问题。如下图，我们1先加入BarrageView中，然后我们2加入并且我们2不会与1在同一行，如果同行就重选选行，同理3不会与2同行，但是3可以与1同行，因为1不是最后一个加入BarrageView的子view，但是确实存在了覆盖问题












至此我们的自定义弹幕BarrageView就分析完了，下面贴上调用代码与自定义BarrageView代码

MainActivity.java
public class MainActivity extends AppCompatActivity {
    private BarrageView barrageView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        barrageView = (BarrageView) findViewById(R.id.barrageView);
        barrageView.setBackgroundResource(0);
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 10000; i++){
                    final int finalI = i;
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if (finalI%2 == 0){
                                barrageView.addBarrageItemView(MainActivity.this,"第" + finalI +"条弹幕");
                            }else{
                                barrageView.addBarrageItemView(MainActivity.this,"第" + finalI +"条弹幕"+"第" + finalI +"条弹幕");
                            }
                        }
                    });
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}
BarrageView.java

public class BarrageView extends RelativeLayout{
    private int mRowNum = 6;
    private long mDuration = 5000;//弹幕在屏幕显示的时间 默认5s
    private int mAlpha = 180;//背景的透明度0-255
    private int mDirection = FROM_RIGNG_TO_LEFT;//当前弹幕活动方向 默认从右到左
    public static final int FROM_LEFT_TO_RIGHT = 1;//从左到右
    public static final int FROM_RIGNG_TO_LEFT = 2;//从右到左
    private int mScreenWidth;
    private List<TextView> mChildView;
    private LinkedList mRowPosList;
    public BarrageView(Context context) {
        super(context);
        init(context);
    }
    public BarrageView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }
    public BarrageView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }
    private void init(Context context){
        mScreenWidth = ToolUtils.getScreenWidth(context);
        mChildView = new ArrayList<TextView>();
        mRowPosList = new LinkedList();
    }
    /**
     * 设置弹幕飘动方向
     * @param direction 弹幕飘动方向 默认从右到左 FROM_RIGNG_TO_LEFT
     */
    public void setDirection(int direction){
        mDirection = direction;
    }
    /**
     * 设置弹幕飘屏时间
     * @param duration 弹幕飘屏时间 默认5s
     */
    public void setDuration(long duration){
        mDuration = duration;
    }
    /**
     * 设置飘屏行数
     * @param rowNum 飘屏行数 默认6条
     */
    public void setRowNum(int rowNum){
        mRowNum = rowNum;
    }
    /**
     * 设置item的背景透明度 范围：0~255
     * @param alpha 取值0~255  0为全透明
     */
    public void setBackgroundAlpha(int alpha){
        mAlpha = alpha;
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
    }
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        int childCount = this.getChildCount();
        for(int i = 0; i < childCount; i++){
            final View view = getChildAt(i);
            if (view != null){
                RelativeLayout.LayoutParams lp = (LayoutParams) view.getLayoutParams();
                if (lp.leftMargin <= 0){
                    if(mDirection == FROM_RIGNG_TO_LEFT){
                        view.layout(mScreenWidth,lp.topMargin,mScreenWidth+view.getMeasuredWidth(),
                                lp.topMargin+view.getMeasuredHeight());
                    }else if(mDirection == FROM_LEFT_TO_RIGHT){
                        view.layout(-view.getMeasuredWidth(),lp.topMargin,0,
                                lp.topMargin+view.getMeasuredHeight());
                    }
                }
            }
        }
    }
    public void addBarrageItemView(Context context,String text,int textSize,int textColor){
        createBarrageItemView(context,text,textSize,textColor);
    }
    public void addBarrageItemView(Context context,String text){
        createBarrageItemView(context,text,0,0);
    }
    private void createBarrageItemView(Context context,String text,int textSize,int textColor){
        final TextView textView = new TextView(context);
        textView.setBackgroundResource(R.drawable.barrage_item_bg);
        if (textColor != 0){
            textView.setTextColor(getResources().getColor(textColor));
        }
        if (textSize != 0){
            textView.setTextSize(textSize);
        }
        textView.setText(text);
        int w = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);
        int h = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED);
        textView.measure(w, h);
        int height =textView.getMeasuredHeight();
        int width = textView.getMeasuredWidth();
        int row = new Random().nextInt(100) % mRowNum;
        while (needResetRow(row)){
            row = new Random().nextInt(100) % mRowNum;
        }
        mRowPosList.add(row);
        RelativeLayout.LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT,LayoutParams.WRAP_CONTENT);
        lp.topMargin = row * (height + ToolUtils.dip2px(context,10));
//        lastRow = row;
        textView.setLayoutParams(lp);
        textView.setPadding(ToolUtils.dip2px(context,15), ToolUtils.dip2px(context,2), ToolUtils.dip2px(context,15), ToolUtils.dip2px(context,2));
        textView.getBackground().setAlpha(mAlpha);
        this.addView(textView);
        ViewPropertyAnimator animator = null;
        if(mDirection == FROM_RIGNG_TO_LEFT){
            animator = textView.animate()
                    .translationXBy(-(mScreenWidth + width + 80));
        }else if(mDirection == FROM_LEFT_TO_RIGHT){
            animator = textView.animate()
                    .translationXBy(mScreenWidth + width + 80);
        }
        animator.setDuration(mDuration);
        animator.setInterpolator(new LinearInterpolator());
        animator.start();
        animator.setListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
            }
            @Override
            public void onAnimationEnd(Animator animation) {
//                mChildView.remove(textView);
                BarrageView.this.removeView(textView);
            }
            @Override
            public void onAnimationCancel(Animator animation) {
            }
            @Override
            public void onAnimationRepeat(Animator animation) {
            }
        });
        mChildView.add(textView);
    }
    public boolean needResetRow(int row){
        int size = mRowPosList.size();
        int sameRowPos =-1;
        for(int i = size; i > 0; i--){
            if (row == mRowPosList.get(i-1)){
                sameRowPos = i-1;
                break;
            }
        }
        if (sameRowPos != -1){
            TextView tv = mChildView.get(sameRowPos);
            if (mScreenWidth -tv.getX() < tv.getWidth()){
                return true;
            }
        }
        return false;
    }
}