LoopbackApp/app/src/main/java/org/drrickorang/loopback/HistogramView.java - platform/external/drrickorang - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.drrickorang.loopback;

 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.View;


 /**
  * This is the histogram used to show recorder/player buffer period.
  */

 public class HistogramView extends View {
     private static final String TAG = "HistogramView";


     private Paint mHistPaint;
     private Paint mTextPaint;
     private Paint mLinePaint;
     private Paint mXLabelPaint;

     private int[] mData; // data for buffer period
     private int[] mDisplayData; // modified data that is used to draw histogram
     private int mMaxBufferPeriod = 0;
     // number of x-axis labels excluding the last x-axis label
     private int mNumberOfXLabel = 5;  // mNumberOfXLabel must > 0

     private final int mYAxisBase = 10; // base of y-axis log scale
     private final int mYLabelSize = 40;
     private final int mXLabelSize = 40;
     private final int mLineWidth = 3;
     private final int mMaxNumberOfBeams = 202; // the max amount of beams to display on the screen

     // Note: if want to change this to base other than 10, must change the way x labels are
     // displayed. It's currently half-hardcoded.
     private final int mBucketBase = 10; // a bucket's range


     public HistogramView(Context context, AttributeSet attrs) {
         super(context, attrs);
         initPaints();
     }


     /** Initiate all the Paint objects. */
     private void initPaints() {
         mHistPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mHistPaint.setStyle(Paint.Style.FILL);
         mHistPaint.setColor(Color.BLUE);

         mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mTextPaint.setColor(Color.BLACK);
         mTextPaint.setTextSize(mYLabelSize);

         mXLabelPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mXLabelPaint.setColor(Color.BLACK);
         mXLabelPaint.setTextSize(mXLabelSize);

         mLinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mLinePaint.setColor(Color.BLACK);
         mLinePaint.setStrokeWidth(mLineWidth);
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         fillCanvas(canvas, this.getRight(), this.getBottom());
     }

     // also called in LoopbackActivity.java
     void fillCanvas(Canvas canvas, int right, int bottom) {
         canvas.drawColor(Color.GRAY);

         if (mData == null || mData.length == 0) {
             return;
         }

         int arrayLength = mData.length;
         boolean exceedBufferPeriodRange;
         if (mMaxBufferPeriod != 0) {
             final int extraYMargin = 5; // the extra margin between y labels and y-axis
             final int beamInterval = 2; // separate each beam in the histogram by such amount
             int range; // the number of beams that's going to be displayed on histogram
             if (mMaxBufferPeriod > arrayLength - 1) {
                 range = arrayLength;
                 exceedBufferPeriodRange = true;
             } else {
                 range = mMaxBufferPeriod + 1;
                 exceedBufferPeriodRange = false;
             }

             if (range == 0) {
                 return;
             }

             boolean isUsingDisplayData = false;
             int oldRange = range;
             int interval = 1;

             // if there are more beams than allowed to be displayed on screen,
             // put beams into buckets
             if (range > mMaxNumberOfBeams) {
                 isUsingDisplayData = true;
                 int bucketOrder = 0;
                 if (exceedBufferPeriodRange) { // there should be one extra beam for 101+
                     range -= 2;
                     while (range > mMaxNumberOfBeams - 2) {
                         range /= mBucketBase;
                         bucketOrder++;
                     }
                     range += 2; // assuming always XXX1+, not something like 0~473, 474+.

                 } else {
                     range--;
                     int temp = range;
                     while (range > mMaxNumberOfBeams - 2) {
                         range /= mBucketBase;
                         bucketOrder++;
                     }

                     if ((temp % mBucketBase) != 0) {
                         range += 2;
                     } else {
                         range++;
                     }
                 }

                 interval = (int) Math.pow(mBucketBase, bucketOrder);
                 mDisplayData = new int[mMaxNumberOfBeams];
                 mDisplayData[0] = mData[0];

                 // putting data into buckets.
                 for (int i = 1; i < (range - 1); i++) {
                     for (int j = (((i - 1) * interval) + 1); (j <= (i * interval)); j++) {
                         mDisplayData[i] += mData[j];
                     }
                 }

                 if (exceedBufferPeriodRange) {
                     mDisplayData[range - 1] = mData[oldRange - 1];
                 } else {
                     for (int i = (((range - 2) * interval) + 1); i < oldRange; i++) {
                         mDisplayData[range - 1] += mData[i];
                     }
                 }
             } else {
                 mDisplayData = mData;
             }

             // calculate the max frequency among all latencies
             int maxBufferPeriodFreq = 0;
             for (int i = 1; i < range; i++) {
                 if (mDisplayData[i] > maxBufferPeriodFreq) {
                     maxBufferPeriodFreq = mDisplayData[i];
                 }
             }

             if (maxBufferPeriodFreq == 0) {
                 return;
             }

             // find the closest order of "mYAxisBase" according to maxBufferPeriodFreq
             int order = (int) Math.ceil((Math.log10(maxBufferPeriodFreq)) /
                         (Math.log10(mYAxisBase)));
             float height = ((float) (bottom - mXLabelSize - mLineWidth) / (order + 1));

             // y labels
             String[] yLabels = new String[order + 2]; // store {"0", "1", "10", ...} for base = 10
             yLabels[0] = "0";
             int yStartPoint = bottom - mXLabelSize - mLineWidth;
             canvas.drawText(yLabels[0], 0, yStartPoint, mTextPaint);
             int currentValue = 1;
             for (int i = 1; i < yLabels.length; i++) {
                 yLabels[i] = Integer.toString(currentValue);
                 // Label is displayed at lower than it should be by the amount of "mYLabelSize"
                 canvas.drawText(yLabels[i], 0, yStartPoint - (i * height) + mYLabelSize,
                         mTextPaint);
                 currentValue *= mYAxisBase;
             }

             // draw x axis
             canvas.drawLine(0, bottom - mXLabelSize, right, bottom - mXLabelSize, mLinePaint);

             // draw y axis
             int yMargin = getTextWidth(yLabels[order + 1], mTextPaint);
             canvas.drawLine(yMargin + extraYMargin, bottom, yMargin + extraYMargin,
                     0, mLinePaint);

             // width of each beam in the histogram
             float width = ((float) (right - yMargin - extraYMargin - mLineWidth -
                           (range * beamInterval)) / range);

             // draw x labels
             String lastXLabel;
             int xLabelInterval;
             int xStartPoint = yMargin + extraYMargin + mLineWidth;  // position of first beam
             String[] xLabels;

             // mNumberOfXLabel includes "0" but excludes the last label, which will be at last beam
             // if mNumberOfXLabel exceeds the total beams that's going to have, reduce its value
             if (mNumberOfXLabel - 1 > range - 2) {
                 mNumberOfXLabel = range - 1;
             }

             //
             if (!isUsingDisplayData) { // in this case each beam represent one buffer period
                 if ((range - 2) < mNumberOfXLabel) {
                     xLabelInterval = 1;
                 } else {
                     xLabelInterval = (range - 2) / mNumberOfXLabel;
                 }

                 xLabels = new String[mNumberOfXLabel];
                 xLabels[0] = "0";       // first label is for 0
                 canvas.drawText(xLabels[0], yMargin + extraYMargin + mLineWidth, bottom,
                         mXLabelPaint);

                 float xLabelLineStartX;
                 float xLabelLineStartY;
                 int xLabelLineLength = 10;
                 for (int i = 1; i < mNumberOfXLabel; i++) {
                     xLabelLineStartX = xStartPoint +
                                        (xLabelInterval * i * (width + beamInterval));
                     xLabels[i] = Integer.toString(i * xLabelInterval);
                     canvas.drawText(xLabels[i], xLabelLineStartX, bottom, mXLabelPaint);

                     //add a vertical line to indicate label's corresponding beams
                     xLabelLineStartY = bottom - mXLabelSize;
                     canvas.drawLine(xLabelLineStartX, xLabelLineStartY, xLabelLineStartX,
                                     xLabelLineStartY - xLabelLineLength, mLinePaint);
                 }

                 // last label is for the last beam
                 if (exceedBufferPeriodRange) {
                     lastXLabel = Integer.toString(range - 1) + "+";
                 } else {
                     lastXLabel = Integer.toString(range - 1);
                 }

                 canvas.drawText(lastXLabel, right - getTextWidth(lastXLabel, mXLabelPaint) - 1,
                         bottom, mXLabelPaint);

             } else {    // in this case each beam represent a range of buffer period
                 // if mNumberOfXLabel exceeds amount of beams, decrease mNumberOfXLabel
                 if ((range - 2) < mNumberOfXLabel) {
                     xLabelInterval = 1;
                 } else {
                     xLabelInterval = (range - 2) / mNumberOfXLabel;
                 }

                 xLabels = new String[mNumberOfXLabel];
                 xLabels[0] = "0";       // first label is for 0ms
                 canvas.drawText(xLabels[0], yMargin + extraYMargin + mLineWidth, bottom,
                         mXLabelPaint);

                 // draw all the middle labels
                 for (int i = 1; i < mNumberOfXLabel; i++) {
                     xLabels[i] = Integer.toString((i * xLabelInterval) - 1) + "1-" +
                                  Integer.toString(i * xLabelInterval) + "0";
                     canvas.drawText(xLabels[i], xStartPoint + (xLabelInterval * i *
                             (width + beamInterval)), bottom, mXLabelPaint);
                 }

                 // draw the last label for the last beam
                 if (exceedBufferPeriodRange) {
                     lastXLabel = Integer.toString(oldRange - 1) + "+";
                 } else {
                     if ((((range - 2) * interval) + 1) == oldRange - 1) {
                         lastXLabel = Integer.toString(oldRange - 1);
                     } else {
                         lastXLabel = Integer.toString(range - 2) + "1-" +
                                 Integer.toString(oldRange - 1);
                     }
                 }

                 canvas.drawText(lastXLabel, right - getTextWidth(lastXLabel, mXLabelPaint) - 1,
                         bottom, mXLabelPaint);
             }

             // draw the histogram
             float currentLeft = yMargin + extraYMargin + mLineWidth;
             float currentTop;
             float currentRight;
             int currentBottom = bottom - mXLabelSize - mLineWidth;
             for (int i = 0; i < range; i++) {
                 currentRight = currentLeft + width;
                 // calculate the height of the beam. Skip drawing if mDisplayData[i] = 0
                 if (mDisplayData[i] != 0) {
                     float units = (float) (((Math.log10((double) mDisplayData[i])) /
                             Math.log10(mYAxisBase)) + 1.0);
                     currentTop = currentBottom - (height * units);
                     canvas.drawRect(currentLeft, currentTop, currentRight,
                             currentBottom, mHistPaint);
                 }

                 currentLeft = currentRight + beamInterval;
             }

         }
     }


     /** get the width of "text" when using "paint". */
     public int getTextWidth(String text, Paint paint) {
         int width;
         Rect bounds = new Rect();
         paint.getTextBounds(text, 0, text.length(), bounds);
         width = bounds.left + bounds.width();
         return width;
     }

     /** Copy buffer period data into "mData" */
     public void setBufferPeriodArray(int[] data) {
         if (data == null) {
             return;
         }

         if (mData == null || data.length != mData.length) {
             mData = new int[data.length];
         }

         System.arraycopy(data, 0, mData, 0, data.length);
     }


     public void setMaxBufferPeriod(int ReadBufferPeriod) {
         mMaxBufferPeriod = ReadBufferPeriod;
     }


     private static void log(String msg) {
         Log.v(TAG, msg);
     }

 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.drrickorang.loopback;

	import android.content.Context;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.view.View;


	/**
	* This is the histogram used to show recorder/player buffer period.
	*/

	public class HistogramView extends View {
	private static final String TAG = "HistogramView";


	private Paint mHistPaint;
	private Paint mTextPaint;
	private Paint mLinePaint;
	private Paint mXLabelPaint;

	private int[] mData; // data for buffer period
	private int[] mDisplayData; // modified data that is used to draw histogram
	private int mMaxBufferPeriod = 0;
	// number of x-axis labels excluding the last x-axis label
	private int mNumberOfXLabel = 5; // mNumberOfXLabel must > 0

	private final int mYAxisBase = 10; // base of y-axis log scale
	private final int mYLabelSize = 40;
	private final int mXLabelSize = 40;
	private final int mLineWidth = 3;
	private final int mMaxNumberOfBeams = 202; // the max amount of beams to display on the screen

	// Note: if want to change this to base other than 10, must change the way x labels are
	// displayed. It's currently half-hardcoded.
	private final int mBucketBase = 10; // a bucket's range


	public HistogramView(Context context, AttributeSet attrs) {
	super(context, attrs);
	initPaints();
	}


	/** Initiate all the Paint objects. */
	private void initPaints() {
	mHistPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mHistPaint.setStyle(Paint.Style.FILL);
	mHistPaint.setColor(Color.BLUE);

	mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mTextPaint.setColor(Color.BLACK);
	mTextPaint.setTextSize(mYLabelSize);

	mXLabelPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mXLabelPaint.setColor(Color.BLACK);
	mXLabelPaint.setTextSize(mXLabelSize);

	mLinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mLinePaint.setColor(Color.BLACK);
	mLinePaint.setStrokeWidth(mLineWidth);
	}

	@Override
	protected void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	fillCanvas(canvas, this.getRight(), this.getBottom());
	}

	// also called in LoopbackActivity.java
	void fillCanvas(Canvas canvas, int right, int bottom) {
	canvas.drawColor(Color.GRAY);

	if (mData == null \|\| mData.length == 0) {
	return;
	}

	int arrayLength = mData.length;
	boolean exceedBufferPeriodRange;
	if (mMaxBufferPeriod != 0) {
	final int extraYMargin = 5; // the extra margin between y labels and y-axis
	final int beamInterval = 2; // separate each beam in the histogram by such amount
	int range; // the number of beams that's going to be displayed on histogram
	if (mMaxBufferPeriod > arrayLength - 1) {
	range = arrayLength;
	exceedBufferPeriodRange = true;
	} else {
	range = mMaxBufferPeriod + 1;
	exceedBufferPeriodRange = false;
	}

	if (range == 0) {
	return;
	}

	boolean isUsingDisplayData = false;
	int oldRange = range;
	int interval = 1;

	// if there are more beams than allowed to be displayed on screen,
	// put beams into buckets
	if (range > mMaxNumberOfBeams) {
	isUsingDisplayData = true;
	int bucketOrder = 0;
	if (exceedBufferPeriodRange) { // there should be one extra beam for 101+
	range -= 2;
	while (range > mMaxNumberOfBeams - 2) {
	range /= mBucketBase;
	bucketOrder++;
	}
	range += 2; // assuming always XXX1+, not something like 0~473, 474+.

	} else {
	range--;
	int temp = range;
	while (range > mMaxNumberOfBeams - 2) {
	range /= mBucketBase;
	bucketOrder++;
	}

	if ((temp % mBucketBase) != 0) {
	range += 2;
	} else {
	range++;
	}
	}

	interval = (int) Math.pow(mBucketBase, bucketOrder);
	mDisplayData = new int[mMaxNumberOfBeams];
	mDisplayData[0] = mData[0];

	// putting data into buckets.
	for (int i = 1; i < (range - 1); i++) {
	for (int j = (((i - 1) * interval) + 1); (j <= (i * interval)); j++) {
	mDisplayData[i] += mData[j];
	}
	}

	if (exceedBufferPeriodRange) {
	mDisplayData[range - 1] = mData[oldRange - 1];
	} else {
	for (int i = (((range - 2) * interval) + 1); i < oldRange; i++) {
	mDisplayData[range - 1] += mData[i];
	}
	}
	} else {
	mDisplayData = mData;
	}

	// calculate the max frequency among all latencies
	int maxBufferPeriodFreq = 0;
	for (int i = 1; i < range; i++) {
	if (mDisplayData[i] > maxBufferPeriodFreq) {
	maxBufferPeriodFreq = mDisplayData[i];
	}
	}

	if (maxBufferPeriodFreq == 0) {
	return;
	}

	// find the closest order of "mYAxisBase" according to maxBufferPeriodFreq
	int order = (int) Math.ceil((Math.log10(maxBufferPeriodFreq)) /
	(Math.log10(mYAxisBase)));
	float height = ((float) (bottom - mXLabelSize - mLineWidth) / (order + 1));

	// y labels
	String[] yLabels = new String[order + 2]; // store {"0", "1", "10", ...} for base = 10
	yLabels[0] = "0";
	int yStartPoint = bottom - mXLabelSize - mLineWidth;
	canvas.drawText(yLabels[0], 0, yStartPoint, mTextPaint);
	int currentValue = 1;
	for (int i = 1; i < yLabels.length; i++) {
	yLabels[i] = Integer.toString(currentValue);
	// Label is displayed at lower than it should be by the amount of "mYLabelSize"
	canvas.drawText(yLabels[i], 0, yStartPoint - (i * height) + mYLabelSize,
	mTextPaint);
	currentValue *= mYAxisBase;
	}

	// draw x axis
	canvas.drawLine(0, bottom - mXLabelSize, right, bottom - mXLabelSize, mLinePaint);

	// draw y axis
	int yMargin = getTextWidth(yLabels[order + 1], mTextPaint);
	canvas.drawLine(yMargin + extraYMargin, bottom, yMargin + extraYMargin,
	0, mLinePaint);

	// width of each beam in the histogram
	float width = ((float) (right - yMargin - extraYMargin - mLineWidth -
	(range * beamInterval)) / range);

	// draw x labels
	String lastXLabel;
	int xLabelInterval;
	int xStartPoint = yMargin + extraYMargin + mLineWidth; // position of first beam
	String[] xLabels;

	// mNumberOfXLabel includes "0" but excludes the last label, which will be at last beam
	// if mNumberOfXLabel exceeds the total beams that's going to have, reduce its value
	if (mNumberOfXLabel - 1 > range - 2) {
	mNumberOfXLabel = range - 1;
	}

	//
	if (!isUsingDisplayData) { // in this case each beam represent one buffer period
	if ((range - 2) < mNumberOfXLabel) {
	xLabelInterval = 1;
	} else {
	xLabelInterval = (range - 2) / mNumberOfXLabel;
	}

	xLabels = new String[mNumberOfXLabel];
	xLabels[0] = "0"; // first label is for 0
	canvas.drawText(xLabels[0], yMargin + extraYMargin + mLineWidth, bottom,
	mXLabelPaint);

	float xLabelLineStartX;
	float xLabelLineStartY;
	int xLabelLineLength = 10;
	for (int i = 1; i < mNumberOfXLabel; i++) {
	xLabelLineStartX = xStartPoint +
	(xLabelInterval * i * (width + beamInterval));
	xLabels[i] = Integer.toString(i * xLabelInterval);
	canvas.drawText(xLabels[i], xLabelLineStartX, bottom, mXLabelPaint);

	//add a vertical line to indicate label's corresponding beams
	xLabelLineStartY = bottom - mXLabelSize;
	canvas.drawLine(xLabelLineStartX, xLabelLineStartY, xLabelLineStartX,
	xLabelLineStartY - xLabelLineLength, mLinePaint);
	}

	// last label is for the last beam
	if (exceedBufferPeriodRange) {
	lastXLabel = Integer.toString(range - 1) + "+";
	} else {
	lastXLabel = Integer.toString(range - 1);
	}

	canvas.drawText(lastXLabel, right - getTextWidth(lastXLabel, mXLabelPaint) - 1,
	bottom, mXLabelPaint);

	} else { // in this case each beam represent a range of buffer period
	// if mNumberOfXLabel exceeds amount of beams, decrease mNumberOfXLabel
	if ((range - 2) < mNumberOfXLabel) {
	xLabelInterval = 1;
	} else {
	xLabelInterval = (range - 2) / mNumberOfXLabel;
	}

	xLabels = new String[mNumberOfXLabel];
	xLabels[0] = "0"; // first label is for 0ms
	canvas.drawText(xLabels[0], yMargin + extraYMargin + mLineWidth, bottom,
	mXLabelPaint);

	// draw all the middle labels
	for (int i = 1; i < mNumberOfXLabel; i++) {
	xLabels[i] = Integer.toString((i * xLabelInterval) - 1) + "1-" +
	Integer.toString(i * xLabelInterval) + "0";
	canvas.drawText(xLabels[i], xStartPoint + (xLabelInterval * i *
	(width + beamInterval)), bottom, mXLabelPaint);
	}

	// draw the last label for the last beam
	if (exceedBufferPeriodRange) {
	lastXLabel = Integer.toString(oldRange - 1) + "+";
	} else {
	if ((((range - 2) * interval) + 1) == oldRange - 1) {
	lastXLabel = Integer.toString(oldRange - 1);
	} else {
	lastXLabel = Integer.toString(range - 2) + "1-" +
	Integer.toString(oldRange - 1);
	}
	}

	canvas.drawText(lastXLabel, right - getTextWidth(lastXLabel, mXLabelPaint) - 1,
	bottom, mXLabelPaint);
	}

	// draw the histogram
	float currentLeft = yMargin + extraYMargin + mLineWidth;
	float currentTop;
	float currentRight;
	int currentBottom = bottom - mXLabelSize - mLineWidth;
	for (int i = 0; i < range; i++) {
	currentRight = currentLeft + width;
	// calculate the height of the beam. Skip drawing if mDisplayData[i] = 0
	if (mDisplayData[i] != 0) {
	float units = (float) (((Math.log10((double) mDisplayData[i])) /
	Math.log10(mYAxisBase)) + 1.0);
	currentTop = currentBottom - (height * units);
	canvas.drawRect(currentLeft, currentTop, currentRight,
	currentBottom, mHistPaint);
	}

	currentLeft = currentRight + beamInterval;
	}

	}
	}


	/** get the width of "text" when using "paint". */
	public int getTextWidth(String text, Paint paint) {
	int width;
	Rect bounds = new Rect();
	paint.getTextBounds(text, 0, text.length(), bounds);
	width = bounds.left + bounds.width();
	return width;
	}

	/** Copy buffer period data into "mData" */
	public void setBufferPeriodArray(int[] data) {
	if (data == null) {
	return;
	}

	if (mData == null \|\| data.length != mData.length) {
	mData = new int[data.length];
	}

	System.arraycopy(data, 0, mData, 0, data.length);
	}


	public void setMaxBufferPeriod(int ReadBufferPeriod) {
	mMaxBufferPeriod = ReadBufferPeriod;
	}


	private static void log(String msg) {
	Log.v(TAG, msg);
	}

	}