Create a new interface by selecting File | New Java Class. In the Name section type GameEngineBroadcaster. In the Type section drop-down selector choose Interface. Select Package private and then click the OK button to generate the empty interface.

Here is the entire code for the GameEngineBroadcaster interface with its single empty method called addObserver that takes an InputObserver as a parameter. The code to type is shown next highlighted amongst the code which was auto-generated.

interface GameEngineBroadcaster {

   void addObserver(InputObserver o);
}

Next, we will code the second interface of our Observer pattern the actual Observer called InputObserver.

Create a new interface by selecting File | New Java Class. In the Name section type InputObserver. In the Type section drop-down selector choose Interface. Select Package private and then click the OK button to generate the empty interface.

Here is the entire code for the InputObserver interface with its single empty method called handleInput that takes a MotionEvent, GameState and an ArrayList containing the position of the controls as parameters. The code to type is shown next highlighted amongst the code which was auto-generated.

import android.graphics.Rect;
import android.view.MotionEvent;
import java.util.ArrayList;

interface InputObserver {

    void handleInput(MotionEvent event, GameState gs,
         ArrayList<Rect> controls);
}

Next, we will implement/use the new GameEngineBroadcaster interface.

Add the GameEngineBroadcaster to the list of interfaces that the GameEngine class implements.

class GameEngine extends SurfaceView implements Runnable, 
   GameStarter, GameEngineBroadcaster {

On screen you will observe the line with the new code will be underlined in red until we implement the required method of the interface. So, let's do that now. We also need to have a way of storing all our InputObservers. An ArrayList will do the job.

Declare and initialize a new empty ArrayList that holds objects of type InputObserver as highlighted next as a member of the GameEngine class.

private Thread mThread = null;
private long mFPS;

private ArrayList<InputObserver>
   inputObservers = new ArrayList();

private GameState mGameState;
private SoundEngine mSoundEngine;
HUD mHUD;
Renderer mRenderer;

Now implement the addObserver method as required by any class implementing the GameEngineBroadcaster interface. I put mine right after the constructor in GameEngine. Here is the method to add.

// For the game engine broadcaster interface
public void addObserver(InputObserver o) {
   
   inputObservers.add(o);
}

Finally, before we make our first InputObserver which can register for broadcasts, we will add the code that will call all the InputObservers' handleInput methods. Add this highlighted code in the onTouchEvent method.

@Override
public boolean onTouchEvent(MotionEvent motionEvent) {
   // Handle the player's input here
   // But in a new way
   for (InputObserver o : inputObservers) {
         o.handleInput(motionEvent, mGameState, 
                mHUD.getControls());
   }   

   return true;
}

The code loops through all the InputObservers in the ArrayList and calls their handleInput method (which they are guaranteed to have implemented). If there is zero, just one or 1000 Observers in the ArrayList the code will work just the same.

Next, we will implement/use the new InputObserver interface at the same time as handling the screen touches for the user interface.