Click here to Skip to main content
13,139,569 members (54,494 online)
Click here to Skip to main content
Add your own
alternative version

Tagged as


10 bookmarked
Posted 29 May 2014

Developing Native Google Glass Apps

, 29 May 2014
This article walks through the ins and outs of Google Glass development with RAD Studio.

Editorial Note

This article is in the Product Showcase section for our sponsors at CodeProject. These articles are intended to provide you with information on products and services that we consider useful and of value to developers.

Google has two APIs / SDKs available in Developer Preview or Sneak Peek status for working with Google Glass. The first is the Google Glass Mirror API, which is a cloud based RESTful interface for sending "cards" to the Google Glass timeline from remote servers. The second is the Glass Development Kit, which builds onto the Android SDK for developing apps that run directly on Glass. These apps can also take advantage of the Android NDK to incorporate native code. Since it builds on the Android SDK, you don't need it for native app development, but it does expose some nice additional features.

Appmethod and RAD Studio from Embarcadero Technologies support Android app development, including support for native Google Glass apps. You can use your choice of C++ or Object Pascal programming languages. The support is based on both the Android SDK and NDK. Once the Android ADB driver is loaded for Google Glass, you can target it just like any other Android device. This article walks through the ins and outs of Google Glass development with RAD Studio. The demos in this article are in Object Pascal and refer to RAD Studio, but everything you see here also works with C++, or the individual C++Builder and Delphi products (with the Mobile Add-On Pack). Likewise, most of this will work with Appmethod as well. You can download a free 30-day license for RAD Studio or Appmethod to follow along with the steps in this article.

Google Glass Specifications

Google Glass is an Android platform device and so much more. Essentially it is a miniaturized tablet you wear on your head. It has a dual-core ARM Cortex-A9 CPU running ARM v7 NEON instructions, a camera, and typical mobile device sensors. Thanks to the recent update it runs Android 4.4 KitKat (API 19). It is able to run many native Android apps, but that is just the beginning.

The main output from glass is the 640x360 display, which looks surprisingly good. Google claims it is the equivalent of a 25-inch screen from 8 feet away. It also has a bone conductive speaker and optional ear buds for sound. It has a large array of input sensors though: a microphone, accelerometer, gyroscope, magnetometer (compass), ambient light sensor, proximity sensor and a forward facing wide-angle camera that can capture 5 mega pixel photos or 720p video. Additionally, it has a touch pad on the right temple, a sensor facing the eye for wink detection, and sensors for "On-Head detection." Support for the latter two are still in beta.

Glass is not the first Android powered optical head-mounted computer, but it may be the most innovative. Instead of a touch screen or keyboard common on other Android devices, its primary input is voice and a small touchpad on the right temple. The touch pad is not used to tap specific widgets or apps, but typically provides four basic gestures: swiping forward and backward for navigation, tapping for selecting, or swiping down for the back button, which will exit your app if not otherwise handled.

The main user interface of Glass is the concept of a timeline made up of a series of cards. One tap wakes up glass. Moving left or right from moves you forward or backward through the timeline. From the home card, taping or using a voice command brings up a list of installed apps which, when launched, typically continue the left to right navigation paradigm.

Figure 1 - Google Glass Home Screen

Installing ADB USB Driver

Before you can develop for any Android device on Windows you need to install the ADB USB Driver. This used to be much more complicated for Google Glass. Now with revision 9 of the Google USB Driver, Google Glass has official support. Simply run the Android Tools utility (installed with RAD Studio) and it will bring up the Android SDK Manager. Select and install the Google USB Driver found in the Extras section at the bottom of the Packages list.

Figure 2 - Android SDK Manager

In device manager you will see an entry with a yellow triangle under Other devices for Glass 1. You can load the driver from the extras\google\usb_driver folder under your Android SDK install. Here is where the folder is found if you installed the Android SDK with RAD Studio and used the default settings:


Creating Your First Native Glassware App

RAD Studio is great for creating true-native multi-device apps that work across both Android and iOS devices. Because Glass is a specific form-factor with a unique interface paradigm I will assume you are creating this app just for Glass. If you do want to make this app work on multiple devices though, you certainly can by using typical multi-device techniques.

RAD Studio provides a number of different templates to get you started creating an application. We will start with just a Blank Application, which will probably be the most common starting point for most Glassware, although the 3D Application could also be really useful.

Figure 3 - FireMonkey Mobile Application Wizard

Setting Up the IDE for Google Glass

While the actual resolution of the main display is 640x360, its pixel density is 1.5. This means an effective resolution for control placement of 472x240 (divide the actual pixels by the pixel density). RAD Studio includes a device layout for Google Glass already sized correctly. You can select it from the drop down box above the design surface in the IDE.

Figure 4 - Design Surface with Google Glass Layout

This layout will work with any color of Google Glass. Likewise, you could define your own Google Glass device in the Device Manager (Tools -> Options -> Environment Options -> Form Designer -> Device Manager). Add a new device for the Android platform. You only need to enable the Landscape Left orientation. You will need to provide a background image that is at least 472x240 pixels. You can specify a Status bar size if you want, but you will typically be hiding it on a Glass app (more about that in a bit).

Voice Launch Support

When you run your app it will launch automatically, but once it closes you will not find it on the menu again. This is because Glass uses a different launch mechanism than a traditional Android app. It is easy enough to add support though.

Once you've built your app for the first time, RAD Studio generates an AndroidManifest.template.xml file. This is a template used to generate the actual AndroidManifest.xml for your Android app.

I find it easiest to add this file to the project group to make it easy to open and edit as needed. Just right click on your project file and select Add . . . This brings up the file browse dialog so you can select the AndroidMainfest.template.xml. Now you can edit the template by double clicking on it from the Project Manager.

There are two edits you need to make in your manifest. The first is inside the <intent-filter> element. You need to specify that you want to respond to the Voice Trigger action. Do this by adding the element:

<action android:name="" />

Then you need to add meta data for this action inside the <activity> element:

<meta-data android:name="" android:resource="@xml/voice_trigger_start" />

This specifies that the XML file voice_trigger_start.xml will define your voice trigger. This file can have any name, but when you add the file it needs to match the name specified here. It should be in the XML directory though.

One note about selecting a voice trigger: Google has a list of approved voice triggers, but if you want to use a different one you are only allowed to do so during development and by adding a special permission to your manifest. Immediately after the <%uses-permission%> add the following:

<pre><uses-permission android:name="" /></pre>

<p>You can submit your suggested voice trigger to Google and if
approved they will add it to the list.</p>

<p>Now you need to create a voice_trigger_start.xml file. </p>

<li>      Add a new XML File to your project by right-clicking the Project Manager and selecting Add New > Other > Web Documents > XML File.

</li><li>      Rename the XML File to voice_trigger_start.xml or whatever name you specified in the manifest. The manifest does not include the .xml extension.

</li><li>      Save the XML File to your project's folder.

</li><li>      Edit the XML File to look like the following:

<pre lang="xml"><?xml version="1.0" encoding="UTF-8"?>

<trigger keyword="Your keyword here" /></pre>

<p>Replace Your
keyword here with whatever
phrase or keyword you want to use if you have the Development permission
specified. Now when your app is deployed to Glass then it will show up in the
menu system with the app icon.</p>

<p>Lastly, you need to configure the deployment of your
voice_trigger_start.xml file to be deployed in the correct location of your
Android app’s apk package. This is done through the deployment manager which is
accessible via the Project > Deployment menu option. Simply click the
Add files button (second from the left) and browse to and select the voice_trigger_start.xml
file you created. After you add the file you will need to edit the Remote
Path to res/xml, which will place it in the correct location within
the apk bundle.</p>

<h2>Common Glass App Configuration</h2>

<p>Commonly Android Apps have a status
bar at the top of the screen. On Google Glass this status bar is hidden. Hiding
it for your app is a two-step process. First you can hide it at design time by
setting the BoarderStyle of the form to None. To remove the
status bar at runtime, go to Project -> Options -> Version Info and
select All configurations – Android Platform at the top. Then change the
value for the theme key from TitleBar to No TitleBar.</p>

<p><img width="640" height="512" src="/KB/showcase/779236/Figure_5_-_Project_Options_-_No_TitleBar.png" /></p>

<div class="Caption">Figure 5 - Project Options - Theme No TitleBar</div>

<p>The default Android theme is Halo Light, which is black
and grey on white background. For a phone or tablet that is fine, but on glass
white pixels are very bright, while black pixels are basically transparent. A
mostly white screen that close to your eye is akin to having a flashlight
shining in your eye, which isn’t very comfortable. Thankfully RAD Studio includes
a Halo Dark, and a specialized Google Glass style. The Google Glass style is
black with light colorful text and a slightly larger font size. It is based on
the recommended Google Glass style.</p>

<p>To change the style of your app, add a TStyleBook to your form
from the Tool Palette. Make sure Android is selected as the Target
Platform in the Project Manager. Select the TForm for your application
(the blank design surface) and in the Object Inspector set the StyleBook
property to the TStyleBook you just placed on your form. Now double click on
the TStyleBook and then click the Load button and navigate to the styles folder.
By default is found in:</p>


<p>Glass apps also typically have a silhouetted white app
icon on a transparent background. You can change the launcher icon for your app
from the Application node of the Project Options dialog.</p>

<h2>Building Your App</h2>

<p>At this point you are ready to build an app for Google
Glass that will integrate into the Glass environment. Since Glass is a
different usage paradigm than typical mobile apps you will need to put some
thought into your app design. The following are some tips on how to interact
with different elements of Glass for the user experience.</p>

<h2>Using the Sensors</h2>

<p>Glass lacks a keyboard or touch screen, but still has all
the standard sensors of a mobile device. You can use the standard sensor
components to access these sensors.</p>

<h3>Location and GPS</h3>

<p>Glass has a built in GPS. The <code>TLocationSensor
has an OnLocationChanged event that occurs when the component is active, and the location changes by more than the Distance property. Inside the OnLocationChanged event handler there is a NewLocation parameter that contains the latitude and longitude of the new location.

Motion & Orientation Tracking

To track the movement and direction of the Glass and the wearer’s head use the TMotionSensor and TOrientationSensor component. They offer information about acceleration, angle, state, heading, speed and motion of the device. Since the Glass is worn on the users head this information is translated into head movement and where the user is looking and how they are moving their head.

It actually accesses information from a number of different sensors, including the gyroscope, magnetometer and accelerometer. You can use a TTimer to poll the sensor information to discover information about the motion and orientation over time, or just read the data once for one time information.

Accessing the Camera

The TCameraComponent gives you the ability to grab frames from the camera. You can grab multiple frames a second to provide a preview or just grab an individual frame. Google requires that the display be on when you are capturing a picture, but doesn’t require that the display show the image you are grabbing (although that is more convenient for your user).

To use the TCameraComponent, set the Active property to true, and then respond to the OnSampleBufferReady event. Keep in mind that this event is not occurring in the UI thread, so if you want to update the UI to display the image to the user you will want to use code similar to the following:

// Event handler for the CameraComponent’s SampleBufferReady event
procedure TMainForm.CameraComponent1SampleBufferReady(
  Sender: TObject; const ATime: Int64);
  // Use Synchronize to move the execution to the main UI thread.
  TThread.Synchronize(TThread.CurrentThread, GetImage);
procedure TMainForm.GetImage;
  // imgCameraView is a TImage component on the UI for displaying the image
  CameraComponent1.SampleBufferToBitmap(imgCameraView.Bitmap, True);

Using the Touchpad

The easiest way to interact with the touchpad is through interactive gestures. The Pan interactive gesture gives you series of events when the user brushes their finger on the touch pad. For example, to allow the user to navigate between options in your app you could look for horizontal movement of the pan gesture.

To respond to interactive gestures, simply expand the Touch property of the form and then specify the individual interactive gestures you want to receive events for. After that, the OnGesture event will occur when the user makes an interactive gesture. Here is an example gesture handler that allows the user to set the screen timeout based on horizontal position of the interactive gesture.

procedure TMainForm.FormGesture(Sender: TObject;
  const EventInfo: TGestureEventInfo; var Handled: Boolean);
  x: Integer;
  // Handle the Pan Interactive Gesture
  if EventInfo.GestureID = igiPan then
    // Specific processing for the beginning of the gesture – save the start location
    if TInteractiveGestureFlag.gfBegin in EventInfo.Flags then
      fPanStart := EventInfo.Location;
      fStartVal := pbTimeOut.Value;
    // Specific processing at the end of the gesture – set the timeout
    if TInteractiveGestureFlag.gfEnd in Eventinfo.Flags then
      SetScreenOffTimeout(Trunc(pbTimeOut.Value * 1000));
    // Update the display based on the current gesture position
      if not (TInteractiveGestureFlag.gfInertia in EventInfo.Flags) then
        x := Trunc((fPanStart.X - EventInfo.Location.X)/10) * 10;
        pbTimeOut.Value := fStartVal + x;

One note, if the user swipes down on the touch pad then the back button event is triggered in addition to the pan gesture. You can handle this back button yourself by trapping it. Simply add an OnKeyUp event handler to your form with the following code:

if Key = vkHardwareBack then
  // Do whatever you want to do here  
  Key := 0;
  // Set Key = 0 if you want to prevent the default action

If you always set Key to 0 then users will not be able to exit your app, so plan appropriately.


RAD Studio and Appmethod’s support for Android in general and Google Glass specifically make it a great choice for developing native Glassware. With support for C++ and Object Pascal, you can use the language you prefer. RAD Studio ships with a native Glassware sample app that demonstrates a lot of what is mentioned here. The documentation also includes a First Steps with Google Glass guide with details of the development process. There are other examples & snippets that demonstrate the use of the different sensors, gestures, etc. It is also possible to call into the GDK to access the timeline or other Glass specific features. The GDK is still under constant updates. Look for future articles covering how to use the GDK on my blog at


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Jim McKeeth
United States United States
Jim is a long time Delphi developer with more than 25 years software development experience. He is the Lead Developer Evangelist for Embarcadero Technologies and leads the Embarcadero Most Valuable Professional (MVP) program. He speaks at conferences around the globe on Delphi and mobile development, and was the first person to earn the Delphi specific badge on Stack Overflow. Catch Jim on his Podcast at where he shares Delphi interviews and other Delphi news.

You may also be interested in...


Comments and Discussions

-- There are no messages in this forum --
Permalink | Advertise | Privacy | Terms of Use | Mobile
Web03 | 2.8.170915.1 | Last Updated 29 May 2014
Article Copyright 2014 by Jim McKeeth
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid