I have just created a very simple Android version of my `Bouncing Ball' sketch: a little ball bounces around your phone's screen, move it with your finger or by moving your phone.

This is a trivial example of course, based on information from the Wiki and this forum. However, seeing the complete code of such an example might help the absolute beginner (i.e. someone like me).

The app is on the market (free and no ads of course) here:
https://play.google.com/store/apps/details?id=processing.test.bouncingball

The source code is available below or at
http://www.gwoptics.org/processing/android/BouncingBall/

Andreas

1. /*
2.  * Bouncing Ball, a simple example for an Android app made with
3.  * This app has been tested with Processing 2.05a, Android SDK 17
4.  * on a Nexus 1 device. Andreas Freise 27.03.2012
   
5.   */
6. 
   
7. import ketai.sensors.*;
8. KetaiSensor sensor;
9. float accelerometerX, accelerometerY;
10. // some global variables to simplify matters
11. boolean rest;
12. boolean showinfo;
13. boolean screenpressed;
14. float fps=60; // frames per second for frameRate() command
15. Ball ball;
16. void setup()
17. {
18.   size(screenWidth, screenHeight, P3D);
19.   orientation(LANDSCAPE);
20.   frameRate(fps);  // set framerate explicitly
21.   ball = new Ball(screenWidth/2.0, screenHeight/2.0);
22.   // init global variables
23.   rest=false;
24.   screenpressed=false;
25.   showinfo=false;
26.   // for text output we might need to set some text properties
27.   textAlign(CENTER, CENTER);
28.   textSize(36);
29. }
30. void draw()
31. {
32.   background(0);
33.   ball.move();
34.   ball.display();
35.   if (showinfo) {
36.     pushStyle();
37.     fill(200);
38.     text("Bouncing Ball: \n" +
39.       "A simple example app made with Processing\n" +
40.       "See http://www.gwoptics.org for more!", screenWidth/2.0, screenHeight/2.0);
41.     popStyle();
42.   }
43.   // if the phone has been shaken,
44.   // wake up the ball
45.   if (accelerometerX*accelerometerX+accelerometerY* accelerometerY>12*12) {
46.     rest=false;
47.   }
48. }
49. /*
50.  * Read the touch events to simply know when a finger is
51.  * on the screen or not.
52.  */
53. public boolean surfaceTouchEvent(MotionEvent me) {
54.   final int action = me.getAction() & MotionEvent.ACTION_MASK;
55.   if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN)
56.   {
57.     rest=false;    // if screen has been pressed, wake up ball
58.     screenpressed=true;
59.     ball.reset(mouseX, mouseY, 0, 0); // set ball position to finger
60.   }
61.   else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP)
62.   {
63.     screenpressed=false;
64.     ball.reset(mouseX, mouseY, 2*(mouseX-pmouseX), 2*(mouseY-pmouseY)); // throw ball!
65.   }
66.   return super.surfaceTouchEvent(me);
67. }
68. /* Read accelerometer data and set two gloabal variables */
69. void onAccelerometerEvent(float x, float y, float z)
70. {
71.   accelerometerX = x;
72.   accelerometerY = y;
73. }
74. /* Check for MENU button */
75. void keyPressed() {
76.   if (key == CODED) {
77.     if (keyCode == MENU) {
78.       if (showinfo) {
79.         showinfo=false;
80.       }
81.       else {
82.         showinfo=true;
83.       }
84.       keyCode=1;
85.     }
86.   }
87. }
88. /* Override the parent (super) Activity class:
89.  * States onCreate(), onStart(), and onStop() aren't called by the sketch. 
90.  * Processing is entered at onResume() and exits at onPause()
91.  */
92. public void onResume(){
93.   super.onResume();
94.   sensor = new KetaiSensor(this); // init sensors
95.   sensor.start(); // start sensors
96. } 
97. public void onPause() {
98.   sensor.stop(); // stop sensors when skecht is paussed/quit
99.   super.onPause();
100. }

And the Ball class:

1. public class Ball
2. {   
3.   // some local variables of the ball
4.   float x;
5.   float y;
6.   float xold;
7.   float yold;
8.   float xspeed;
9.   float yspeed;
10.   float phi;
11.   float phispeed;
12.   float gravity;
13.   float friction;
14.   float phifriction;
15.   float wallfriction;
16.   float slowing;
17.   float reverseSpeed;
18.   float slowSpeed;
19.   PImage ball;
20.   float xmin;
21.   float ymin;
22.   float xmax;
23.   float ymax;
24.   float phiscale;
25.   Ball(float tempX, float tempY)
26.   {
27.     rest = false;
28.     x = tempX;
29.     y = tempY;
30.     xspeed = 0;
31.     yspeed = 0;
32.     phi = 0;
33.     phispeed = 0;
34.     slowing=0.0;
35.     gravity = 0.6*30.0/fps;
36.     friction = 0.98;
37.     phifriction = 0.99;
38.     wallfriction=0.5;
39.     reverseSpeed = -0.98;
40.     slowSpeed = 0.98;
41.     ball=loadImage("ball.png");
42.     xmin = 0;
43.     ymin = 0;
44.     xmax = width-ball.width;
45.     ymax = height-ball.height;
46.     phiscale =2.0/(ball.height);
47.   }
48.   void reset(float newX, float newY, float newXspeed, float newYspeed)
49.   {
50.     x=newX;
51.     y=newY; 
52.     xspeed=newXspeed;
53.     yspeed=newYspeed;
54.     xold=x-xspeed;
55.     yold=y-yspeed;
56.   }
57.   void move()
58.   {
59.     /* if ball is not at rest, check for motion and collisions */
60.     if (!rest && !screenpressed)
61.     {     
62.       xold=x;
63.       yold=y;
64.       y=y+yspeed;
65.       x=x+xspeed;
66.       phi=phi+phispeed;
67.       if (y >= ymax)
68.       {
69.         yspeed = yspeed * reverseSpeed;
70.         xspeed = xspeed * slowSpeed;
71.         y = ymax;
72.       }
73.       if (y <= ymin)
74.       {
75.         yspeed = yspeed * reverseSpeed;
76.         xspeed = xspeed * slowSpeed;
77.         y = ymin;
78.       }
79.       if (x >= xmax)
80.       {
81.         xspeed = xspeed * reverseSpeed;
82.         yspeed = yspeed * slowSpeed;
83.         x = xmax;
84.       }
85.       if (x <= xmin)
86.       {
87.         xspeed = xspeed * reverseSpeed;
88.         yspeed = yspeed * slowSpeed;
89.         x = xmin;
90.       }
91.       /* change speed due to acceleration */
92.       xspeed=xspeed+gravity * accelerometerY;
93.       yspeed=yspeed+gravity * accelerometerX;
94.       /* apply frcition */
95.       xspeed=friction*xspeed;
96.       yspeed=friction*yspeed;
97.       /* if we are in contact with a wall, set rotational speed */
98.       if (y >= ymax)
99.       {
100.         phispeed=wall_speed(phispeed, x-xold);
101.       }
102.       if (y <= ymin)
103.       {
104.         phispeed=wall_speed(phispeed, -1.0*(x-xold));
105.       }
106.       if (x >= xmax)
107.       {
108.         phispeed=wall_speed(phispeed, -1.0*(y-yold));
109.       }
110.       if (x <= xmin)
111.       {
112.         phispeed=wall_speed(phispeed, y-yold);
113.       }
114.       phispeed=phifriction*phispeed;
115.       /* check if ball is still moving */
116.       if ( y==yold && x==xold && phispeed<1)
117.       {
118.         slowing=slowing+1;
119.       }
120.       else
121.       {
122.         slowing=0.0;
123.       }
124.       /* wait roughly 2 seconds before setting ball to rest */
125.       if (slowing>2*fps) {
126.         rest=true; 
127.         slowing=0.0;
128.       }
129.     }
130.     else {
131.       if (screenpressed) {
132.         x=mouseX;
133.         y=mouseY;
134.       }
135.     }
136.   }
137.   void display()
138.   {   
139.     pushStyle();
140.     pushMatrix();
141.     stroke(255);
142.     float offsetX=x+ball.width/2;
143.     float offsetY=y+ball.height/2;
144.     translate(offsetX, offsetY);
145.     rotate(phi);
146.     translate(-offsetX, -offsetY);
147.     image(ball, x, y);
148.     popMatrix();
149.     popStyle();
150.   }
151.   float wall_speed(float oldphispeed, float speed2) {
152.     return wallfriction*oldphispeed+(1-wallfriction)*speed2*phiscale;
153.   }
154. }