master.flame.danmaku.danmaku.model.DanmakuTimer Java Examples

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;
}
 

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;
    }
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean willHit, DanmakuContext config) {
    boolean filtered = false;
    if (this.mEnabledPairs != null) {
        Boolean enabledValue = (Boolean) this.mEnabledPairs.get(Integer.valueOf(danmaku.getType()));
        filtered = enabledValue != null && enabledValue.booleanValue() && willHit;
        if (filtered) {
            danmaku.mFilterParam |= 512;
        }
    }
    return filtered;
}
 

private void danmuku(InputStream inputStream) {
        if (mDanmakuView != null) {
            mParser = DanmakuHelper.createParser(inputStream);
            mDanmakuView.setCallback(new DrawHandler.Callback() {
                @Override
                public void updateTimer(DanmakuTimer timer) {
                }

                @Override
                public void danmakuShown(BaseDanmaku danmaku) {

                }

                @Override
                public void drawingFinished() {

                }

                @Override
                public void prepared() {
                    mIsDanmakuReday = true;
                }
            });
            mDanmakuView.setOnDanmakuClickListener(new IDanmakuView.OnDanmakuClickListener() {
                @Override
                public void onDanmakuClick(BaseDanmaku latest) {
//                    Log.d("DFM", "onDanmakuClick text:" + latest.text);
                }

                @Override
                public void onDanmakuClick(IDanmakus danmakus) {
//                    Log.d("DFM", "onDanmakuClick danmakus size:" + danmakus.size());
                }
            });
            mDanmakuView.prepare(mParser, mDanmakuContext);
            mDanmakuView.enableDanmakuDrawingCache(true);
//            mDanmakuView.showFPS(true);
        }
    }
 

public CacheManagingDrawTask(DanmakuTimer timer, DanmakuContext config, TaskListener taskListener, int maxCacheSize) {
    super(timer, config, taskListener);
    NativeBitmapFactory.loadLibs();
    this.mMaxCacheSize = maxCacheSize;
    if (NativeBitmapFactory.isInNativeAlloc()) {
        this.mMaxCacheSize = maxCacheSize * 2;
    }
    this.mCacheManager = new CacheManager(maxCacheSize, 3);
    this.mRenderer.setCacheManager(this.mCacheManager);
}
 

public boolean filterSecondary(BaseDanmaku danmaku, int lines, int totalsizeInScreen, DanmakuTimer timer, boolean willHit, DanmakuContext context) {
    for (IDanmakuFilter<?> f : this.mFilterArraySecondary) {
        if (f != null) {
            boolean filtered = f.filter(danmaku, lines, totalsizeInScreen, timer, willHit, context);
            danmaku.filterResetFlag = context.mGlobalFlagValues.FILTER_RESET_FLAG;
            if (filtered) {
                return true;
            }
        }
    }
    return false;
}
 

public void filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext context) {
    for (IDanmakuFilter<?> f : this.mFilterArray) {
        if (f != null) {
            boolean filtered = f.filter(danmaku, index, totalsizeInScreen, timer, fromCachingTask, context);
            danmaku.filterResetFlag = context.mGlobalFlagValues.FILTER_RESET_FLAG;
            if (filtered) {
                return;
            }
        }
    }
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = danmaku != null && this.mBlackList.contains(Integer.valueOf(danmaku.userId));
    if (filtered) {
        danmaku.mFilterParam |= 16;
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = danmaku != null && this.mBlackList.contains(danmaku.userHash);
    if (filtered) {
        danmaku.mFilterParam |= 32;
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int orderInScreen, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = danmaku != null && this.mFilterTypes.contains(Integer.valueOf(danmaku.getType()));
    if (filtered) {
        danmaku.mFilterParam |= 1;
        danmaku.isDanmakuTypeFiltered = true;
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = (danmaku == null || this.mWhiteList.contains(Integer.valueOf(danmaku.textColor))) ? false : true;
    if (filtered) {
        danmaku.mFilterParam |= 8;
    }
    return filtered;
}
 

public synchronized boolean filter(BaseDanmaku danmaku, int orderInScreen, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered;
    filtered = needFilter(danmaku, orderInScreen, totalsizeInScreen, timer, fromCachingTask, config);
    if (filtered) {
        danmaku.mFilterParam |= 2;
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int lines, int totalsizeInScreen, DanmakuTimer timer, boolean willHit, DanmakuContext config) {
    boolean filtered = false;
    if (this.mMaximumLinesPairs != null) {
        Integer maxLines = (Integer) this.mMaximumLinesPairs.get(Integer.valueOf(danmaku.getType()));
        filtered = maxLines != null && lines >= maxLines.intValue();
        if (filtered) {
            danmaku.mFilterParam |= 256;
        }
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = this.mBlock.booleanValue() && danmaku.isGuest;
    if (filtered) {
        danmaku.mFilterParam |= 64;
    }
    return filtered;
}
 

public boolean filter(BaseDanmaku danmaku, int orderInScreen, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = needFilter(danmaku, orderInScreen, totalsizeInScreen, timer, fromCachingTask);
    if (filtered) {
        danmaku.mFilterParam |= 4;
    }
    return filtered;
}
 

private synchronized boolean needFilter(BaseDanmaku danmaku, int orderInScreen, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask) {
    boolean z = false;
    synchronized (this) {
        if (timer != null) {
            if (danmaku.isOutside()) {
                if (SystemClock.uptimeMillis() - timer.currMillisecond >= this.mMaxTime) {
                    z = true;
                }
            }
        }
    }
    return z;
}
 

public boolean filter(BaseDanmaku danmaku, int index, int totalsizeInScreen, DanmakuTimer timer, boolean fromCachingTask, DanmakuContext config) {
    boolean filtered = needFilter(danmaku, index, totalsizeInScreen, timer, fromCachingTask);
    if (filtered) {
        danmaku.mFilterParam |= 128;
    }
    return filtered;
}
 

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);
    }
}
 

private IDrawTask createDrawTask(boolean useDrwaingCache, DanmakuTimer timer, Context context, int width, int height, boolean isHardwareAccelerated, TaskListener taskListener) {
    this.mDisp = this.mContext.getDisplayer();
    this.mDisp.setSize(width, height);
    DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
    this.mDisp.setDensities(displayMetrics.density, displayMetrics.densityDpi, displayMetrics.scaledDensity);
    this.mDisp.resetSlopPixel(this.mContext.scaleTextSize);
    this.mDisp.setHardwareAccelerated(isHardwareAccelerated);
    IDrawTask task = useDrwaingCache ? new CacheManagingDrawTask(timer, this.mContext, taskListener, (1048576 * AndroidUtils.getMemoryClass(context)) / 3) : new DrawTask(timer, this.mContext, taskListener);
    task.setParser(this.mParser);
    task.prepare();
    obtainMessage(10, Boolean.valueOf(false)).sendToTarget();
    return task;
}
 

/**
 * danmuku init
 */
public void initDanMuKu(){
    //弹幕
    // 设置最大显示行数
    HashMap<Integer, Integer> maxLinesPair = new HashMap<Integer, Integer>();
    maxLinesPair.put(BaseDanmaku.TYPE_SCROLL_RL, 10); // 滚动弹幕最大显示10行
    // 设置是否禁止重叠
    HashMap<Integer, Boolean> overlappingEnablePair = new HashMap<Integer, Boolean>();
    overlappingEnablePair.put(BaseDanmaku.TYPE_SCROLL_RL, true);
    overlappingEnablePair.put(BaseDanmaku.TYPE_FIX_TOP, true);

    danmakuContext = DanmakuContext.create();
    danmakuContext.setDanmakuStyle(IDisplayer.DANMAKU_STYLE_STROKEN, 5).setDuplicateMergingEnabled(false)
            .setMaximumLines(maxLinesPair)
            .preventOverlapping(overlappingEnablePair).setDanmakuMargin(20);
    danmakuView = findViewById(R.id.danmaku_view);
    danmakuView.enableDanmakuDrawingCache(true);
    danmakuView.setCallback(new DrawHandler.Callback() {
        @Override
        public void prepared() {
            showDanmaku = true;
            danmakuView.start();
        }

        @Override
        public void updateTimer(DanmakuTimer timer) {

        }

        @Override
        public void danmakuShown(BaseDanmaku danmaku) {

        }

        @Override
        public void drawingFinished() {

        }
    });
    danmakuView.prepare(parser, danmakuContext);
}
 

protected RenderingState drawDanmakus(AbsDisplayer disp, DanmakuTimer timer) {
    if (this.clearRetainerFlag) {
        this.mRenderer.clearRetainer();
        this.clearRetainerFlag = false;
    }
    if (this.danmakuList == null) {
        return null;
    }
    DrawHelper.clearCanvas((Canvas) disp.getExtraData());
    if (this.mIsHidden) {
        return this.mRenderingState;
    }
    long beginMills = (timer.currMillisecond - this.mContext.mDanmakuFactory.MAX_DANMAKU_DURATION) - 100;
    long endMills = timer.currMillisecond + this.mContext.mDanmakuFactory.MAX_DANMAKU_DURATION;
    if (this.mLastBeginMills > beginMills || timer.currMillisecond > this.mLastEndMills) {
        IDanmakus subDanmakus = this.danmakuList.sub(beginMills, endMills);
        if (subDanmakus != null) {
            this.danmakus = subDanmakus;
        } else {
            this.danmakus.clear();
        }
        this.mLastBeginMills = beginMills;
        this.mLastEndMills = endMills;
    } else {
        beginMills = this.mLastBeginMills;
        endMills = this.mLastEndMills;
    }
    if (this.danmakus == null || this.danmakus.isEmpty()) {
        this.mRenderingState.nothingRendered = true;
        this.mRenderingState.beginTime = beginMills;
        this.mRenderingState.endTime = endMills;
        return this.mRenderingState;
    }
    RenderingState renderingState = this.mRenderer.draw(this.mDisp, this.danmakus, this.mStartRenderTime);
    this.mRenderingState = renderingState;
    if (!renderingState.nothingRendered) {
        return renderingState;
    }
    if (!(this.mTaskListener == null || this.mLastDanmaku == null || !this.mLastDanmaku.isTimeOut())) {
        this.mTaskListener.onDanmakusDrawingFinished();
    }
    if (renderingState.beginTime == -1) {
        renderingState.beginTime = beginMills;
    }
    if (renderingState.endTime != -1) {
        return renderingState;
    }
    renderingState.endTime = endMills;
    return renderingState;
}
 

protected void initTimer(DanmakuTimer timer) {
    this.mTimer = timer;
}
 

protected void initTimer(DanmakuTimer timer) {
    this.mTimer = timer;
    this.mCacheTimer = new DanmakuTimer();
    this.mCacheTimer.update(timer.currMillisecond);
}
 

public BaseDanmakuParser setTimer(DanmakuTimer timer) {
    this.mTimer = timer;
    return this;
}
 

public DanmakuTimer getTimer() {
    return this.mTimer;
}
 

@Override
public void updateTimer(DanmakuTimer timer) {

}
 

boolean filter(BaseDanmaku baseDanmaku, int i, int i2, DanmakuTimer danmakuTimer, boolean z, DanmakuContext danmakuContext); 

public abstract boolean filter(BaseDanmaku baseDanmaku, int i, int i2, DanmakuTimer danmakuTimer, boolean z, DanmakuContext danmakuContext); 

void updateTimer(DanmakuTimer danmakuTimer);