Android弹幕实现：基于B站弹幕开源系统（4）-重构



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