android.graphics.Paint.FontMetrics#master.flame.danmaku.danmaku.model.BaseDanmaku源码实例Demo

private void addDanmaku(String content, boolean withBorder) {
    if(danmakuView == null){
        return;
    }
    BaseDanmaku danmaku = danmakuContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
    if(content.length() > 7) {
        danmaku = danmakuContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_FIX_TOP);
    }
    danmaku.text = content;
    danmaku.padding = 5;
    danmaku.textSize = sp2px(14);
    danmaku.textColor = Color.WHITE;
    danmaku.textShadowColor = Color.BLACK;
    danmaku.setTime(danmakuView.getCurrentTime());
    if (withBorder) {
        danmaku.borderColor = Color.GREEN;
    }
    danmakuView.addDanmaku(danmaku);
}
 

private void addDanmaku(boolean islive) {
    BaseDanmaku danmaku = DanmakuConfig.getDefaultContext().mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
    if (danmaku == null || danmakuControl == null) {
        return;
    }
    // for(int i=0;i<100;i++){
    // }
    danmaku.text = "QSVideoPlayer-" + System.nanoTime();
    danmaku.padding = 5;
    danmaku.priority = 10;  // 可能会被各种过滤器过滤并隐藏显示
    danmaku.isLive = islive;
    danmaku.setTime(demoVideoView.getPosition() + 1200);
    danmaku.textSize = 40;
    danmaku.textColor = Color.RED;
    danmaku.textShadowColor = Color.WHITE;
    // danmaku.underlineColor = Color.GREEN;
    danmaku.borderColor = Color.GREEN;
    danmakuControl.add(danmaku);

}
 

/**
 模拟添加弹幕数据
 */
private void addDanmaku(boolean islive) {
    BaseDanmaku danmaku = mDanmakuContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
    if (danmaku == null || mDanmakuView == null) {
        return;
    }
    danmaku.text = "这是一条弹幕 " + getCurrentPositionWhenPlaying();
    danmaku.padding = 5;
    danmaku.priority = 8;  // 可能会被各种过滤器过滤并隐藏显示，所以提高等级
    danmaku.isLive = islive;
    danmaku.setTime(mDanmakuView.getCurrentTime() + 500);
    danmaku.textSize = 25f * (mParser.getDisplayer().getDensity() - 0.6f);
    danmaku.textColor = Color.RED;
    danmaku.textShadowColor = Color.WHITE;
    danmaku.borderColor = Color.GREEN;
    mDanmakuView.addDanmaku(danmaku);

}
 

public static DanmakuContext getDefaultContext() {
        if (danmakuContext != null)
            return danmakuContext;

        // 设置最大显示行数
        HashMap<Integer, Integer> maxLinesPair = new HashMap<>();
        maxLinesPair.put(BaseDanmaku.TYPE_SCROLL_RL, 5); // 滚动弹幕最大显示5行
        // 设置是否禁止重叠
        HashMap<Integer, Boolean> overlappingEnablePair = new HashMap<>();
        overlappingEnablePair.put(BaseDanmaku.TYPE_SCROLL_RL, true);
        overlappingEnablePair.put(BaseDanmaku.TYPE_FIX_TOP, true);
        danmakuContext = DanmakuContext.create();
        danmakuContext.setDanmakuStyle(IDisplayer.DANMAKU_STYLE_STROKEN, 3)
                .setDuplicateMergingEnabled(false)
                .setScrollSpeedFactor(1.2f).setScaleTextSize(1.2f)
//                .setCacheStuffer(new SpannedCacheStuffer(), mCacheStufferAdapter) // 图文混排使用SpannedCacheStuffer
//        .setCacheStuffer(new BackgroundCacheStuffer())  // 绘制背景使用BackgroundCacheStuffer
                .setMaximumLines(maxLinesPair)
                .preventOverlapping(overlappingEnablePair)
                .setDanmakuMargin(40);
        return danmakuContext;
    }
 

public boolean onTouchEvent(MotionEvent event) {
    switch (event.getAction()) {
        case 1:
            IDanmakus clickDanmakus = touchHitDanmaku(event.getX(), event.getY());
            BaseDanmaku newestDanmaku = null;
            if (!(clickDanmakus == null || clickDanmakus.isEmpty())) {
                performClick(clickDanmakus);
                newestDanmaku = fetchLatestOne(clickDanmakus);
            }
            if (newestDanmaku != null) {
                performClickWithlatest(newestDanmaku);
                break;
            }
            break;
    }
    return false;
}
 

private void removeTimeoutDanmakus(LinkedHashMap<String, BaseDanmaku> danmakus, int limitTime) {
    Iterator<Entry<String, BaseDanmaku>> it = danmakus.entrySet().iterator();
    long startTime = SystemClock.uptimeMillis();
    while (it.hasNext()) {
        try {
            if (((BaseDanmaku) ((Entry) it.next()).getValue()).isTimeOut()) {
                it.remove();
                if (SystemClock.uptimeMillis() - startTime > ((long) limitTime)) {
                    return;
                }
            }
            return;
        } catch (Exception e) {
            return;
        }
    }
}
 

public synchronized boolean needFilter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask) {
    boolean z = true;
    synchronized (this) {
        removeTimeoutDanmakus(this.blockedDanmakus, 2);
        removeTimeoutDanmakus(this.passedDanmakus, 2);
        removeTimeoutDanmakus(this.currentDanmakus, 3);
        if (!this.blockedDanmakus.contains(danmaku) || danmaku.isOutside()) {
            if (this.passedDanmakus.contains(danmaku)) {
                z = false;
            } else if (this.currentDanmakus.containsKey(danmaku.text)) {
                this.currentDanmakus.put(String.valueOf(danmaku.text), danmaku);
                this.blockedDanmakus.removeItem(danmaku);
                this.blockedDanmakus.addItem(danmaku);
            } else {
                this.currentDanmakus.put(String.valueOf(danmaku.text), danmaku);
                this.passedDanmakus.addItem(danmaku);
                z = false;
            }
        }
    }
    return z;
}
 

public void measure(BaseDanmaku danmaku, TextPaint paint, boolean fromWorkerThread) {
    if (this.mProxy != null) {
        this.mProxy.prepareDrawing(danmaku, fromWorkerThread);
    }
    float w = 0.0f;
    Float textHeight = Float.valueOf(0.0f);
    if (danmaku.lines == null) {
        if (danmaku.text == null) {
            w = 0.0f;
        } else {
            w = paint.measureText(danmaku.text.toString());
            textHeight = getCacheHeight(danmaku, paint);
        }
        danmaku.paintWidth = w;
        danmaku.paintHeight = textHeight.floatValue();
        return;
    }
    textHeight = getCacheHeight(danmaku, paint);
    for (String tempStr : danmaku.lines) {
        if (tempStr.length() > 0) {
            w = Math.max(paint.measureText(tempStr), w);
        }
    }
    danmaku.paintWidth = w;
    danmaku.paintHeight = ((float) danmaku.lines.length) * textHeight.floatValue();
}
 

private boolean needFilter(BaseDanmaku danmaku, int orderInScreen, int totalSizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext context) {
    Log.v("XX", "QuantityDanmakuFilter needFilter mMaximumSize : " + this.mMaximumSize + " totalSizeInScreen : " + totalSizeInScreen + " orderInScreen : " + orderInScreen + " danmaku.isTimeOut() " + danmaku.isTimeOut() + " mMaximumSize : " + this.mMaximumSize + " isShown :" + danmaku.isShown());
    if (this.mMaximumSize == 0) {
        return true;
    }
    if (totalSizeInScreen < this.mMaximumSize || (this.mLastSkipped != null && danmaku.time - this.mLastSkipped.time > context.mDanmakuFactory.MAX_DANMAKU_DURATION / 4)) {
        Log.v("xx", " QuantityDanmakuFilter not guolv2222 >>>>>>>>");
        this.mLastSkipped = danmaku;
        return false;
    } else if (orderInScreen <= this.mMaximumSize || danmaku.isTimeOut()) {
        this.mLastSkipped = danmaku;
        Log.v("xx", " QuantityDanmakuFilter not guolv11111 >>>>>>>>");
        return false;
    } else {
        Log.v("xx", " QuantityDanmakuFilter guolv >>>>>>>>");
        return true;
    }
}
 

private Collection<BaseDanmaku> subset(long startTime, long endTime) {
    if (this.mSortType == 4 || this.items == null || this.items.size() == 0) {
        return null;
    }
    if (this.subItems == null) {
        this.subItems = new Danmakus(this.mDuplicateMergingEnabled);
    }
    if (this.startSubItem == null) {
        this.startSubItem = createItem(JarConstant.PLUGIN_WINDOW_PLAYER_STATIC_METHOD_NAME_START);
    }
    if (this.endSubItem == null) {
        this.endSubItem = createItem("end");
    }
    this.startSubItem.time = startTime;
    this.endSubItem.time = endTime;
    return ((SortedSet) this.items).subSet(this.startSubItem, this.endSubItem);
}
 

public boolean createCache(BaseDanmaku item) {
    if (!item.isMeasured()) {
        item.measure(CacheManagingDrawTask.this.mDisp, true);
    }
    DrawingCache cache = null;
    try {
        cache = DanmakuUtils.buildDanmakuDrawingCache(item, CacheManagingDrawTask.this.mDisp, (DrawingCache) CacheManager.this.mCachePool.acquire());
        item.cache = cache;
        return true;
    } catch (OutOfMemoryError e) {
        if (cache != null) {
            CacheManager.this.mCachePool.release(cache);
        }
        item.cache = null;
        return false;
    } catch (Exception e2) {
        if (cache != null) {
            CacheManager.this.mCachePool.release(cache);
        }
        item.cache = null;
        return false;
    }
}
 

private void clearTimeOutCaches(long time) {
    IDanmakuIterator it = this.mCaches.iterator();
    while (it.hasNext() && !this.mEndFlag) {
        BaseDanmaku val = it.next();
        if (val.isTimeOut()) {
            synchronized (CacheManagingDrawTask.this.mDrawingNotify) {
                try {
                    CacheManagingDrawTask.this.mDrawingNotify.wait(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                }
            }
            entryRemoved(false, val, null);
            it.remove();
        } else {
            return;
        }
    }
}
 

private void applyPaintConfig(BaseDanmaku danmaku, Paint paint, boolean stroke) {
    if (this.isTranslucent) {
        if (stroke) {
            paint.setStyle(this.HAS_PROJECTION ? Style.FILL : Style.STROKE);
            paint.setColor(danmaku.textShadowColor & ViewCompat.MEASURED_SIZE_MASK);
            paint.setAlpha(this.HAS_PROJECTION ? (int) (((float) this.sProjectionAlpha) * (((float) this.transparency) / ((float) AlphaValue.MAX))) : this.transparency);
            return;
        }
        paint.setStyle(Style.FILL);
        paint.setColor(danmaku.textColor & ViewCompat.MEASURED_SIZE_MASK);
        paint.setAlpha(this.transparency);
    } else if (stroke) {
        paint.setStyle(this.HAS_PROJECTION ? Style.FILL : Style.STROKE);
        paint.setColor(danmaku.textShadowColor & ViewCompat.MEASURED_SIZE_MASK);
        paint.setAlpha(this.HAS_PROJECTION ? this.sProjectionAlpha : AlphaValue.MAX);
    } else {
        paint.setStyle(Style.FILL);
        paint.setColor(danmaku.textColor & ViewCompat.MEASURED_SIZE_MASK);
        paint.setAlpha(AlphaValue.MAX);
    }
}
 

public BaseDanmaku createDanmaku(int type, float viewportWidth, float viewportHeight, float viewportSizeFactor, float scrollSpeedFactor) {
    boolean sizeChanged = updateViewportState(viewportWidth, viewportHeight, viewportSizeFactor);
    if (this.MAX_Duration_Scroll_Danmaku == null) {
        this.MAX_Duration_Scroll_Danmaku = new Duration(this.REAL_DANMAKU_DURATION);
        this.MAX_Duration_Scroll_Danmaku.setFactor(scrollSpeedFactor);
    } else if (sizeChanged) {
        this.MAX_Duration_Scroll_Danmaku.setValue(this.REAL_DANMAKU_DURATION);
    }
    if (this.MAX_Duration_Fix_Danmaku == null) {
        this.MAX_Duration_Fix_Danmaku = new Duration(COMMON_DANMAKU_DURATION);
    }
    if (sizeChanged && viewportWidth > 0.0f) {
        updateMaxDanmakuDuration();
        float scaleX = 1.0f;
        float scaleY = 1.0f;
        if (this.CURRENT_DISP_WIDTH > 0 && this.CURRENT_DISP_HEIGHT > 0) {
            scaleX = viewportWidth / ((float) this.CURRENT_DISP_WIDTH);
            scaleY = viewportHeight / ((float) this.CURRENT_DISP_HEIGHT);
        }
        if (viewportHeight > 0.0f) {
            updateSpecialDanmakusDate(scaleX, scaleY);
        }
    }
    switch (type) {
        case 1:
            return new R2LDanmaku(this.MAX_Duration_Scroll_Danmaku);
        case 4:
            return new FBDanmaku(this.MAX_Duration_Fix_Danmaku);
        case 5:
            return new FTDanmaku(this.MAX_Duration_Fix_Danmaku);
        case 6:
            return new L2RDanmaku(this.MAX_Duration_Scroll_Danmaku);
        case 7:
            BaseDanmaku instance = new SpecialDanmaku();
            this.sSpecialDanmakus.addItem(instance);
            return instance;
        default:
            return null;
    }
}
 

/**
     * 发送自定义弹幕
     */
    public void addDanmakuWithDrawable() {
        mContext.setCacheStuffer(new BackgroundCacheStuffer(), null);
        BaseDanmaku danmaku = mContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
        if (danmaku == null || mDanmakuView == null) {
            return;
        }
        // for(int i=0;i<100;i++){
        // }
        Drawable drawable = ContextCompat.getDrawable(getContext(), R.mipmap.ic_launcher_round);
        int size = PlayerUtils.dp2px(getContext(), 20);
        drawable.setBounds(0, 0, size, size);

//        danmaku.text = "这是一条弹幕";
        danmaku.text = createSpannable(drawable);
//        danmaku.padding = 5;
        danmaku.priority = 0;  // 可能会被各种过滤器过滤并隐藏显示
        danmaku.isLive = false;
        danmaku.setTime(mDanmakuView.getCurrentTime() + 1200);
        danmaku.textSize = PlayerUtils.sp2px(getContext(), 12);
        danmaku.textColor = Color.RED;
        danmaku.textShadowColor = Color.WHITE;
        // danmaku.underlineColor = Color.GREEN;
//        danmaku.borderColor = Color.GREEN;
        mDanmakuView.addDanmaku(danmaku);

    }
 

@Override
public void drawBackground(BaseDanmaku danmaku, Canvas canvas, float left, float top) {
    paint.setAntiAlias(true);
    paint.setColor(Color.parseColor("#65777777"));//黑色 普通
    int radius = PlayerUtils.dp2px(getContext(), 10);
    canvas.drawRoundRect(new RectF(left, top, left + danmaku.paintWidth, top + danmaku.paintHeight), radius, radius, paint);
}
 

/**
     * 发送自定义弹幕
     */
    public void addDanmakuWithDrawable() {
        mContext.setCacheStuffer(new BackgroundCacheStuffer(), null);
        BaseDanmaku danmaku = mContext.mDanmakuFactory.createDanmaku(BaseDanmaku.TYPE_SCROLL_RL);
        if (danmaku == null) {
            return;
        }
        // for(int i=0;i<100;i++){
        // }
        Drawable drawable = ContextCompat.getDrawable(getContext(), R.mipmap.ic_launcher_round);
        int size = PlayerUtils.dp2px(getContext(), 20);
        drawable.setBounds(0, 0, size, size);

//        danmaku.text = "这是一条弹幕";
        danmaku.text = createSpannable(drawable);
//        danmaku.padding = 5;
        danmaku.priority = 0;  // 可能会被各种过滤器过滤并隐藏显示
        danmaku.isLive = false;
        danmaku.setTime(getCurrentTime() + 1200);
        danmaku.textSize = PlayerUtils.sp2px(getContext(), 12);
        danmaku.textColor = Color.RED;
        danmaku.textShadowColor = Color.WHITE;
        // danmaku.underlineColor = Color.GREEN;
//        danmaku.borderColor = Color.GREEN;
        addDanmaku(danmaku);

    }
 

public BaseDanmaku createDanmaku(int type, IDisplayer disp, float viewportScale, float scrollSpeedFactor) {
    if (disp == null) {
        return null;
    }
    this.sLastDisp = disp;
    return createDanmaku(type, disp.getWidth(), disp.getHeight(), viewportScale, scrollSpeedFactor);
}
 

private int saveCanvas(BaseDanmaku danmaku, Canvas canvas, float left, float top) {
    this.camera.save();
    this.camera.rotateY(-danmaku.rotationY);
    this.camera.rotateZ(-danmaku.rotationZ);
    this.camera.getMatrix(this.matrix);
    this.matrix.preTranslate(-left, -top);
    this.matrix.postTranslate(left, top);
    this.camera.restore();
    int count = canvas.save();
    canvas.concat(this.matrix);
    return count;
}
 

public static void fillLinePathData(BaseDanmaku item, float[][] points, float scaleX, float scaleY) {
    if (item.getType() == 7 && points.length != 0 && points[0].length == 2) {
        for (int i = 0; i < points.length; i++) {
            float[] fArr = points[i];
            fArr[0] = fArr[0] * scaleX;
            fArr = points[i];
            fArr[1] = fArr[1] * scaleY;
        }
        ((SpecialDanmaku) item).setLinePathData(points);
    }
}
 

public void addDanmaku(BaseDanmaku item) {
    if (this.drawTask != null) {
        item.flags = this.mContext.mGlobalFlagValues;
        item.setTimer(this.timer);
        this.drawTask.addDanmaku(item);
        obtainMessage(11).sendToTarget();
    }
}
 

public BaseDanmaku createDanmaku(int type, DanmakuContext context) {
    if (context == null) {
        return null;
    }
    this.sLastConfig = context;
    this.sLastDisp = context.getDisplayer();
    return createDanmaku(type, this.sLastDisp.getWidth(), this.sLastDisp.getHeight(), this.CURRENT_DISP_SIZE_FACTOR, context.scrollSpeedFactor);
}
 

public DrawTask(DanmakuTimer timer, DanmakuContext context, TaskListener taskListener) {
    boolean z = false;
    if (context == null) {
        throw new IllegalArgumentException("context is null");
    }
    this.mContext = context;
    this.mDisp = context.getDisplayer();
    this.mTaskListener = taskListener;
    this.mRenderer = new DanmakuRenderer(context);
    this.mRenderer.setOnDanmakuShownListener(new OnDanmakuShownListener() {
        public void onDanmakuShown(BaseDanmaku danmaku) {
            if (DrawTask.this.mTaskListener != null) {
                DrawTask.this.mTaskListener.onDanmakuShown(danmaku);
            }
        }
    });
    IRenderer iRenderer = this.mRenderer;
    if (this.mContext.isPreventOverlappingEnabled() || this.mContext.isMaxLinesLimited()) {
        z = true;
    }
    iRenderer.setVerifierEnabled(z);
    initTimer(timer);
    Boolean enable = Boolean.valueOf(this.mContext.isDuplicateMergingEnabled());
    if (enable == null) {
        return;
    }
    if (enable.booleanValue()) {
        this.mContext.mDanmakuFilters.registerFilter(DanmakuFilters.TAG_DUPLICATE_FILTER);
    } else {
        this.mContext.mDanmakuFilters.unregisterFilter(DanmakuFilters.TAG_DUPLICATE_FILTER);
    }
}
 

public synchronized void addDanmaku(BaseDanmaku item) {
    if (this.danmakuList != null) {
        boolean added;
        if (item.isLive) {
            removeUnusedLiveDanmakusIn(10);
        }
        item.index = this.danmakuList.size();
        if (this.mLastBeginMills <= item.time && item.time <= this.mLastEndMills) {
            synchronized (this.danmakus) {
                added = this.danmakus.addItem(item);
            }
        } else if (item.isLive) {
            this.mLastEndMills = 0;
            this.mLastBeginMills = 0;
        }
        synchronized (this.danmakuList) {
            added = this.danmakuList.addItem(item);
        }
        if (added) {
            if (this.mTaskListener != null) {
                this.mTaskListener.onDanmakuAdd(item);
            }
        }
        if (this.mLastDanmaku == null || !(item == null || this.mLastDanmaku == null || item.time <= this.mLastDanmaku.time)) {
            this.mLastDanmaku = item;
        }
    }
}
 

public void invalidateDanmaku(BaseDanmaku item, boolean remeasure) {
    this.mContext.getDisplayer().getCacheStuffer().clearCache(item);
    if (remeasure) {
        item.paintWidth = -1.0f;
        item.paintHeight = -1.0f;
    }
}
 

public synchronized void removeAllLiveDanmakus() {
    if (!(this.danmakus == null || this.danmakus.isEmpty())) {
        synchronized (this.danmakus) {
            IDanmakuIterator it = this.danmakus.iterator();
            while (it.hasNext()) {
                BaseDanmaku danmaku = it.next();
                if (danmaku.isLive) {
                    it.remove();
                    onDanmakuRemoved(danmaku);
                }
            }
        }
    }
}
 

private void applyTextScaleConfig(BaseDanmaku danmaku, Paint paint) {
    if (this.isTextScaled) {
        Float size = (Float) this.sCachedScaleSize.get(Float.valueOf(danmaku.textSize));
        if (size == null || this.sLastScaleTextSize != this.scaleTextSize) {
            this.sLastScaleTextSize = this.scaleTextSize;
            size = Float.valueOf(danmaku.textSize * this.scaleTextSize);
            this.sCachedScaleSize.put(Float.valueOf(danmaku.textSize), size);
        }
        paint.setTextSize(size.floatValue());
    }
}
 

public IDanmakus getVisibleDanmakusOnTime(long time) {
    IDanmakus subDanmakus = this.danmakuList.subnew((time - this.mContext.mDanmakuFactory.MAX_DANMAKU_DURATION) - 100, time + this.mContext.mDanmakuFactory.MAX_DANMAKU_DURATION);
    IDanmakus visibleDanmakus = new Danmakus();
    if (!(subDanmakus == null || subDanmakus.isEmpty())) {
        IDanmakuIterator iterator = subDanmakus.iterator();
        while (iterator.hasNext()) {
            BaseDanmaku danmaku = iterator.next();
            if (danmaku.isShown() && !danmaku.isOutside()) {
                visibleDanmakus.addItem(danmaku);
            }
        }
    }
    return visibleDanmakus;
}
 

public BaseDanmaku last() {
    if (this.items == null || this.items.isEmpty()) {
        return null;
    }
    if (this.mSortType == 4) {
        return (BaseDanmaku) ((ArrayList) this.items).get(this.items.size() - 1);
    }
    return (BaseDanmaku) ((SortedSet) this.items).last();
}
 

public static DrawingCache buildDanmakuDrawingCache(BaseDanmaku danmaku, IDisplayer disp, DrawingCache cache) {
    if (cache == null) {
        cache = new DrawingCache();
    }
    cache.build((int) Math.ceil((double) danmaku.paintWidth), (int) Math.ceil((double) danmaku.paintHeight), disp.getDensityDpi(), false);
    DrawingCacheHolder holder = cache.get();
    if (holder != null) {
        ((AbsDisplayer) disp).drawDanmaku(danmaku, holder.canvas, 0.0f, 0.0f, true);
        if (disp.isHardwareAccelerated()) {
            holder.splitWith(disp.getWidth(), disp.getHeight(), disp.getMaximumCacheWidth(), disp.getMaximumCacheHeight());
        }
    }
    return cache;
}