转载请注明出处：http://blog.csdn.net/sinyu890807/article/details/51933728
 
 
 
本文同步发表于我的微信公众号，扫一扫文章底部的二维码或在微信搜索 郭霖 即可关注，每天都有文章更新。
 
 
大家好，感觉好像已经很久没更新博客了。前段时间主要是忙于新书的事情，时间比较紧张。而现在新书已经完稿，剩下的事情就都是出版社的工作了，那么我又可以抽出时间来写写博客了。
 
记得之前有位朋友在我的公众号里问过我，像直播的那种弹幕功能该如何实现？如今直播行业确实是非常火爆啊，大大小小的公司都要涉足一下直播的领域，用斗鱼的话来讲，现在就是千播之战。而弹幕则无疑是直播功能当中最为重要的一个功能之一，那么今天，我就带着大家一起来实现一个简单的Android端弹幕效果。
 
分析
 
首先我们来看一下斗鱼上的弹幕效果，如下图所示：
 


 

 
这是一个Dota2游戏直播的界面，我们可以看到，在游戏界面的上方有很多的弹幕，看直播的观众们就是在这里进行讨论的。
 
那么这样的一个界面该如何实现呢？其实并不复杂，我们只需要首先在布局中放置一个显示游戏界面的View，然后在游戏界面的上方再覆盖一个显示弹幕的View就可以了。弹幕的View必须要做成完全透明的，这样即使覆盖在游戏界面的上方也不会影响到游戏的正常观看，只有当有人发弹幕消息时，再将消息绘制到弹幕的View上面就可以了。原理示意图如下所示：
 


 

 
但是我们除了要能看到弹幕之外也要能发弹幕才行，因此还要再在弹幕的View上面再覆盖一个操作界面的View，然后我们就可以在操作界面上发弹幕、送礼物等。原理示意图如下所示：
 


 

 
这样我们就把基本的实现原理分析完了，下面就让我们开始一步步实现吧。
 
实现视频播放
 
由于本篇文章的主题是实现弹幕效果，并不涉及直播的任何其他功能，因此这里我们就简单地使用VideoView播放一个本地视频来模拟最底层的游戏界面。
 
首先使用Android Studio新建一个DanmuTest项目，然后修改activity_main.xml中的代码，如下所示：
 
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#000">

    <VideoView
        android:id="@+id/video_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"/>

</RelativeLayout>
 
布局文件的代码非常简单，只有一个VideoView，我们将它设置为居中显示。 
 然后修改MainActivity中的代码，如下所示：
 
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        VideoView videoView = (VideoView) findViewById(R.id.video_view);
        videoView.setVideoPath(Environment.getExternalStorageDirectory() + "/Pixels.mp4");
        videoView.start();
    }


    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if (hasFocus && Build.VERSION.SDK_INT >= 19) {
            View decorView = getWindow().getDecorView();
            decorView.setSystemUiVisibility(
                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                            | View.SYSTEM_UI_FLAG_FULLSCREEN
                            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
        }
    }

}
 
上面的代码中使用了VideoView的最基本用法。在onCreate()方法中获取到了VideoView的实例，给它设置了一个视频文件的地址，然后调用start()方法开始播放。当然，我事先已经在SD的根目录中准备了一个叫Pixels.mp4的视频文件。
 
这里使用到了SD卡的功能，但是为了代码简单起见，我并没有加入运行时权限的处理，因此一定要记得将你的项目的targetSdkVersion指定成23以下。
 
另外，为了让视频播放可以有最好的体验效果，这里使用了沉浸式模式的写法。对沉浸式模式还不理解的朋友可以参考我的上一篇文章 Android状态栏微技巧，带你真正理解沉浸式模式 。
 
最后，我们在AndroidManifest.xml中将Activity设置为横屏显示并加入权限声明，如下所示：
 
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.guolin.danmutest">

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity" android:screenOrientation="landscape"
                  android:configChanges="orientation|keyboardHidden|screenLayout|screenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>

</manifest>
 
OK，现在可以运行一下项目了，程序启动之后就会自动开始播放视频，效果如下图所示：
 


 

 
这样我们就把第一步的功能实现了。
 
实现弹幕效果
 
接下来我们开始实现弹幕效果。弹幕其实也就是一个自定义的View，它的上面可以显示类似于跑马灯的文字效果。观众们发表的评论都会在弹幕上显示出来，但又会很快地移出屏幕，既可以起到互动的作用，同时又不会影响视频的正常观看。
 
我们可以自己来编写这样的一个自定义View，当然也可以直接使用网上现成的开源项目。那么为了能够简单快速地实现弹幕效果，这里我就准备直接使用由哔哩哔哩开源的弹幕效果库DanmakuFlameMaster了。
 
DanmakuFlameMaster库的项目主页地址是：https://github.com/Bilibili/DanmakuFlameMaster
 
话说现在使用Android Studio来引入一些开源库真的非常方便，只需要在build.gradle文件里面添加开源库的依赖就可以了。那么我们修改app/build.gradle文件，并在dependencies闭包中添加如下依赖：
 
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:24.2.1'
    testCompile 'junit:junit:4.12'
    compile 'com.github.ctiao:DanmakuFlameMaster:0.5.3'
}
 
这样我们就将DanmakuFlameMaster库引入到当前项目中了。然后修改activity_main.xml中的代码，如下所示：
 
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#000">

    <VideoView
        android:id="@+id/video_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"/>

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

</RelativeLayout>
 
可以看到，这里在RelativeLayout中加入了一个DanmakuView控件，这个控件就是用于显示弹幕信息的了。注意一定要将DanmakuView写在VideoView的下面，因为RelativeLayout中后添加的控件会被覆盖在上面。
 
接下来修改MainActivity中的代码，我们在这里加入弹幕显示的逻辑，如下所示：
 
public class MainActivity extends AppCompatActivity {

    private boolean showDanmaku;

    private DanmakuView danmakuView;

    private DanmakuContext danmakuContext;

    private BaseDanmakuParser parser = new BaseDanmakuParser() {
        @Override
        protected IDanmakus parse() {
            return new Danmakus();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        VideoView videoView = (VideoView) findViewById(R.id.video_view);
        videoView.setVideoPath(Environment.getExternalStorageDirectory() + "/Pixels.mp4");
        videoView.start();
        danmakuView = (DanmakuView) findViewById(R.id.danmaku_view);
        danmakuView.enableDanmakuDrawingCache(true);
        danmakuView.setCallback(new DrawHandler.Callback() {
            @Override
            public void prepared() {
                showDanmaku = true;
                danmakuView.start();
                generateSomeDanmaku();
            }

            @Override
            public void updateTimer(DanmakuTimer timer) {

            }

            @Override
            public void danmakuShown(BaseDanmaku danmaku) {

            }

            @Override
            public void drawingFinished() {

            }
        });
        danmakuContext = DanmakuContext.create();
        danmakuView.prepare(parser, danmakuContext);
    }

    /**
     * 向弹幕View中添加一条弹幕
     * @param content
     *          弹幕的具体内容
     * @param  withBorder
     *          弹幕是否有边框
     */
    private void addDanmaku(String content, boolean withBorder) {
        BaseDanmaku danmaku = danmakuContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
        danmaku.text = content;
        danmaku.padding = 5;
        danmaku.textSize = sp2px(20);
        danmaku.textColor = Color.WHITE;
        danmaku.setTime(danmakuView.getCurrentTime());
        if (withBorder) {
            danmaku.borderColor = Color.GREEN;
        }
        danmakuView.addDanmaku(danmaku);
    }

    /**
     * 随机生成一些弹幕内容以供测试
     */
    private void generateSomeDanmaku() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(showDanmaku) {
                    int time = new Random().nextInt(300);
                    String content = "" + time + time;
                    addDanmaku(content, false);
                    try {
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    /**
     * sp转px的方法。
     */
    public int sp2px(float spValue) {
        final float fontScale = getResources().getDisplayMetrics().scaledDensity;
        return (int) (spValue * fontScale + 0.5f);
    }

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

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

    @Override
    protected void onDestroy() {
        super.onDestroy();
        showDanmaku = false;
        if (danmakuView != null) {
            danmakuView.release();
            danmakuView = null;
        }
    }

    ......

}
 
可以看到，在onCreate()方法中我们先是获取到了DanmakuView控件的实例，然后调用了enableDanmakuDrawingCache()方法来提升绘制效率，又调用了setCallback()方法来设置回调函数。
 
接着调用DanmakuContext.create()方法创建了一个DanmakuContext的实例，DanmakuContext可以用于对弹幕的各种全局配置进行设定，如设置字体、设置最大显示行数等。这里我们并没有什么特殊的要求，因此一切都保持默认。
 
另外我们还需要创建一个弹幕的解析器才行，这里直接创建了一个全局的BaseDanmakuParser。
 
有了DanmakuContext和BaseDanmakuParser，接下来我们就可以调用DanmakuView的prepare()方法来进行准备，准备完成后会自动调用刚才设置的回调函数中的prepared()方法，然后我们在这里再调用DanmakuView的start()方法，这样DanmakuView就可以开始正常工作了。
 
虽说DanmakuView已经在正常工作了，但是屏幕上没有任何弹幕信息的话我们也看不出效果，因此我们还要增加一个添加弹幕消息的功能。
 
观察addDanmaku()方法，这个方法就是用于向DanmakuView中添加一条弹幕消息的。其中首先调用了createDanmaku()方法来创建一个BaseDanmaku实例，TYPE_SCROLL_RL表示这是一条从右向左滚动的弹幕，然后我们就可以对弹幕的内容、字体大小、颜色、显示时间等各种细节进行配置了。注意addDanmaku()方法中有一个withBorder参数，这个参数用于指定弹幕消息是否带有边框，这样才好将自己发送的弹幕和别人发送的弹幕进行区分。
 
这样我们就把最基本的弹幕功能就完成了，现在只需要当在接收到别人发送的弹幕消息时，调用addDanmaku()方法将这条弹幕添加到DanmakuView上就可以了。但接收别人发送来的消息又涉及到了即时通讯技术，显然这一篇文章中不可能将复杂的即时通讯技术也进行讲解，因此这里我专门写了一个generateSomeDanmaku()方法来随机生成一些弹幕消息，这样就可以模拟出和斗鱼类似的弹幕效果了。
 
除此之外，我们还需要在onPause()、onResume()、onDestroy()方法中进行一些逻辑处理，以保证DanmakuView的资源可以得到释放。
 
现在重新运行一下程序，效果如下图所示：
 


 

 
这样我们就把第二步的功能也实现了。
 
加入操作界面
 
那么下面我们开始进行第三步功能实现，加入发送弹幕消息的操作界面。
 
首先修改activity_main.xml中的代码，如下所示：
 
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#000">

    ......

    <LinearLayout
        android:id="@+id/operation_layout"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:layout_alignParentBottom="true"
        android:background="#fff"
        android:visibility="gone">

        <EditText
            android:id="@+id/edit_text"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            />

        <Button
            android:id="@+id/send"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:text="Send" />
    </LinearLayout>

</RelativeLayout>
 
可以看到，这里我们加入了一个LinearLayout来作为操作界面。LinearLayout中并没有什么复杂的控件，只有一个EditText用于输入内容，一个Button用于发送弹幕。注意我们一开始是将LinearLayout隐藏的，因为不能让这个操作界面一直遮挡着VideoView，只有用户想要发弹幕的时候才应该将它显示出来。
 
接下来修改MainActivity中的代码，在这里面加入发送弹幕的逻辑，如下所示：
 
public class MainActivity extends AppCompatActivity {

    ......

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ......
        final  LinearLayout operationLayout = (LinearLayout) findViewById(R.id.operation_layout);
        final Button send = (Button) findViewById(R.id.send);
        final EditText editText = (EditText) findViewById(R.id.edit_text);
        danmakuView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (operationLayout.getVisibility() == View.GONE) {
                    operationLayout.setVisibility(View.VISIBLE);
                } else {
                    operationLayout.setVisibility(View.GONE);
                }
            }
        });
        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                String content = editText.getText().toString();
                if (!TextUtils.isEmpty(content)) {
                    addDanmaku(content, true);
                    editText.setText("");
                }
            }
        });
        getWindow().getDecorView().setOnSystemUiVisibilityChangeListener (new View.OnSystemUiVisibilityChangeListener() {
            @Override
            public void onSystemUiVisibilityChange(int visibility) {
                if (visibility == View.SYSTEM_UI_FLAG_VISIBLE) {
                    onWindowFocusChanged(true);
                }
            }
        });
    }
    ......

}
 
这里的逻辑还是比较简单的，我们先是给DanmakuView设置了一个点击事件，当点击屏幕时就会触发这个点击事件。然后进行判断，如果操作界面是隐藏的就将它显示出来，如果操作界面是显示的就将它隐藏掉，这样就可以简单地通过点击屏幕来实现操作界面的隐藏和显示了。
 
接下来我们又给发送按钮注册了一个点击事件，当点击发送时，获取EditText中的输入内容，然后调用addDanmaku()方法将这条消息添加到DanmakuView上。另外，这条弹幕是由我们自己发送的，因此addDanmaku()方法的第二个参数要传入true。
 
最后，由于系统输入法弹出的时候会导致焦点丢失，从而退出沉浸式模式，因此这里还对系统全局的UI变化进行了监听，保证程序一直可以处于沉浸式模式。
 
这样我们就将所有的代码都完成了，现在可以运行一下看看最终效果了。由于电影播放的同时进行GIF截图生成的文件太大了，无法上传，因此这里我是在电影暂停的情况进行操作的。效果如下图所示：
 


 

 
可以看到，我们自己发送的弹幕是有一个绿色边框包围的，很容易和其他弹幕区分开。
 
这样我们就把第三步的功能也实现了。
 
 
虽说现在我们已经成功实现了非常不错的弹幕效果，但其实这只是DanmakuFlameMaster库提供的最基本的功能而已。哔哩哔哩提供的这个弹幕开源库中拥有极其丰富的功能，包含各种不同的弹幕样式、特效等等。不过本篇文章的主要目标是带大家了解弹幕效果实现的思路，并不是要对DanmakuFlameMaster这个库进行全面的解析。如果你对这个库非常感兴趣，可以到它的github主页上面去学习更多的用法。
 
那么今天的文章到此结束。
 
源码下载，请点击这里
 
 
 
关注我的技术公众号，每天都有优质技术文章推送。关注我的娱乐公众号，工作、学习累了的时候放松一下自己。
 
 
微信扫一扫下方二维码即可关注：
 
 
         
 

 

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

 
前端之简易弹幕实现
 
实现效果：
实现思路：
实现代码

 
实现效果：
 

 打开网页，直接显示一遍本地存储的弹幕（本地存储的主要用于效果查看，可删）；
 编辑新的弹幕，点击发送，首先显示最新弹幕，再依次显示一遍所有弹幕；
 点击清屏，当前显示框div下的所有子元素全部，但已进入发送队列的会继续显示（可认为是bug，但也可以认为不是，毕竟只是清理当前屏幕而已，又不是关闭弹幕 > v <）
 
实现思路：
 
html布局：中间一个div显示框，用于装填弹幕消息；下面两个button，一个用于发送新消息，一个用于清屏。
js逻辑：
 a. 发送按钮事件：获取input输入框中的值val，将其传入senddanmu()方法中，同时将val加入消息list队列。
 b. 清屏按钮事件：获取显示框div，用empty()方法清空其下的所有子元素。
 c. senddanmu(val)方法：
 首先，创建一个新的div标签，将传入的弹幕消息val加入进去，主要设置好标签的position(由于要给div标签添加动画，故只能为absolute或fixed或relative)，top、right或者left(即确定好div的初始位置)。
 然后，将新创建的div标签加入显示框div中。然后通过访问显示框div新加入的子元素获得新创建的div标签，接着对其添加动画效果。
 d. danmu()方法：每间隔一定时间，依次发送消息队列中的消息。可以用setTimeout()或者setInterval()实现时间间隔，由于它们均是异步操作，并且原理各有不同，有坑，仔细~
 e. randomColor()方法：随机生成六位十六进制rgb颜色，用于给弹幕消息设置不同的颜色。
 
实现代码
 
html：
 
<div class="container-fluid" style="display:flex;flex-direction:column;align-items:center;">       
  <div class="screen" style="position:relative;width:80%;height:400px;border:1px solid #999999;margin-top:30px;">
  //插入弹幕消息
  </div>
  <div style="margin-top:20px;">
  	<input type="text" style="width:400px;height:30px;" placeholder='说点什么...'id="something" autocomplete="off">
  </div>
  <div style="margin-top:10px;">
  	<button style="color:orange;font-size:20px;margin-right:20px;" onClick="saySomething()">发射</button>
	<button style="color:purple;font-size:20px;margin-left:20px" onClick="doClear()">清屏</button>
  </div>
</div>
 
js：
 
var t=0;
var list=['1','2','3','4','5','6','7','8'];
var diff=40;  //相邻弹幕高度差
var _height=10;  //弹幕初始高度
function saySomething(){    //发送button的绑定事件
  var something = document.getElementById("something").value;
  document.getElementById("something").value = "";
  list.push("'"+something+"'");
  senddanmu(something);
  setTimeout("danmu()",1000);
}

function doClear(){       //清屏button的绑定事件
  console.log("clear");
  $(".screen").empty();
}

$(document).ready(function(){
  danmu();//发默认弹幕
});

function senddanmu(val){     //发送单条弹幕
  var item_t = "<div style='position:absolute;color:"+randomColor()+";right:0px;top:"+_height+"px;'>"+val+"</div>";
      $(".screen").append($(item_t));
      var item = $(".screen").children()[$(".screen").children().length - 1];
      $(item).animate({left:'10px'},10000,function(){
        $(this).remove();
      });
      //console.log(item);
      _height = _height + diff;
      // console.log($(".screen").height());
      // console.log(_height);
      if(_height > $(".screen").height()){
        _height = 20;
      } 
}
function danmu(){     //发送弹幕列表list
  //使用setTimeout实现时间间隔
  if(list){
    for(var i = 0; i<list.length;i++){
      console.log(list.length);
      t = setTimeout("senddanmu("+list[i]+")",i*1000);
    } 
  }
  //使用setInterval实现时间间隔
  // var i = 0;
  // t = setInterval(function(){
  //   senddanmu(list[i]);
  //   i++;
  //   if(i > list.length - 1){
  //     clearInterval(t);
  //   }
  // },2000);
}

function randomColor(){      //随机生产字体颜色
  var color='#';
  for(var i = 0;i<6;i++){
    var temp = Math.floor(Math.random()*15)+1;
    color = color+ temp.toString(16);
  }
  // console.log(color);
  return color;
}

 

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