System Requirements

You can develop GDK Glassware with the ADT or Eclipse IDE on a computer running Windows, Mac, or Linux with the following requirements (see http://developer.android.com/sdk/index.html for more details):

• Intel-based Mac OS X 10.5.8 or newer
• Windows XP (32-bit), Vista (32/64-bit), or Windows 7 (32/64-bit) or newer
• Linux (preferably Ubuntu Linux 8.04 or newer)

Android Developer Tools

The ADT Bundle is Google’s recommended tool for developing Android and GDK apps quickly. If you’re an experienced developer, you should be able to follow the instructions at http://developer.android.com/sdk and get it installed in less than an hour. If you experience any issues and can’t find the right answers on Google, you can refer to the following steps.

Enabling Debugging Mode on Glass

To get your Glass ready for development purpose, you need first to enable USB debugging on Glass. After you turn on Glass and see the OK Glass menu, swipe your Glass backward on the touchpad until you see Settings; then, tap it and swipe forward to find “Device info,” as shown in Figure 2-5. Tap again and swipe to find and select “Turn on debug.” Now connect Glass to your computer via USB.

The adb Command

Android Debug Bridge (adb) is a handy command-line tool that you’ll use to communicate with Glass. Its main uses are listing connected Android devices (adb devices), browsing the device folders (adb shell), installing and uninstalling apps (adb install and adb uninstall), and copying files (adb pull and adb push). As a Glass developer, you should definitely check out its documentation at http://developer.android.com/tools/help/adb.html and get familiar with it.

Before you can run the adb command, you need to add the path to ADT’s platform-tools directory to your system’s PATH variable. If you use Windows, update the PATH variable at Start Control Panel System and Security System Advanced system settings Advanced Environment Variables System Variables. If you use Mac or Linux, update your PATH variable in ~/.bashrc to be like this:

PATH=$PATH:<path-to-adt-folder>/sdk/platform-tools

Now launch a terminal window on Mac or Linux, and run the following command; you’ll see your Glass listed as shown here:

adb devices
List of devices attached
015xxxxxxxx17xxx device

Installing the USB Driver on Windows

Unfortunately on Windows, most likely you won’t see any devices listed with the adb devices command. This is because if you’re developing on Mac or Linux, you don’t need to install a USB driver, but on Windows, you need to manually install the right USB driver. The steps are as follows:

1. Download the Google USB Driver package for Windows at http://developer.android.com/sdk/win-usb.html; you can either download the ZIP file at the URL directly or use ADT’s Android SDK Manager and select the Google USB Driver package to download, as shown in Figure 2-6.

   

   Figure 2-6. Installing Google USB Driver for Windows

2. Unzip the file to a location you choose and find the usb_driver folder; or if you use the Android SDK Manager to download the driver, you can find your auto-unzipped files in ADT’s sdkextrasgoogleusb_driver folder.
3. Double-click the android_winusb.inf file in the usb_driver folder and add the following lines to the [Google.NTx86] and [Google.NTamd64] sections:

   ;Google Glass
   %SingleAdbInterface% = USB_Install, USBVID_18D1&PID_9001&REV_0216
   %CompositeAdbInterface% = USB_Install, USBVID_18D1&PID_9001&MI_01

   You may want to verify those seemingly magic values by these steps: Right-click Computer and select Manage. Then select Device Manager, and on the right panel under Other Devices, right-click Glass 1 and switch to the Details tab. Finally, select Hardware Ids Property; now you should see something like Figure 2-7 and Figure 2-8. (You need to make the previous code lines the same as the values in Figure 2-8.)

   

   Figure 2-7. Device Manager on Windows

   

   Figure 2-8. Values for Google Glass USB setup info file on Windows

4. Save the android_winusb.inf file, right-click Glass 1, and choose Update Driver Software Browse my computer for driver software. Choose the path to the usb_driver folder described in step 2 and dismiss the warning message; you should see the message “Windows has successfully updated your driver software.” Your Glass1 device will also be changed to Android Composite ADB Interface.

   Note  Steps 3 and 4 were tested on Windows 7. For Windows XP and Vista, you may want to check the document at http://developer.android.com/tools/extras/oem-usb.html#InstallingDriver for more details.

5. Open a command prompt window on Windows and run adb devices to verify your Glass is listed. You may have to run the command adb kill-server first and then adb devices to see your Glass listed. If you see a message saying “’adb’ is not recognized as an internal or external commands,” you should check your PATH variable as described earlier in “The adb Command.”

Showing the Glass Screen on a Bigger Screen

You can use tools to show your Glass screen on your computer running Mac, Windows, or Linux. This can make your development easier because you can look at the bigger computer screen most of the time instead of the small Glass screen. It can also make your demo, presentation, or training sessions much easier.

Before you continue, you should verify that the adb command, discussed in the previous section, works fine and shows your Glass in the “List of devices attached” area or the following tools won’t work.

There are at least two good tools to use here. You can download the latest Droid@Screen version at http://droid-at-screen.ribomation.com/download or Android Screen Monitor at https://code.google.com/p/android-screen-monitor. Droid@Screen has a better UI, but Android Screen Monitor has better frame rate. After downloading one of them (and unzipping it for Android Screen Manager), you can run one of the following commands to see on your computer something like Figure 2-9 and Figure 2-10:

java -jar droidAtScreen-1.0.2.jar
 
java -jar ASM_2_50/asm.jar

Another great way to see your Glass screen content on a bigger screen is to install the MyGlass app on any Android and iOS device (preferably tablets) and use its Screencast feature. There are two ways to activate Screencast: You can pair with Glass via Bluetooth and turn on Personal Hotspot, or you can connect Glass and your Android/iOS devices to the same wi-fi network.

Developing with Simulated Devices or Emulators

If you have some experience with Android or iOS app development, most likely you have used simulators to speed up your development. The bad news is that there is no official support from Google for the Glass development with emulators or Android devices; the good news is that because Glass is an Android device, theoretically you can just extract the .apk files from the system image of Glass and install them to your non-Glass Android. The web page www.elekslabs.com/2013/11/google-glass-development-without-glass.html is a summary but hasn’t been updated for the GDK release as of May 2014.

Although there are some developers who don’t own Glass but are interested in learning Glass development, I decided not to cover the GDK Glass development with simulated devices in this book for two main reasons. A lot of non-Glass-development-related hacks would be needed, and the time spent there can be better used for learning about the exciting GDK and Mirror API development. In addition, by the time you are reading this book, chances are Google will have made, or soon make, Glass publicly available at an acceptable price of several hundred dollars. Google will likely also release an official way to do Glass development on emulators or other Android devices.

Testing with GDK Samples

Finally, you’re ready to see some samples working on Glass, whether you use Mac, Linux, or Windows. Compared to what it takes to get the development environment set up correctly, especially on Windows and Linux, and configure the Glass USB Driver package on Windows, testing the GDK samples is a lot easier. (After all, there’s a balance in everything.) Whether you’re an Android expert or beginner, just follow the well-documented GDK Quick Start instructions at https://developers.google.com/glass/develop/gdk/quick-start to install the Android 4.4.2 (API 19) SDK, the Glass Development Kit Preview add-on, and the three GDK samples (Compass, Stopwatch, and Timer).

After you select a sample from Eclipse to run as an Android app, if you have Glass connected to your computer via USB, you’ll see your Glass shown as a running Android device, as in Figure 2-11.

Select the google-glass_1-xxx device and click OK; you’ll see the sample app gets installed to your Glass. Figure 2-12 shows the console output after running the Timer sample.

Now tap Glass, say “OK Glass,” and then say “Start a timer.” The Timer app will get launched on Glass, displaying 00:00:00 for hour:minute:second. Tap the Glass touchpad, and the first menu item, “Set timer,” appears. Swipe forward, and you’ll see the Stop menu item. Figure 2-13 shows both screens.

Tap the “Set timer” menu item; you’ll see the hours text with the first two 0s highlighted. Tap again to see 00 in a large font size centered in a new screen. You can swipe left and right to choose a value between 00 and 23. After you tap a number, it becomes your selected hour. You can then swipe to select minutes and seconds. Figure 2-14 shows the timer information before and after setting it (with 2 hours 30 minutes).

Now swipe down on the touchpad, and you’ll see the set timer 02:30:00; tap again, and this time a new menu item, Start, appears. Tap it, and you’ll see the timer gets updated every second. Tapping one more time will show the new menu items Pause, Reset, Change time, and Stop. Figure 2-15 shows two of these menu items.

To play more with Glass, you can run the other two samples Compass and Stopwatch in the same way. You should also look into the samples’ source code. If you’re like me when I started to learn Glass GDK development, you probably hope there’s a step-by-step tutorial on how to create such a GDK app. That is exactly what you’ll get in the next section of this chapter.

Step-by-Step Tutorial

Follow these steps to build a generic GDK template app that will be used as the basis to build your first HelloGlass app and all the GDK apps in the coming chapters:

1. Launch Eclipse.
2. In ADT’s Package Explorer, right-click to show the menu and then select Import. (You can also select File Import.)
3. Select Android Existing Android Code Into Workspace and then click Next.
4. In the Import Projects window, click Browse and select the GlasswareTemplate folder in the source code directory that comes with the book. Keep all the other defaults (the window should look like Figure 2-16) and click Finish.

   

   Figure 2-16. Importing GlasswareTemplate project to ADT

   Note  You may notice some slight differences between your Eclipse screens and the following screenshots. This is because the ADT looks on Mac, Windows, and Linux are not 100 percent the same, but the difference is so insignificant (for example, the order of Cancel and Finish buttons is different) that you shouldn’t have any trouble following the tutorial.

5. An error may occur because an incorrect target could be set as Project Build Target when the project was imported. To fix this, simply right-click GlasswareTemplate in ADT’s left Package Explorer panel, select Properties, and then change Project Build Target to Glass Development Kit Preview, as shown in Figure 2-17. Click OK, and you’re ready to run the template Glassware.

   

   Figure 2-17. Fixing possible project target error after importing

6. Connect Glass to your computer and turn it on if you haven’t (you may want to verify your Glass is connected by running adb devices). Right-click GlasswareTemplate and select Run As Android Application. You’ll see the Android Device Chooser window with your Glass; select it and click OK.
7. You should see a message that says “/GlasswareTemplate/bin/GlasswareTemplate.apk installed on device” in ADT’s console.

   Note  Sometimes after you import the GDK template app to Eclipse or create a new project based on it, you may get an error message when building the app: “Unable to execute dex: java.nio.BufferOverflowException.” You can fix this by right-clicking the project and then selecting Android Tools and Add Support Library.

8. Tap your Glass, say “OK Glass,” and then say “Glassware.” Or tap the OK Glass screen and then tap again when you see #glassware#, which should be the first item in the menu (starting with XE 16, recent and frequently visited items are placed first). GlasswareTemplate will run and show the main screen with the “Hello Glass!” text. Tap it and swipe, and you’ll see the menu items STOP, TTS (for text-to-speech), ASR (for automated-speech-recognition). Tap STOP to close the app; tap TTS to listen to “Hello Glass!”; tap ASR and say “Hello Glass.” Glass will recognize your speech!

Congratulations! You have the generic Glassware template app up and running.

Next, follow these steps to build and test HelloGlass, your first GDK app created based on the template app. I’ll then explain the project, files, and code for both HelloGlass and GlasswareTemplate in detail in the next section.

1. In ADT, select File New Android Application Project and enter the information shown in Figure 2-18.

   

   Figure 2-18. Creating your HelloGlass GDK app based on the template app

2. Click Next three times and keep all the default settings.
3. Uncheck Create Activity on the Create Activity screen, as shown in Figure 2-19, and then click Finish.

   

   Figure 2-19. Changed setting for your HelloGlass app

4. Open GlasswareTemplate, as shown in Figure 2-20; the files showing are to be copied to your HelloGlass app.

   

   Figure 2-20. GlasswareTemplate project folders

5. Right-click the HelloGlass app’s src, folder, select New Package, and enter the name shown in Figure 2-21 (or change the package name to be other name you like better); click Finish.

   

   Figure 2-21. Creating a new package name for HelloGlass

6. In Eclipse, copy the four files from GlasswareTemplate’s src folder and paste them to HelloGlass’s src folder. The first line in the four files of HelloGlass’s src folder should have been changed automatically by Eclipse from com.morkout.glasswaretemplate to com.morkout.helloglass; if not, change them manually. Ignore the errors in the HelloGlass project; they’ll all be fixed soon in the following steps.
7. In Eclipse, copy the drawable, menu, and xml folders in GlasswareTemplate’s res folder and paste them to HelloGlass’s res folder; then copy the files in GlasswareTemplate’s res, layout, and values folders and paste them to HelloGlass’s res, layout, and values folders (you need to overwrite the strings.xml and styles.xml files in the HelloGlass res, layout, and values folders when you copy and paste). Replace the whole <application> ... </application> section in HelloGlass’s AndroidManifest.xml with that in GlasswareTemplate’s AndroidManifest.xml. Change android:name’s value in the service tag from com.morkout.glasswaretemplate.AppService to com.morkout.helloglass.AppService, and change android:name’s value in the activity tag from com.morkout.glasswaretemple.MenuActivity to com.morkout.helloglass.MenuActivity.
8. Copy the line <uses-permission android:name="com.google.android.glass.permission.DEVELOPMENT" />from GlasswareTemplate’s AndroidManifest.xml file to HelloGlass’s AndroidManifest.xml file. This is something new in XE 16 or later and is required when you develop your GDK apps; see https://developers.google.com/glass/develop/gdk/starting-glassware for more details.
9. Finally, change the string value for say_glasswaretemplate in HelloGlass’s res/values/strings.xml file to #helloglass#. Run HelloGlass as an Android application while Glass is connected and turned on. You’ll see on your computer something like Figure 2-11 and Figure 2-12. Then on your Glass, you’ll see your #helloglass# app in the app list on the OK Glass screen. Tap the app to start it and see “Hello Glass,” where you can tap and then swipe to see the menu like in the GlasswareTemplate app.

What’s Going On

Now that you have both the template Glassware and HelloGlass app running, it’s time to delve into the details of the projects. Let’s first take a look at the big picture.

package com.morkout.glasswaretemplate;
 
import android.content.Context;
import android.graphics.Canvas;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.View;
 
public class AppDrawer implements SurfaceHolder.Callback {
    private static final String TAG = "AppDrawer";
    private final AppViewer mView;
    private SurfaceHolder mHolder;
 
    public AppDrawer(Context context) {
        mView = new AppViewer(context);
    }
 
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // Measure and layout the view with the canvas dimensions.
        int measuredWidth = View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY);
        int measuredHeight = View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY);
        mView.measure(measuredWidth, measuredHeight);
        mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());
        draw(mView);
    }
 
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        mHolder = holder;
        mView.start();
        draw(mView);
    }
 
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        mHolder = null;
    }
 
    private void draw(View view) {
        Canvas canvas;
        try {
            canvas = mHolder.lockCanvas();
        } catch (Exception e) {
            return;
        }
        if (canvas != null) {
            view.draw(canvas);
            mHolder.unlockCanvasAndPost(canvas);
        }
    }
}

package com.morkout.glasswaretemplate;
 
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
 
import com.google.android.glass.timeline.LiveCard;
import com.google.android.glass.timeline.LiveCard.PublishMode;
 
public class AppService extends Service {
 
    private static final String TAG = "AppService";
    private static final String LIVE_CARD_ID = "HelloGlass";
 
    private AppDrawer mCallback;
    private LiveCard mLiveCard;
 
    @Override
    public void onCreate() {
        super.onCreate();
    }
 
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
 
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (mLiveCard == null) {
            mLiveCard = new LiveCard(this, LIVE_CARD_ID);
            mCallback = new AppDrawer(this);
            mLiveCard.setDirectRenderingEnabled(true).getSurfaceHolder().addCallback(mCallback);
            Intent menuIntent = new Intent(this, MenuActivity.class);
            mLiveCard.setAction(PendingIntent.getActivity(this, 0, menuIntent, 0));
 
            mLiveCard.publish(PublishMode.REVEAL);
        }
 
 
        return START_STICKY;
    }
 
    @Override
    public void onDestroy() {
        if (mLiveCard != null && mLiveCard.isPublished()) {
            if (mCallback != null) {
                mLiveCard.getSurfaceHolder().removeCallback(mCallback);
            }
            mLiveCard.unpublish();
            mLiveCard = null;
        }
        super.onDestroy();
    }
 
 
}

package com.morkout.glasswaretemplate;
 
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.widget.FrameLayout;
import android.widget.TextView;
 
public class AppViewer extends FrameLayout {
    private final TextView mTextView;
 
 
    public AppViewer(Context context) {
        this(context, null, 0);
    }
 
    public AppViewer(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
 
    public void start() {
    }
 
    public AppViewer(Context context, AttributeSet attrs, int style) {
        super(context, attrs, style);
        LayoutInflater.from(context).inflate(R.layout.start, this);
 
        mTextView =  (TextView) findViewById(R.id.hello_view);
        mTextView.setText("Hello Glass!");
    }
 
}

package com.morkout.glasswaretemplate;
 
import java.util.Locale;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.speech.RecognizerIntent;
import android.speech.tts.TextToSpeech;
import android.speech.tts.TextToSpeech.OnInitListener;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
 
public class MenuActivity extends Activity implements OnInitListener {
    private TextToSpeech tts;
    private boolean mAttachedToWindow;
    private boolean mTTSSelected;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mTTSSelected = false;
    }
 
    @Override
    public void onAttachedToWindow() {
        super.onAttachedToWindow();
        mAttachedToWindow = true;
        openOptionsMenu();
    }
 
    @Override
    public void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        mAttachedToWindow = false;
    }
 
    @Override
    public void openOptionsMenu() {
        if (mAttachedToWindow) {
            super.openOptionsMenu();
        }
    }
 
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.main, menu);
        return true;
    }
 
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case R.id.stop:
            stopService(new Intent(this, AppService.class));
            return true;
 
        case R.id.tts:
                    mTTSSelected = true;
                    tts = new TextToSpeech(this, this);
                    tts.setOnUtteranceProgressListener(new UtteranceProgressListener() {
                    // 1
                        @Override
                        public void onDone(String utteranceId) {
                            if (tts != null) {
                                tts.stop();
                                tts.shutdown();
                            }
                            finish();
                        }
 
                        @Override
                        public void onError(String utteranceId) {
                        }
 
                        @Override
                        public void onStart(String utteranceId) {
                        }
                    });
            return true;
 
        case R.id.asr:
            Intent i = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
            startActivityForResult(i, 0);
            return true;
 
        default:
            return super.onOptionsItemSelected(item);
        }
    }
 
    @Override
    public void onOptionsMenuClosed(Menu menu) {
        if (!mTTSSelected)
            finish();
    }
 
    @Override
    public void onInit(int status) {
        if (status == TextToSpeech.SUCCESS) {
            int result = tts.setLanguage(Locale.US);
            if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
            } else {
                            HashMap<String, String> map = new HashMap<String, String>();
                            map.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID,"helloID");
                            // 2
                               tts.speak("Hello Glass!", TextToSpeech.QUEUE_FLUSH, map);
                            // 3
            }
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android "
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/black" >
 
    <TextView
        android:id="@+id/hello_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center"
        android:layout_marginTop="-10px"
        android:gravity="center"
        android:textSize="100px" />
</FrameLayout>

<?xml version="1.0" encoding="utf-8"?>
 
<menu xmlns:android="http://schemas.android.com/apk/res/android ">
    <item
        android:id="@+id/stop"
        android:title="@string/stop"
        android:icon="@drawable/ic_stop" />
         
    <item
        android:id="@+id/tts"
        android:title="@string/tts"
        android:icon="@drawable/ic_tts" />
     
    <item
        android:id="@+id/asr"
        android:title="@string/asr"
        android:icon="@drawable/ic_asr" />
</menu>

<?xml version="1.0" encoding="utf-8"?>
 
<resources>
    <string name="app_name">Glassware!!!</string>
    <string name="say_glasswaretemplate">#Glassware#</string>
    <string name="glass_voice_prompt">Say Glassware Template to trigger the glassware</string>
    <string name="stop">STOP</string>
    <string name="tts">TTS</string>
    <string name="asr">ASR</string>
</resources>
      

<?xml version="1.0" encoding="utf-8"?>
 
<trigger keyword="@string/say_glasswaretemplate" >
</trigger>

<manifest xmlns:android="http://schemas.android.com/apk/res/android "
    package="com.morkout.glasswaretemplate"
    android:versionCode="5"
    android:versionName="1.0" >
 
    <uses-sdk
        android:minSdkVersion="19"
        android:targetSdkVersion="19" /> 
 
        <uses-permission android:name="com.google.android.glass.permission.DEVELOPMENT" />
          
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_app"
        android:label="@string/app_name" >
        <activity
            android:name="com.morkout.glasswaretemplate.MenuActivity"
            android:enabled="true"
            android:label="@string/app_name" >
        </activity>
 
        <service
            android:name="com.morkout.glasswaretemplate.AppService"
            android:enabled="true"
            android:exported="true"
            android:icon="@drawable/ic_app"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="com.google.android.glass.action.VOICE_TRIGGER" />
            </intent-filter>
 
            <meta-data
                android:name="com.google.android.glass.VoiceTrigger"
                android:resource="@xml/voice_trigger_start" />
        </service>
    </application>
 
</manifest>