精华内容
下载资源
问答
  • Android弹幕功能实现,模仿斗鱼直播的弹幕效果

    万次阅读 多人点赞 2016-10-18 08:01:32
    记得之前有位朋友在我的公众号里问过我,像直播的那种弹幕功能该如何实现?如今直播行业确实是非常火爆啊,大大小小的公司都要涉足一下直播的领域,用斗鱼的话来讲,现在就是千播之战。而弹幕则无疑是直播功能当中...

    转载请注明出处: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弹幕实现:基于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

    展开全文
  • 前端之简易弹幕实现

    千次阅读 2019-08-12 20:57:04
    前端之简易弹幕实现实现效果:实现思路:实现代码 实现效果: 直接体验一下,功能很基础简单 打开网页,直接显示一遍本地存储的弹幕(本地存储的主要用于效果查看,可删); 编辑新的弹幕,点击发送,首先显示...

    前端之简易弹幕实现

    实现效果:

    在这里插入图片描述
    打开网页,直接显示一遍本地存储的弹幕(本地存储的主要用于效果查看,可删);
    编辑新的弹幕,点击发送,首先显示最新弹幕,再依次显示一遍所有弹幕;
    点击清屏,当前显示框div下的所有子元素全部,但已进入发送队列的会继续显示(可认为是bug,但也可以认为不是,毕竟只是清理当前屏幕而已,又不是关闭弹幕 > v <)

    实现思路:

    1. html布局:中间一个div显示框,用于装填弹幕消息;下面两个button,一个用于发送新消息,一个用于清屏。
    2. 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的基础上,我再次对弹幕进行抽象和重构,把弹幕从底向上抽象成不同的层,便于复用。第一步,抽象...
    

    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

    展开全文
  • JS弹幕实现

    2017-10-23 04:10:06
    基于直播平台的流行,利用原生实现一下弹幕效果。 原文链接 实现原理 1、设置展示弹幕元素位置属性为relative2、动态创建弹幕元素,位置属性设置absolute,left为展示宽度3、随机设置弹幕元素top值4、随机产生弹幕...
  • 弹幕实现方法

    千次阅读 2016-10-23 16:38:49
    首先我们来看一下斗鱼上的弹幕效果,如下图所示: 这是一个Dota2游戏直播的界面,我们可以看到,在游戏界面的上方有很多的弹幕,看直播的观众们就是在这里进行讨论的。 那么这样的一个界面该如何...
  • 安卓弹幕实现

    2016-10-20 09:32:02
    安卓的弹幕实现。很久以前用过的双缓存技术。纪念下我的mfc青葱岁月 原文链接 点击打开链接 拷贝黏贴 大家好,感觉好像已经很久没更新博客了。前段时间主要是忙于新书的事情,时间比较紧张。而现在新书已经...
  • JS实现弹幕

    千次阅读 2018-12-29 11:01:18
    JS弹幕实现
  • 基于Android淡入淡出弹幕实现

    千次阅读 2016-05-18 15:31:18
    最近遇到需求,需要在某张用户发表的图片中展示评论,方式是以淡入淡出的弹幕形式。需求为淡入事件t1->淡出t2,所有弹幕依次开始播放,中间一定的时间间隔deltaT。仔细考虑之后,想到以下实现方式,现总结下来并进行...
  • 前段时间做了游戏的相关业务,其中弹幕相关的内容自成一块。弹幕已经不只是最初的视频弹幕了,战火已经烧到了评论区,烧到了手机淘宝的首页搜索结果。作为一种近几年迅速燃起的内容呈现形式,有必要适时引入,对于...
  • 那就是弹幕,现在也越来越多的人喜欢上了弹幕,甚至有人常说,‘正经人谁看视频啊,我是来看弹幕的????’,下面看下它的效果: 相信小伙伴们都看过了,那么它实现的原理是什么呢,那么我们前端怎么用我们web技术...
  • 弹幕效果实现

    千次阅读 2016-08-04 19:08:45
    呜呼哀哉,临睡前看了一个弹幕的效果实现的技术视频,听着很好的,自己在做电商这块也没写过弹幕。今天来到公司趁着闲暇按照人家说的思路写了一下,有用得上的可以看看。 demo地址正文先来看一下最终实现的效果: ...
  • 2 实现思路2.1 服务架构2.2 传输流程3 实现效果3.1 视频展示4 代码实现4.1 项目结构4.2 Java服务端4.2.1 先做一个netty nio的服务端:4.2.2 服务端的具体处理逻辑4.3 网页客户端实现5 小结 基于websocket协议与netty...
  • android实现简单弹幕

    2019-03-26 15:15:03
    android端实现,简单的弹幕功能;可以自定义弹幕的样式和使用逻辑
  • 项目需要实现弹幕,网上参考了各种方法,最后觉得transform+transition实现的效果在移动设备上性能最好,在iphone6和红米4上测试,看不到卡顿的感觉。用jquery的animate动画在移动设备上有明显的卡顿。本文主要介绍...
  • 前端实现直播弹幕

    千次阅读 2019-07-21 17:49:13
    2,建立所需要的dom节点并添加到dom池里面,dom节点总数=轨道数X每条轨道可放置的最大弹幕数,并把建好的dom节点加入到可视区容器里面通过添加class使其定位到可视区外部,并绑定相应的事件进行逻辑处理(注意作用域...
  • 弹幕在直播中是一个比较重要的功能,而开源的B站弹幕可以让我们轻松的实现这个功能。 其实现原理大概就是在页面的上方盖了一层全透明的View,然后再View中添加需要的弹幕效果。 上图: 1、首先,在项目中添加依赖:...
  • android端实现,简单的弹幕功能;可以自定义弹幕的样式和使用逻辑
  • Android - 弹幕实现原理(附Demo源码)

    千次阅读 2018-05-30 15:11:39
    二、弹幕原理的简单解析 1.我们先来做些准备工作。 (1)我们可能会需要一个视频(我在这里找了一个mp4格式的视频,并放在了res/raw目录下面,因为音频和视频文件放在其它目录(例如assets资源目录)下会导致无法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,430
精华内容 1,772
关键字:

弹幕实现逻辑