Finger and Head Movement Support

Now copy two other files, TouchRotateActivity.java and Cube.java, at the end of TouchRotateActivity class, and add this method:

public boolean onGenericMotionEvent(MotionEvent e) {
    // this allows two-finger tap to exit the activity
    if ((e.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {
        finish();
        return true;
    }
     
    // this enables the surfaceview to handle touch event
    mGLSurfaceView.onTouchEvent(e);
    return true;
}

Add a new menu entry, OpenGLES Rotate, to launch the activity. Run GraphicsAnimationApp and select OpenGLES Rotate. Touch and move on the Glass touchpad, and you’ll see a cube rotating with your finger movement, as shown in Figure 9-6. (Again, to exit the activity, use a two-finger swipe down.)

The next and final graphics example is even cooler. Copy the RotationVectorDemo.java file to your project. You should check out http://developer.android.com/guide/topics/graphics/opengl.html and get some OpenGL ES for Android books (for example, Pro OpenGL ES for Android by Mike Smithwick and Mayank Verma or OpenGL ES 2 for Android by Kevin Brothaler) to understand the OpenGL ES code in the example (and other examples in this section), but you’ve already seen the sensor-related code, shown in Listing 9-5, in the previous chapter, which will also be used later in the chapter.

Listing 9-5.  Rotating Graphics with Glass Sensor

public class RotationVectorDemo extends Activity {
    private GLSurfaceView mGLSurfaceView;
    private SensorManager mSensorManager;
    private MyRenderer mRenderer;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        mSensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
 
        mRenderer = new MyRenderer();
        mGLSurfaceView = new GLSurfaceView(this);
        mGLSurfaceView.setRenderer(mRenderer);
        setContentView(mGLSurfaceView);
    }
 
    class MyRenderer implements GLSurfaceView.Renderer, SensorEventListener {
        private Cube mCube;
        private Sensor mRotationVectorSensor;
        private final float[] mRotationMatrix = new float[16];
 
        public MyRenderer() {
            // find the rotation-vector sensor
            mRotationVectorSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
 
            mCube = new Cube();
            // initialize the rotation matrix to identity
            mRotationMatrix[ 0] = 1;
            mRotationMatrix[ 4] = 1;
            mRotationMatrix [ 8] = 1;
            mRotationMatrix [12] = 1;
        }
 
        public void start() {
            // enable our sensor when the activity is resumed, ask for
            // 10 ms updates.
            mSensorManager.registerListener(this, mRotationVectorSensor, 10000);
        }
 
        public void stop() {
            // make sure to turn our sensor off when the activity is paused
            mSensorManager.unregisterListener(this);
        }
 
        public void onSensorChanged(SensorEvent event) {
            if (event.sensor.getType() == Sensor.TYPE _ROTATION_VECTOR) {
                SensorManager .getRotationMatrixFromVector(mRotationMatrix , event.values);
            }
        }
        ...
    }
}

The rotation vector sensor is a composite (also known as software) sensor because it uses three base sensors (accelerometer, gyroscope, and magnetometer) to measure the orientation (yaw, pitch, and roll) of a device. For more information, you should check out Chapter 8 and additional Android resources at https://source.android.com/devices/sensors/composite_sensors.html and http://developer.android.com/guide/topics/sensors/sensors_overview.html. In a game example later in this chapter, you’ll see how to use the measurement of rotation vector to display a cursor that moves with your Glass movement. This is the basis of a Glass game like Spellista.

To get a feeling of how your head movement can control the rotation of the 3D cube, simply run your app and select the Rotation Vector menu item; then move your head, and you’ll see all six sides of a cube, just like Figure 9-5.

Porting and Running the Demo Cocos2d-x App on Glass

These are the steps to run the sample C++ demo app that comes with Cocos2d-x 3.0:

1. Follow the how-to guide at www.cocos2d-x.org/wiki/How_to_run_cpp-tests_on_Android to get the sample app cpp-tests built.

   Note  You can skip the section “How to deploy it on your Android phone via command line” in the guide because you’ll import the project to Eclipse and install the app to Glass from Eclipse, but you may also want to test it on your other Android devices to get the feeling of how the demo runs. Also, you’ll need to cd <your-cocos2d-x-3.0>/build directory and run the command python android-build.py -p 19 cpp-tests instead of python android-build.py -p 10 cpp-tests as documented in the guide to build the app for Glass.

2. Follow the steps at www.cocos2d-x.org/wiki/How_to_Build_an_Android_Project_with_Eclipse to import the cpp-tests project and the libcocos2dx project to Eclipse. After this, you’ll see something like Figure 9-8 in Eclipse.

   

   Figure 9-8. Importing the CppTests demo and the libcocos2dx library projects to Eclipse

3. Select CppTests and run it as an Android application with your Glass connected and turned on; you’ll see something like Figure 9-9.

   

   Figure 9-9. Cocos2d-x 3.0 test app on Glass

   Unfortunately, tapping or swiping left or right won’t navigate the demo menu. And what makes it worse is if your Glass screen goes off, tapping it again would take you to the OK Glass home screen instead of this CppTests app. Although the purpose of running the app on Glass is to see what features of the game engine can run on Glass so you can make a better decision on whether to use the engine when developing your next Glass games, you should have the launchy app (https://github.com/kaze0/launchy) installed and use it to easily select the CppTests to run if your Glass goes off.

4. To enable user interaction for CppTests on Glass, you need to first modify the class implementation in the AppActivity.java file shown in Figure 9-8, as shown in Listing 9-6.

   Listing 9-6.  Enabling and Passing a Touch Event to Cocos2d-x View on Glass

   public class AppActivity extends Cocos2dxActivity {
       Cocos2dxGLSurfaceView glSurfaceView;
    
       public Cocos2dxGLSurfaceView onCreateView() {
           glSurfaceView = new Cocos2dxGLSurfaceView(this);
           glSurfaceView.setEGLConfigChooser(5, 6, 5, 0, 16, 8);
           return glSurfaceView;
       }
    
       public boolean onGenericMotionEvent(MotionEvent event) {
           if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) { // true if two-finger tap happens
               finish();
               return true;
           }
            
           glSurfaceView.onTouchEvent(event);
           return false;
       }
   }

   The changes are to make glSurfaceView, the view that shows each demo feature, an instance variable so in the GenericMotionEvent you can pass the touch event (except the double finger tap, which will finish the app) to the glSurfaceView.

5. To develop C++ code directly from Eclipse, you need to link the C++ source files in the Classes directory shown in Figure 9-10 to CppTests’s Classes folder in Eclipse.

   

   Figure 9-10. C++ source folder for the test project

   To do this, open the project properties, select C/C++ General, and then select Paths and Symbols. You’ll see the message “This project is not a CDT project” (CDT stands for C/C++ Development Tools), as shown in Figure 9-11.

   

   Figure 9-11. Showing Project Properties

   To fix this, click Cancel in the Properties window. In Eclipse, select File New Project and then select C/C++ C++ Project. Enter a dummy project name and hit Finish. Now select the dummy project’s Properties Resource to find its location. On Terminal, copy the .cproject file from that location to your CppTests app’s proj.android directory (<path-to-cocos2d-x-3.0>/tests/cpp-tests/proj.android). You can delete the dummy project from both Eclipse and the project contents on disk now.

6. Go back to CppTests Properties C/C++ General Paths and Symbols Source Location, click Link Folder, check “Link to folder in the file system,” click Browse, and select the Classes folder of CppTests (Figure 9-12).

   

   Figure 9-12. Linking C++ source folder to develop C++ code in Eclipse

   Click OK, and you’ll see the dialog in Figure 9-13. Click OK again, and Eclipse will show all the source folders under Classes, as in Figure 9-14.

   

   Figure 9-13. After Source Folder is Linked

   

   Figure 9-14. C++ source folders in Eclipse

7. Next, you need to modify the AppDelegate.cpp file in the Classes folder. But before you do this, you first need to fix the errors when you open the AppDelegate.cpp file. Eclipse, at least as of ADT version 22.6.2, incorrectly shows an error in the CppTests project and lots of errors in the AppDelegate.cpp file. If you try to build the CppTests application now (after you open the AppDelegate.cpp file), you’ll get the annoying “Your project contains error(s), please fix them before running your application.” error message. To fix this, open the CppTests’s Properties window, go to Code Analysis under C/C++ General, select “Use project settings,” and deselect Syntax and Semantic Errors, as shown in Figure9-15. This is important because otherwise you won’t be able to build the CppTests app from Eclipse after you make some C++ code change in Eclipse.

   

   Figure 9-15. Deselecting incorrect code analysis to enable project build in Eclipse

8. The changes you need to make to AppDelegate.cpp are pretty simple. In the applicationDidFinishLaunching method, before return true;, add the following two lines of code:

   auto s = new Box2dTestBedScene();
   s->runThisTest();

   Then add #include "Box2DTestBed/Box2dView.h" in the beginning of AppDelegate.cpp. Now open a Terminal window, cd to the cocos2d-x-3.0 build directory, and run the native C++ library build command.

   python android-build.py -p 19 cpp-tests

   After the “BUILD SUCCESSFUL” message, a new version of the CppTests library file, named libcpp_tests.so, will be available in the CppTests/libs/armeabi folder.

9. Now run the CppTests app again from Eclipse, and you’ll see CppTests’s Box2D sample running on Glass, as shown in Figure 9-16. Move your finger on the Glass touchpad to see the box move on Glass.

   

   Figure 9-16. Running Cocos2d-x Box2d test code on Glass

Ideally, you would be able to use a gesture to go back to MainMenu and easily test all the other cool features of Cocos2d-x on Glass. This may be available by the time you read the book. If so, I’ll post the link to the updated tutorial on the book’s site. For now, you can use steps 6 and 7 to experiment with all the other features demonstrated in CppTests. For example, to check out how ParticleTest runs on Glass, replace auto s = new Box2dTestBedScene(); with auto s = new ParticleTestScene(); in AppDelegate.cpp, add #include "ParticleTest/ParticleTest.h", build the C++ library, and run the CppTests app from Eclipse. You’ll see something like Figure 9-17.

After playing with CppTests, you should check out the Cocos2d-x wiki and API references at www.cocos2d-x.org for further information before you start using it to build your next Glass game. Before you move to the next game engine, let’s see how you can create a new Cocos2d-x app running on Glass.

Creating a New Cocos2d-x App on Glass

Follow these steps to create a Cocos2d-x app from scratch:

1. Follow the how-to guide at www.cocos2d-x.org/wiki/How_to_Start_A_New_Cocos2D-X_Game. To summarize, the commands I ran on my Mac are as follows:

   cd cocos2d-x-3.0
   ./setup.py
   source ~/.bash_profile
   cocos new MyGame -p com.myCompany.myGame -l cpp -d ./MyCompany
   cocos run -s ./MyCompany/MyGame -p android

2. In Eclipse, import the Android project located at MyCompany/MyGame/proj.android. After importing, if you see errors in the MyGame project and AppActivity.java, you need to fix the reference to libcocos2dx. Open the project’s properties, go to Android’s Library section, click Add, and then select libcocos2dx there. After that, you should see something like Figure 9-18.

   

   Figure 9-18. Adding the libcocos2dx library to a new app

3. Run the MyGame app on your Glass, and you’ll see the Cocos2d-x version of Hello World on Glass, as shown in Figure 9-19.

   

   Figure 9-19. Running Cocos2d-x Hello World app on Glass

4. If you click the Classes folder, which should contain all the C++ code for the game app, you’ll see it’s empty, but it’s located at MyCompany/MyGame, at the same level as the proj.android directory. You need to link the Classes directory to MyGame’s Classes folder in Eclipse, like you did in the previous section.  To do this, simply follow step 5 in the previous section. Or, in Eclipse, select File New Project..., then select C/C++ C++ Project, enter a dummy project name, and hit Finish. Now open the dummy project’s Properties Resource to find its location. On Terminal, copy the .cproject file from that location to your new game app’s proj.android directory (MyCompany/MyGame/proj.android).

   Now go back to MyGame’s Properties C/C++ General Paths and Symbols Source Location, click Link Folder, check Link to folder in the file system, click Browse, select the Classes folder of MyGame, and click OK.

5. If you open the AppDelegate.cpp file in Classes, you’ll see lots of errors. To fix this, follow step 7 in the previous section, as shown in Figure 9-15.
6. Open AppActivity.java and change its content to look like Listing 9-6.
7. Open HelloWorldScene.cpp and add the following code, most of which is borrowed from www.cocos2d-x.org/wiki/EventDispatcher_Mechanism but with some fixes, to the end of the HelloWorld::init() method, before return true;, as shown in Listing 9-7.

   Listing 9-7.  Adding Sprites with a Touch Event Listener for Cocos2d-x 3.0

   auto size = Director::getInstance()->getWinSize();
    
   auto sprite1 = Sprite::create("CloseNormal.png");
   sprite1->setPosition(origin+Point(size.width/2, size.height/2) + Point(-80, 80));
   addChild(sprite1, 10);
    
   auto sprite2 = Sprite::create("CloseNormal.png");
   sprite2->setPosition(origin+Point(size.width/2, size.height/2));
   addChild(sprite2, 20);
    
   auto sprite3 = Sprite::create("HelloWorld.png");
   sprite3->setPosition(Point(0, 0));
   sprite2->addChild(sprite3, 1);
    
   auto listener1 = EventListenerTouchOneByOne::create();
   listener1->setSwallowTouches(true);
    
   listener1->onTouchBegan = [](Touch* touch, Event* event){
       auto target = static_cast<Sprite*>(event->getCurrentTarget());
    
       //Get the position of the current point relative to the button
       Point locationInNode = target->convertToNodeSpace(touch->getLocation());
       Size s = target->getContentSize();
       Rect rect = Rect(0, 0, s.width, s.height);
    
       //Check the click area
       if (rect.containsPoint(locationInNode)) {
           target->setOpacity(180);
           return true;
       }
       return false;
   };
    
   //Trigger when moving touch
   listener1->onTouchMoved = [](Touch* touch, Event* event){
       auto target = static_cast<Sprite*>(event->getCurrentTarget());
       //Move the position of current button sprite
       target->setPosition(target->getPosition() + touch->getDelta());
   };
    
   //Process the touch end event
   listener1->onTouchEnded = [=](Touch* touch, Event* event){
       auto target = static_cast<Sprite*>(event->getCurrentTarget());
       target->setOpacity(255);
       //Reset zOrder and the display sequence will change
       if (target == sprite2)
           sprite1->setZOrder(100);
       else if(target == sprite1)
           sprite1->setZOrder(0);
   };
    
   _eventDispatcher ->addEventListenerWithSceneGraphPriority(listener1, sprite1);
   _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(), sprite2);
   _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1->clone(), sprite3);

8. Open a Terminal window, cd to MyGame’s proj.android directory, and run the python build_native.py command. You should see messages as follows:

   [armeabi] Compile++ thumb: cocos2dcpp_shared <= HelloWorldScene.cpp
   [armeabi] SharedLibrary  : libcocos2dcpp.so
   [armeabi] Install        : libcocos2dcpp.so => libs/armeabi/libcocos2dcpp.so

9. Return to Eclipse and run the MyGame app on Glass. This time, you can move around the image on the top of the Glass touchpad, as shown in Figure 9-20. Be aware that you have to drag on the right part of the touchpad to make the move work.

   

   Figure 9-20. Moving Cocos2d-x sprite on Glass

If you have any Cocos2d game development background, or even if you don’t, you can come up to speed with Cocos2d-x quickly. It has well-documented online resources and examples. What I hope to offer here is to show you how to run the engine and samples on Glass and interact with the engine so you can see the potential of using the great engine for your next Glass game project. To get inspired, take another look at many great games developed with the engine at www.cocos2d-x.org/games.

Creating a New libgdx App on Glass

Follow these steps:

1. Follow the document at https://github.com/libgdx/libgdx/wiki/Setting-up-your-Development-Environment-%28Eclipse%2C-Intellij-IDEA%2C-NetBeans%29 to set up Eclipse. Because you’ve been using Eclipse for your GDK development, chances are you need to install only JDK 7 (if you use JDK 6; you can find out by running java –version on Terminal). The last step of “Setting up Eclipse” is “Eclipse Integration Gradle.” Gradle (http://en.wikipedia.org/wiki/Gradle) is an automation build tool used by libgdx projects, and you also need to follow the steps at https://github.com/spring-projects/eclipse-integration-gradle, under “Installation instructions” and then “Installing Gradle Tooling from update site.”
2. Download gdx-setup.jar at http://libgdx.badlogicgames.com/download.html.
3. Double-click the gdx-setup.jar or run java -jar gdx-setup.jar in the Terminal or a command-line window to run the file, and in the libgdx Project Generator window, enter values for Name, Package, Game class, Destination, and Android SDK. Select Sub Projects and Extensions and click Generate, and you’ll see something like Figure 9-21.

   

   Figure 9-21. Setting up a new libgdx project

4. In Eclipse, select File Import Gradle Gradle Project, as shown in Figure 9-22.

   

   Figure 9-22. Importing a new Gradle project

5. Click Browse and choose the destination entered in Figure 9-21 of step 3. Then click Build Model. If you see error saying “SDK location not found,” you can fix this by creating a new file called local .properties in the Destination directory and entering this single line:

   sdk.dir=<your-path-to-adt>/sdk

   Then select Build Model again. You should see something like Figure 9-23.

   

   Figure 9-23. Importing a new libgdx project

6. Select the test project and click Finish; you’ll see two new projects in Eclipse: my-gdx-game-android and my-gdx-game-core.
7. Connect your Glass, keep the Glass screen on, and run the app. You’ll see the default home screen, as shown in Figure 9-24.

   

   Figure 9-24. Running the libgdx test app on Glass

Running and Playing libgdx Game on Glass

It’s great you’re able to run your first libgdx app on Glass, but it’d be more fun if you could play an actual libgdx game on Glass. Follow these steps to see how to do this:

1. Get one of the libgdx demo apps, namely, Vector Pinball, at https://github.com/libgdx/libgdx-demo-vector-pinball. This is a 2D pinball simulation game using Box2D, a 2D physics engine.
2. Follow steps 4 to 6 in the previous exercise to import the Vector Pinball project to Eclipse. Figure 9-25 shows the Import window.

   

   Figure 9-25. Importing the Vector Pinball libgdx game to Eclipse

3. In Eclipse, run libgdx-demo-vector-pinball-android on Glass. You’ll see the game UI, as shown in Figure 9-26.

   

   Figure 9-26. Running the Vector Pinball game on Glass

4. Unfortunately, you can’t play the game at all. It’s the unbearable pain of not being able to have fun while fun seems so close. The problem is in the core game source code of libgdx-demo-vector-pinball-core or, to be more specific, the Bouncy.java file that handles the UI touch event. You have to let Glass pass the touch event to it, as you’ve done several times earlier in the chapter. In the libgdx-demo-vector-pinball-android project, there’s a single source file called AndroidLauncher.java, which calls this line to actually launch the game:

   initialize(new Bouncy(), config);

   You need to replace the AndroidLauncher class implementation with the code in Listing 9-8.

   Listing 9-8.  Enabling UI interaction on Glass for libgdx Vector Pinball

   public class AndroidLauncher extends AndroidApplication {
       Bouncy mBouncy;
    
       @Override
       protected void onCreate (Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();
           mBouncy = new Bouncy();
           initialize(mBouncy, config);
       }
    
       public boolean onGenericMotionEvent(MotionEvent event) {
           switch (event.getActionMasked()) {
           case MotionEvent.ACTION_DOWN:
               mBouncy.touchDown(0, 0, 0, 0);
               break;
           case MotionEvent.ACTION_UP:
               mBouncy.touchUp(0, 0, 0, 0);
               break;
           case MotionEvent.ACTION_MOVE:
               mBouncy.touchDragged(0, 0, 0);
               break;
           }
           return true;
       }
   }

   You use an instance variable of mBouncy here so you can call its touchdown, touchup, and touchDragged event handlers defined in the core project’s Bouncy.java.

5. Now run the app again, and you’ll be able to play the vector pinball game perfectly fine on Glass.

libgdx is well documented at http://libgdx.badlogicgames.com/documentation.html and has been used to build hundreds of cool games. Now that you know how to create a new app or port an existing one in libgdx to Glass, you’re well positioned to consider it when developing your next Glass game app.

Running and Testing AndEngine Examples on Glass

Follow these steps to add and use the AndEngine library and run examples in Eclipse:

1. Get the AndEngine library at https://github.com/nicolasgramlich/AndEngine.
2. Import the AndEngine library downloaded to Eclipse, and that’s it. You now have the AndEngine library you can use in your game app.
3. Get the AndEngine examples project at https://github.com/nicolasgramlich/AndEngineExamples and most of the extensions listed at the Extensions section of the AndEngine GitHub location at https://github.com/nicolasgramlich/AndEngine (the extensions are needed to run the AndEngineExamples). After you import the examples project and all the extensions to Eclipse, you should see something like Figure 9-27 (you may need to add the AndEngine library to each of the extension projects if you get a library error on the extension’s properties).

   

   Figure 9-27. Importing the AndEngine library, examples, and extensions to Eclipse

4. Open the AndEngineExamples project’s properties, change Project Build Target to Glass Development Kit Preview, and then add the AndEngine library and all the extension libraries. Figure 9-28 shows what it looks like.

   

   Figure 9-28. Adding the AndEngine and Extension libraries to the AndEngineExamples

5. Now you can run AndEngineExamples on Glass and see the example UI as in Figure 9-29.

   

   Figure 9-29. Showing AndEngineExamples UI on Glass

6. Still, you can’t navigate the menu and see how all the examples work. To fix this, open ExampleLauncher.java in AndEngineExamples’s org.andengine.examples.launcher package. First add four instance variables before onCreate.

   private GestureDetector mGestureDetector;
   private ExpandableListActivity mList;
   private int mGroupPosition = 0;
   private int mChildPosition = 0;

   Then add two lines of code at the end of onCreate.

   mGestureDetector = createGestureDetector(this);
   mList = this;

   Finally, add the following two methods after onCreate.

   private GestureDetector createGestureDetector(Context context) {
     GestureDetector gestureDetector = new GestureDetector(context);
     gestureDetector.setBaseListener( new GestureDetector.BaseListener() {
         @Override
         public boolean onGesture(Gesture gesture) {
             if (gesture == Gesture.TAP) {
                 if (mList.getExpandableListView().isGroupExpanded(mGroupPosition)) {
                     if (mChildPosition >=0) {
                         final Example example = mExpandableExampleLauncherListAdapter.getChild(mGroupPosition, mChildPosition);
                         startActivity(new Intent(mList, example.CLASS));
                     }
                 }
                 else {
                     mList.getExpandableListView().expandGroup(mGroupPosition);
                     mChildPosition = 0;
                     mList.setSelectedChild(mGroupPosition, 0, true);
                 }
    
                 return true;
             } else if (gesture == Gesture.SWIPE_RIGHT) {
                 if (mList.getExpandableListView().isGroupExpanded(mGroupPosition)) {
                     if (mExpandableExampleLauncherListAdapter. getChildrenCount(mGroupPosition) > mChildPosition+1)
                         mList.setSelectedChild(mGroupPosition, ++mChildPosition, true);
                 }
                 else if ( mExpandableExampleLauncherListAdapter .getGroupCount() > mGroupPosition+1 )
                     mList.setSelectedGroup(++mGroupPosition);
                 return true;
             } else if (gesture == Gesture.SWIPE_LEFT) {
                 if (mList .getExpandableListView().isGroupExpanded(mGroupPosition)) {
                     if (mChildPosition > 0)
                         mList.setSelectedChild(mGroupPosition, --mChildPosition, true);
                     else {
                         mList.getExpandableListView().collapseGroup(mGroupPosition);
                         mList.setSelectedGroup(mGroupPosition);
                     }
                 }
                 else if (mGroupPosition > 0) {
                     mList.setSelectedGroup(--mGroupPosition);
                     mChildPosition = 0;
                 }
    
                 return true;
             }
             return false;
         }
     });
    
     return gestureDetector;
   }
    
   public boolean onGenericMotionEvent(MotionEvent event) {
     if (mGestureDetector != null) {
         return mGestureDetector.onMotionEvent(event);
     }
     return false;
   }

   The previous code enables the navigation and selection of the expanded list of examples. Tapping an unexpanded group expands it and highlights the first item in the group; tapping a highlighted item runs the example associated with it. Swiping right on an unexpanded group highlights the next group, unless it’s the last group. Swiping right on a highlighted group item highlights the next item in the group, unless it’s the last item in the group. Swiping left on an unexpanded group highlights the previous group, unless it’s the first group. Swiping left on a highlighted group item goes to the previous item, but if it’s already the first item in the group, then swiping left uncollapses and highlights the group. Swiping down on an example goes back to the navigation list. This is all intuitive actually; maybe I just got inspired by the phrase “BAD Logic” in Figure 9-24 and decided to describe the good logic for navigation in detail.

7. Now run the app again and try the examples. For example, if you choose A Cool ParticleSystem and A Nexus ParticleSystem (Figure 9-30) under ParticleSystems, you’ll see the effects shown in Figure 9-31.

   

   Figure 9-30. Navigating AndEngine example list on Glass

   

   Figure 9-31. Showing AndEngine’s particle effects on Glass

If you choose an example that requires touch event handling, you still need to make some code change in the xxxExample.java file. For example, if you select the second item, Using Physics, under Physics, you’ll need to add code like the following in PhysicsExample.java of the org.andengine.examples package to make the touch work:

public boolean onGenericMotionEvent(MotionEvent event) {
    if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
        this.addFace(event.getX(), event.getY());
    }
         
    return false;
}

You’ve already seen examples of enabling touch in previous sections of this chapter, and you’re about to explore how to use a Glass sensor and head gesture, more fitting for Glass in some cases, to control the UI, so I’ll leave this to you to experiment with. Before I discuss how to enable head gesture for a game, let’s first quickly check out a game built with AndEngine. I’ll show you how to improve the game using a Glass sensor after that.

An AndEngine-based Tower of Hanoi Game

www.raywenderlich.com/12065/how-to-create-a-simple-android-game is a nice tutorial on how to use AndEngine to create a simple Android game. Download the project’s source code from the link at the end of the tutorial, unzip and import it to Eclipse, and fix the library issue if necessary by adding the AndEngine library project in the TowerOfHanor project’s properties.

If you run the app now in a non-Glass Android device or a virtual device, you can play the game. Run it on Glass, however, and you see only a static scene of the game. You can either use onGenericMotionEvent, as you’ve done in this chapter, to enable touch handling, or use the Glass sensor to create a hands-free experience, as I’ll describe in the next section.