Audio Record Support for Android Emulator

To test your applications which use android AudioRecord calss, you should set this class's constructor with supported device properties. In the android documentation, it says Android devices support at least;
Sample rate: 44100Mhz
Channel Type: CHANNEL_IN_MONO
Encoding: ENCODING_PCM_16BIT

But unfortunately this is not correct. Because neither emulator nor my Samsung Galaxy S2 supports this configuration. I have just discovered that the correct initialization for the android emulator is


Sample rate: 8000Mhz
Channel Type: CHANNEL_IN_MONO
Encoding: ENCODING_PCM_16BIT

 this works for minimum buffer size calculation with getMinBufferSize(,,)

Cheers!

Why do we need non-static inner class in java

Non static inner classes can reach to its enclosing class elements because they are dynamic elements of their enclosing classes. You can do that.

class A {
     public void method(){}
     public class B {
     method(); // cannot do this if you define B as 'public static class B'
     }
}

And in this case (non-static inner class). If you d like to create an instance of you inner class (B) in some other class, you should instantiate it like below.

class C {
     public C(){
     A.B b = new A().new B(); // B has the same characteristic like other non-static class elements
     }
}

On the other hand if you aren't going to reach to the enclosing class elements from the inner class, you can define your inner class as static class. In this case you don't need to create an instance of enclosing class to create an instance of the inner class.


class C {
     public C(){
     A.B b = new A.B(); // this is a valid instantiation of a B's instance.
     }
}

Defining the route path between two points in 2D coordination system and Java implementation

I currently develop a 2D ball game for Android OS therefore this computing is important for the game to define the ball’s route in the game. In Android OS, there is a TranslateAnimation class to fulfil the Translate operation (changing the X, Y coordinates of an instance of a View class) but TranslateAnimation class does not supply the information of the animated object’s current x, y coordinate state. In my game, the ball’s place in time is important to take action according to its location. Therefore, I developed my own Extended TranslateAnimation class.

***The Algorithm***

I divide the animation operation in to two parts. First part is path resolving between the destination and the source points and the second part is animating the instance of a View class (animated object) and displaying it on the screen graphically. This article explains the path resolving operation which’s algorithm is below.

The figure below shows the representation of the destination(X1, Y1) and the source (X0, Y0) points. Red line (hypotenuse) shows the full path between points, green line shows the base and blue line shows the leg of the right triangle. The aim is, from the point 0 to point 1 if the animated object moves long as “d” on the redline (hypotenuse), what will be the new location on 2D plane( the “x, y” value of the very top and left had side of the plane is “0, 0” and it increases to the bottom right hand side). If it was calculated this new location’s coordinates, it would be set to the animated object’s location and the object would move to there.

The step by step algorithm is defined below for “d” distance.

1. Get little hypotenuse length (hypo=d)

2. Calculate the length of Hypotenuse (RealHypo)

3. Find Tan α = Blue Line/ Green Line

4. Find the α angle (use ArcTan)

5. Calculate the Cos α and Sin α values

Until here, we know the Cos α and Sin α values so we can calculate the base and leg length of the small right triangle which’s hypotenuse is “d” and top point is X0, Y0. So we just need to find the coordinate of the other tip of “d” (X’, Y’).

6. Find the difference between X0 – X’ = d*Cos α

7. Find the difference between Y0 – Y’ = d*Sin α

8. Subtract/Add these differences to X0 and Y0 According to the equations in step 5-6.

9. hypo=hypo+d

X’ = X0 - d*Cos α

Y’ = Y0 - d*Sin α

That’s all. One important note is Subtract/Add option changes according to the movement of the animated object therefore the direction calculation should be computed in step 7 as well.

Code

Full Java Code (VectoralPathResolver) is added below.

VectoralPathResolver.java

   1: package aliolci.CrazyBall;

   2: /*

   3:  * By Ali Olcay SAHIN 

   4:  * www.aliolci.com

   5:  * aliolci@gmail.com

   6:  * Thank you for using it.

   7:  * */

   8: import java.util.ArrayList;

   9: import java.util.List;

  10:  

  11: import android.graphics.PointF;

  12:  

  13: public class VectoralPathResolver {

  14:     private float FromXDelta, ToXDelta, FromYDelta, ToYDelta;

  15:     private float d =(float) 0.1;//sensitivity

  16:     private float realHypo;

  17:     private float hypo;

  18:     private double TanAngle;

  19:     private double cosValue;

  20:     private double sinValue;

  21:     private byte signX;

  22:     private byte signY;

  23:     public VectoralPathResolver(float fromXDelta, float toXDelta,

  24:             float fromYDelta, float toYDelta) {

  25:         FromXDelta = fromXDelta;

  26:         ToXDelta = toXDelta; 

  27:         FromYDelta = fromYDelta;

  28:         ToYDelta = toYDelta;

  29:         

  30:         realHypo = (float) Math.sqrt(Math.pow(FromXDelta-ToXDelta, 2)+Math.pow(FromYDelta-ToYDelta, 2));

  31:         hypo =0;

  32:         TanAngle = Math.atan((ToYDelta-FromYDelta)/(ToXDelta-FromXDelta));

  33:         cosValue =Math.cos(TanAngle);

  34:         sinValue =Math.sin(TanAngle);

  35:         signX = (byte) (Integer.signum((int) (ToXDelta-FromXDelta))<0?-1:1);

  36:         signY = (byte) (Integer.signum((int) (ToYDelta-FromYDelta))<0?-1:1);

  37:     }

  38:     public List<PointF> ResolveReturnFullPath()

  39:     {

  40:         List<PointF> path= new ArrayList<PointF>();

  41:         PointF f;

  42:         do

  43:         {

  44:             f=this.Next();

  45:             if(f!=null)

  46:                 path.add(f);

  47:         }

  48:         while(f!=null);

  49:         

  50:         return path;

  51:     }

  52:     public void setSensitivity(float sensitivity)

  53:     {

  54:         d=sensitivity;

  55:     }

  56:     public PointF Next()

  57:     {

  58:         if(realHypo>hypo)

  59:         {

  60:             hypo+=d;

  61:             float Xnew = (float)(cosValue*hypo*signX)+FromXDelta;

  62:             float Ynew =(float)(sinValue*hypo*signY)+FromYDelta;

  63:             return new PointF(Xnew,Ynew);

  64:         }

  65:         else

  66:             return null;

  67:     }

  68:     public PointF Next(int HowMuchEachTime)

  69:     {

  70:         if(realHypo>hypo)

  71:         {

  72:             hypo+=d*HowMuchEachTime;

  73:             float Xnew = (float)(cosValue*hypo*signX)+FromXDelta;

  74:             float Ynew =(float)(sinValue*hypo*signY)+FromYDelta;

  75:             return new PointF(Xnew,Ynew);

  76:         }

  77:         else

  78:             return null;

  79:     }

  80:     public void reset()

  81:     {

  82:         hypo=0;

  83:     }

  84:     public int getTotalSteps()

  85:     {

  86:         return (int)(realHypo/d);

  87:     }

  88: }

Custom Timer for Android OS (with Cross Thread Messaging to Handle the UI updates )

Code below shows MyTimer class which implements the Runnable interface in order to be run as an individual thread. This class also supports MyTimerListener to inform the classes which are registered to this class, onTick event.

MyTimerClass

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class MyTimer implements Runnable {

  long interval;
  List<MyTimerListener> l = new ArrayList<MyTimerListener>();
  @Override
  public void run() {
      while(true)
      {
          try {
              Thread.sleep(interval);
          } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          }
          Iterator<MyTimerListener> it = l.iterator();
          while(it.hasNext())
          {
              ((MyTimerListener)it.next()).onTick();
          }
      }
    
  }
  MyTimer(long Interval)
  {
      interval=Interval;
  }
  public void addListener(MyTimerListener mtl)
  {
      if(!l.contains(mtl))
          l.add(mtl);
  }
  public void removeListener(MyTimerListener mtl)
  {
      if(l.contains(mtl))
          l.remove(mtl);
  }
  public void start()
  {
      Thread t = new Thread(this);
      t.start();
  }

}

MyTimerListerner interface responsible for handling the onTick event.

public interface MyTimerListener {
void onTick();
}

Implementation of MyTimer

android.os.Handler;

public class AttachedClass implements MyTimerListener {

  private MyTimer mt = new MyTimer(1);
  private Handler mHandler = new Handler();// Main thread attaaches this handler itself while it creates the instance of AttachedClass instance
  public void startAttachedClass()
  {
      mt.start();// start method creates a new thread and runs mt in it.
  }
  @Override
  public void onTick() {
      Runnable r = new Runnable() {
          public void run() {
              TextView1.setText("Text has setted");
          }
      };
      mHandler.post(r);// onTick event called by new thread which has been created in mt.start(). but TextView1 belonges to the main thread. In order to make handled setText method by new thread, Handler's post method has used which requires a Runnable(method) which will be run in main thread.
    
      }
}
}

You can leave your questions to the comment section. Than you..