Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.dynamic;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Rect;

import android.util.AttributeSet;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import org.distorted.library.type.Dynamic;

///////////////////////////////////////////////////////////////////////////////////////////////////

class DynamicSpeedSurfaceView extends SurfaceView implements SurfaceHolder.Callback

{

    private static final int FRAME_INTERVAL = 70;

    private static final int NUM_POINTS     = DynamicSurfaceView.NUM_POINTS;

    private static boolean refreshScreen = true;

    private GraphicsThread mThread;

    private int mWidth, mHeight, mMargin;

    private int mMode, mNumRedPoints, mPointSize;

    private float mFontHeight;

    private Paint mPaint;

    private float[] mPoints = new float[2*NUM_POINTS];

    private int mPosition;

    private float mMultiplier;

/////////////////////////////////////////////////////////////////////////////////////////

    private class GraphicsThread extends Thread

      {

      private final SurfaceHolder mSurfaceHolder;

      private final DynamicSpeedSurfaceView mPicker;

      private boolean mRun = false;

      ///////////////////////////////////////////////////////////////////////////////////////

      GraphicsThread(SurfaceHolder surfaceHolder, DynamicSpeedSurfaceView p)

        {

        mSurfaceHolder = surfaceHolder;

        mPicker = p;

        }

      ///////////////////////////////////////////////////////////////////////////////////////

      void setRunning(boolean run)

        {

        mRun = run;

        }

      ///////////////////////////////////////////////////////////////////////////////////////

      public void run()

        {

        Canvas c;

        long time;

        while (mRun)

          {

          c = null;

          time = 0;

          if( refreshScreen )

            {

            refreshScreen=false;

            time = System.currentTimeMillis();

            try

              {

              c = mSurfaceHolder.lockCanvas(null);

              synchronized (mSurfaceHolder) { mPicker.render(c); }

              }

            finally

              {

              if (c != null)  mSurfaceHolder.unlockCanvasAndPost(c);

              }

            time = System.currentTimeMillis() -time;

            }

          if( time<FRAME_INTERVAL )

            {

            try { Thread.sleep(FRAME_INTERVAL-time); }

            catch(InterruptedException ex) {}

            }

          }

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public DynamicSpeedSurfaceView(Context context, AttributeSet attrs)

      {

      super(context,attrs);

      mNumRedPoints = 0;

      mPosition     = 0;

      mPaint = new Paint();

      mPaint.setAntiAlias(true);

      mPaint.setFakeBoldText(true);

      mPaint.setStyle(Paint.Style.FILL);

      clearPoints();

      getHolder().addCallback(this);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void stopThread()

      {

      if( mThread!=null )

        {

        boolean retry = true;

        mThread.setRunning(false);

        while (retry)

          {

          try

            {

            mThread.join();

            retry = false;

            }

          catch (InterruptedException e) { android.util.Log.e( "DynamicSpeed", "Joining thread interrupted!"); }

          }

        mThread=null;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void render(Canvas c)

      {

      if( c!=null )

        {

        mPaint.setColor(0xff007d00);

        c.drawRect(0, 0, mWidth, mHeight, mPaint);

        mPaint.setColor(0xff000000);

        c.drawText( "Speed", mWidth/2, mMargin, mPaint);

        drawAxis(c);

        drawSpeedGraph(c);

        drawRedPoints(c);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawAxis(Canvas c)

      {

      mPaint.setColor(0xff000000);

      c.drawLine( mMargin, mHeight-mMargin, mWidth-mMargin, mHeight-mMargin, mPaint);

      c.drawLine( mMargin, mHeight-mMargin,        mMargin,         mMargin, mPaint);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoints(Canvas c)

      {

      if( mNumRedPoints==1 )

        {

        drawRedPoint(c,"0", mMargin, mHeight-mMargin);

        }

      else if( mNumRedPoints>1 )

        {

        int len = mMode== Dynamic.MODE_LOOP ? mNumRedPoints+1 : mNumRedPoints;

        String label;

        float x;

        for(int curr=0; curr<len; curr++)

          {

          label = curr==mNumRedPoints ? "0" : curr+"";

          x = mMargin + curr*((float)(mWidth-2*mMargin))/(len-1);

          drawRedPoint(c,label, x, mHeight-mMargin);

          }

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoint(Canvas c, String label, float width, float height)

      {

      mPaint.setColor(0xffff0000);

      c.drawCircle( width, height, mPointSize, mPaint);

      mPaint.setColor(0xffffffff);

      c.drawText(label, width,height-mFontHeight, mPaint);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawSpeedGraph(Canvas c)

      {

      mPaint.setColor(0xffffffff);

      float y, highiest=0.0f;

      for(int i=0; i<NUM_POINTS; i++)

        {

        y = mPoints[2*i+1];

        c.drawCircle( mMargin+mPoints[2*i]*(mWidth-2*mMargin), mHeight-mMargin-mMultiplier*y , mPointSize*0.3f, mPaint );

        if( y>highiest ) highiest = y;

        }

      mMultiplier = (mHeight-2*mMargin)/highiest;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void setMode(int mode)

      {

      mMode = mode;

      refreshScreen = true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void clearPoints()

      {

      for(int i=0; i<2*NUM_POINTS; i++)

         {

         mPoints[i] = -10.0f;

         }

      refreshScreen = true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void addPoint(float x, float y)

      {

      mPoints[2*mPosition  ] =x;

      mPoints[2*mPosition+1] =y;

      if ( ++mPosition >= NUM_POINTS ) mPosition=0;

      refreshScreen = true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void setNumRedPoints(int numRedPoints)

      {

      mNumRedPoints = numRedPoints;

      refreshScreen = true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void onPause()

      {

      if( mThread!=null ) mThread.setRunning(false);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void onResume()

      {

      if( mThread!=null ) mThread.setRunning(true);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    @Override

    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)

      {

      mWidth = width;

      mHeight= height;

      mMargin= height/10;

      mPointSize = (mWidth+mHeight)/80;

      mPaint.setTextSize((mWidth+mHeight)/60);

      mPaint.setTextAlign(Paint.Align.CENTER);

      final Rect textBounds = new Rect();

      String text = "1";

      mPaint.getTextBounds(text, 0, text.length(), textBounds);

      mFontHeight = textBounds.exactCenterY();

      refreshScreen = true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    @Override

    public void surfaceCreated(SurfaceHolder holder)

      {

      mThread = new GraphicsThread(getHolder(), this);

      mThread.setRunning(true);

      mThread.start();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    @Override

    public void surfaceDestroyed(SurfaceHolder holder)

      {

      stopThread();

      }

}