我想在我的应用程序中制作一个简单的实时绘图折线图。我知道有很多不同的库，但它们太大或没有正确的功能或许可证。
我的想法是制作自定义视图，并扩展View类。在这种情况下使用OpenGL就像用大炮打鸭子一样。我已经有一个视图正在绘制静态数据——首先将所有数据放入我的Plot对象的float数组中，然后使用循环在PlotView类的onDraw()方法中绘制所有内容。
我还有一个线程，会提供新的数据给我的绘图。但现在的问题是如何在添加新数据时进行绘制。第一个想法是简单地添加新点并绘制。再添加一个点，再绘制。但我不确定在100或1000个点时会发生什么。我添加新点，要求视图使其无效，但仍然有一些点没有被绘制。在这种情况下，即使使用一些队列也可能很困难，因为onDraw()将重新开始，所以队列元素的数量只会增加。
您有什么建议可以实现这个目标吗？
这应该能解决问题。
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.os.Bundle;
import android.support.v4.view.ViewCompat;
import android.support.v7.app.AppCompatActivity;
import android.util.AttributeSet;
import android.view.View;
import java.io.Serializable;
public class MainActivity
extends AppCompatActivity
{
private static final String STATE_PLOT = "statePlot";
private MockDataGenerator mMockDataGenerator;
private Plot mPlot;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
if(savedInstanceState == null){
mPlot = new Plot(100, -1.5f, 1.5f);
}else{
mPlot = (Plot) savedInstanceState.getSerializable(STATE_PLOT);
}
PlotView plotView = new PlotView(this);
plotView.setPlot(mPlot);
setContentView(plotView);
}
@Override
protected void onSaveInstanceState(Bundle outState)
{
super.onSaveInstanceState(outState);
outState.putSerializable(STATE_PLOT, mPlot);
}
@Override
protected void onResume()
{
super.onResume();
mMockDataGenerator = new MockDataGenerator(mPlot);
mMockDataGenerator.start();
}
@Override
protected void onPause()
{
super.onPause();
mMockDataGenerator.quit();
}
public static class MockDataGenerator
extends Thread
{
private final Plot mPlot;
public MockDataGenerator(Plot plot)
{
super(MockDataGenerator.class.getSimpleName());
mPlot = plot;
}
@Override
public void run()
{
try{
float val = 0;
while(!isInterrupted()){
mPlot.add((float) Math.sin(val += 0.16f));
Thread.sleep(1000 / 30);
}
}
catch(InterruptedException e){
//
}
}
public void quit()
{
try{
interrupt();
join();
}
catch(InterruptedException e){
//
}
}
}
public static class PlotView extends View
implements Plot.OnPlotDataChanged
{
private Paint mLinePaint;
private Plot mPlot;
public PlotView(Context context)
{
this(context, null);
}
public PlotView(Context context, AttributeSet attrs)
{
super(context, attrs);
mLinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mLinePaint.setStyle(Paint.Style.STROKE);
mLinePaint.setStrokeJoin(Paint.Join.ROUND);
mLinePaint.setStrokeCap(Paint.Cap.ROUND);
mLinePaint.setStrokeWidth(context.getResources()
.getDisplayMetrics().density * 2.0f);
mLinePaint.setColor(0xFF568607);
setBackgroundColor(0xFF8DBF45);
}
public void setPlot(Plot plot)
{
if(mPlot != null){
mPlot.setOnPlotDataChanged(null);
}
mPlot = plot;
if(plot != null){
plot.setOnPlotDataChanged(this);
}
onPlotDataChanged();
}
public Plot getPlot()
{
return mPlot;
}
public Paint getLinePaint()
{
return mLinePaint;
}
@Override
public void onPlotDataChanged()
{
ViewCompat.postInvalidateOnAnimation(this);
}
@Override
protected void onDraw(Canvas canvas)
{
super.onDraw(canvas);
final Plot plot = mPlot;
if(plot == null){
return;
}
final int height = getHeight();
final float[] data = plot.getData();
final float unitHeight = height / plot.getRange();
final float midHeight = height / 2.0f;
final float unitWidth = (float) getWidth() / data.length;
float lastX = -unitWidth, lastY = 0, currentX, currentY;
for(int i = 0; i < data.length; i++){
currentX = lastX + unitWidth;
currentY = unitHeight * data[i] + midHeight;
canvas.drawLine(lastX, lastY, currentX, currentY, mLinePaint);
lastX = currentX;
lastY = currentY;
}
}
}
public static class Plot
implements Serializable
{
private final float[] mData;
private final float mMin;
private final float mMax;
private transient OnPlotDataChanged mOnPlotDataChanged;
public Plot(int size, float min, float max)
{
mData = new float[size];
mMin = min;
mMax = max;
}
public void setOnPlotDataChanged(OnPlotDataChanged onPlotDataChanged)
{
mOnPlotDataChanged = onPlotDataChanged;
}
public void add(float value)
{
System.arraycopy(mData, 1, mData, 0, mData.length - 1);
mData[mData.length - 1] = value;
if(mOnPlotDataChanged != null){
mOnPlotDataChanged.onPlotDataChanged();
}
}
public float[] getData()
{
return mData;
}
public float getMin()
{
return mMin;
}
public float getMax()
{
return mMax;
}
public float getRange()
{
return (mMax - mMin);
}
public interface OnPlotDataChanged
{
void onPlotDataChanged();
}
}
}
第一个问题是-您的情况有什么缓慢之处？您知道延迟来自何处吗？首先，请确保您有一个要解决的问题；其次，请确保您知道问题来自何处。
假设您的问题在于数据大小，这个问题如何解决是一个复杂的问题。这取决于正在绘制的数据的属性-您可以假设什么不变量等等。您已经谈到了在float[]中存储数据，因此我将假设您拥有一定数量的数据点，其值会发生变化。我还假设通过“100或1000”，您想表达的是“很多很多”，因为老实说，1000个浮点数并不是很多的数据。
当您有一个非常大的数组要绘制时，性能限制最终将来自于遍历数组。然后，您的性能增强将是减少您要遍历的数组量。这就是数据属性发挥作用的地方。
减少重绘操作量的一种方法是保留一个“脏列表”，它类似于Queue<Int>。每当数组中的单元格更改时，将该数组索引入队，标记为“脏”。每次绘制方法回到时，出队脏列表中的固定数量条目，并仅更新与这些条目对应的渲染图像块-由于有那么多数据点，您可能拥有比屏幕像素更多的数据，因此您可能需要进行一些缩放和/或抗锯齿处理等。在任何给定的帧更新中重新绘制的条目数应受所需帧速率的限制-您可以根据先前绘制操作花费的时间以及脏列表的深度来使其自适应，以保持帧速率和可见数据年龄之间的良好平衡。
如果您尝试在屏幕上同时绘制所有数据，则此方法特别适用。如果您只查看数据的一部分（例如在可滚动视图中），并且数组位置与窗口大小之间存在某种对应关系，则可以“窗口化”数据-在每个绘制调用中，仅考虑实际在屏幕上的数据子集。如果您还有一个“缩放”功能，则可以混合使用这两种方法-这可能会变得复杂。
如果你的数据是窗口化的，每个数组元素的值决定了数据点是否在屏幕上，考虑使用一对排序列表，其中排序键是该值。这将让您在这种情况下执行上面概述的窗口化优化。如果窗口处理发生在两个维度中，您很可能只需要执行一个优化，但也有两个维度范围查询结构可以为您提供此功能。如果您已经有一个绘制静态数据的视图，那么您离目标很近了。 然后您需要做的唯一事情是：
1）提取检索数据的逻辑 2）提取将此数据绘制到屏幕上的逻辑 3）在onDraw()方法中，首先调用1）- 然后调用2）- 最后调用invalidate() - 因为这将触发新的绘制并使用新数据更新视图。
这应该不是问题，因为屏幕上的点将受到限制，所以队列只会保留那么多点，之前的点将被删除。
希望这种方法有所帮助。
现在我建议您使用GraphView Library。它是开源的，不用担心许可证问题，而且大小也不大（小于64kB）。如果您愿意，可以清理必要的文件。
您可以找到实时绘图的用法示例
来自官方示例：
public class RealtimeUpdates extends Fragment {
private final Handler mHandler = new Handler();
private Runnable mTimer1;
private Runnable mTimer2;
private LineGraphSeries<DataPoint> mSeries1;
private LineGraphSeries<DataPoint> mSeries2;
private double graph2LastXValue = 5d;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_main2, container, false);
GraphView graph = (GraphView) rootView.findViewById(R.id.graph);
mSeries1 = new LineGraphSeries<DataPoint>(generateData());
graph.addSeries(mSeries1);
GraphView graph2 = (GraphView) rootView.findViewById(R.id.graph2);
mSeries2 = new LineGraphSeries<DataPoint>();
graph2.addSeries(mSeries2);
graph2.getViewport().setXAxisBoundsManual(true);
graph2.getViewport().setMinX(0);
graph2.getViewport().setMaxX(40);
return rootView;
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
((MainActivity) activity).onSectionAttached(
getArguments().getInt(MainActivity.ARG_SECTION_NUMBER));
}
@Override
public void onResume() {
super.onResume();
mTimer1 = new Runnable() {
@Override
public void run() {
mSeries1.resetData(generateData());
mHandler.postDelayed(this, 300);
}
};
mHandler.postDelayed(mTimer1, 300);
mTimer2 = new Runnable() {
@Override
public void run() {
graph2LastXValue += 1d;
mSeries2.appendData(new DataPoint(graph2LastXValue, getRandom()), true, 40);
mHandler.postDelayed(this, 200);
}
};
mHandler.postDelayed(mTimer2, 1000);
}
@Override
public void onPause() {
mHandler.removeCallbacks(mTimer1);
mHandler.removeCallbacks(mTimer2);
super.onPause();
}
private DataPoint[] generateData() {
int count = 30;
DataPoint[] values = new DataPoint[count];
for (int i=0; i<count; i++) {
double x = i;
double f = mRand.nextDouble()*0.15+0.3;
double y = Math.sin(i*f+2) + mRand.nextDouble()*0.3;
DataPoint v = new DataPoint(x, y);
values[i] = v;
}
return values;
}
double mLastRandom = 2;
Random mRand = new Random();
private double getRandom() {
return mLastRandom += mRand.nextDouble()*0.5 - 0.25;
}
}
GraphView进行斗争，但似乎存在一个错误 - http://stackoverflow.com/questions/30290575/android-graphview-project-get-freeze-with-real-time-updates - sebap123public class MyView extends View {
...
}
在布局中：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<com.yadayada.MyView
android:id="@+id/paintme"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
</LinearLayout>
Bitmap/BitmapDrawable支持的ImageView。当出现新数据时，将其绘制在位图上，但不要清除旧数据，这样您就不需要每帧重新绘制所有内容。 - pelya