HTTP GET

Add the code in Listing 7-1 to HTTPRequestActivity.java to implement an HTTP GET request to my demo web site at http://morkout.com, which just returns some simple text.

Listing 7-1.  Making an HTTP GET Request in HTTPRequestActivity.java

TextView mTvInfo;
String mWhat;
HttpURLConnection mUrlConnection;
String mResult;
 
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 
    setContentView(R.layout.main);
    mTvInfo = (TextView) findViewById(R.id.info);
    Intent intent = getIntent();
    mWhat = intent.getStringExtra("WHAT");
    mTvInfo.setText("Making HTTP "+ mWhat + " request...");
    new HTTPRequest().execute();
}
 
// Async task class to make HTTP Get, Post and upload
 
private class HTTPRequest extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... arg0) {
        try {
            if (mWhat.equalsIgnoreCase("GET")) {
                // get json via YouTube API
                URL url = new URL("http://morkout.com");
                mUrlConnection = (HttpURLConnection)
                        url.openConnection();
                InputStream in = new BufferedInputStream(
                        mUrlConnection.getInputStream());
                int ch;
                StringBuffer b = new StringBuffer();
                while ((ch = in.read()) != -1) {
                        b.append((char) ch);
                }
                 
                mResult = new String(b);
            }
        } catch (Exception e) {}
        return null;
    }
         
    @Override
    protected void onPostExecute(Void result) {
        super.onPostExecute(result);
        mTvInfo.setText(mResult);
    }

Don’t forget to add <uses-permission android:name="android.permission.INTERNET"/>to your AndroidManifest.xml file. Now run the app and tap to select HTTP GET. You’ll see the message “Making HTTP GET request. . .,” followed by the GET result, as shown in Figure 7-1.

So, with just a few lines of code, you can make an HTTP GET call and get its returned result.

HTTP POST

Similarly, you can make an HTTP POST request with DefaultHttpClient. Simply add the code in Listing 7-2 after the if statement in doInBackground of Listing 7-1.

Listing 7-2.  Making an HTTP POST Request in HTTPRequestActivity.java

else if (mWhat.equalsIgnoreCase("POST")) {
     
    URL url = new URL("http://morkout.com/glass/posttest.php");
    mUrlConnection = (HttpURLConnection) url.openConnection();
    mUrlConnection.setRequestMethod("POST");
    String urlParameters = "[email protected]&name=Jeff
                Tang&pwd=1234567&vcode=2014";
    OutputStreamWriter writer = new
        OutputStreamWriter(mUrlConnection.getOutputStream());
    writer.write(urlParameters);
    writer.flush();
     
    InputStream in = new BufferedInputStream(
                mUrlConnection.getInputStream());
    int ch;
    StringBuffer b = new StringBuffer();
    while ((ch = in.read()) != -1) {
        b.append((char) ch);
    }
     
    mResult = new String(b);
     
    in.close();
    writer.close();
}

The server code posttest.php, if you are curious, is extremely simple, used here only for demo purposes (you don’t need to implement this; it’s set up on my demo server morkout.com).

<?php
 
$email = $_REQUEST["email"];
$pwd = md5($_REQUEST["pwd"]);
$name = $_REQUEST["name"];
$vcode = md5(uniqid(time()));
 
echo "POST returns: email=$email, pwd=$pwd, name=$name, vcode=$vcode";
 
?>

Run the app and select HTTP POST this time. You’ll see after “Making HTTP Post request . . .” the message shown in Figure 7-2.

HTTP File Uploading

The code in Listing 7-3 shows how to implement file uploading using HttpURLConnection. First copy an image file called marchmadness.png from the project’s asset file to Glass’s external storage directory using the same copyAsset method you used in Chapter 5; then send the file to the server and display the response message from the server.

Listing 7-3.  HTTP File Uploading in HTTPRequestActivity.java

else if (mWhat.equalsIgnoreCase("UPLOAD")) {
    int serverResponseCode = 0;
    File sourceFile = new File(copyAsset("marchmadness.png"));
    DataOutputStream dos = null;
    String lineEnd = "
";
    String twoHyphens = "--";
    String boundary = "*****";
    int bytesRead, bytesAvailable, bufferSize;
    byte[] buffer;
    int maxBufferSize = 1024 * 1024;
    int REQUEST_SUCCESS_CODE = 200; // for all possible response codes and messages, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
 
    FileInputStream fileInputStream = new FileInputStream(sourceFile);
    URL url = new URL("http://www.morkout.com/glass/upload.php");
         
    mUrlConnection = (HttpURLConnection) url.openConnection();
    mUrlConnection.setRequestMethod("POST");
    mUrlConnection.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary); // Content-Type has to be set like this to support HTTP file uploading, which originates from HTML form-based file uploading
     
    mUrlConnection.setRequestProperty("Filedata", sourceFile.getName()); // "Filedata" needs to match the server code that handles file uploading. For example, in PHP, $_FILES["Filedata"]["tmp_name"] is used to access the uploaded file
     
    dos = new DataOutputStream(mUrlConnection.getOutputStream());
    dos.writeBytes(twoHyphens + boundary + lineEnd);
    dos.writeBytes("Content-Disposition: form-data; name=Filedata;filename="+ sourceFile.getName() + lineEnd);
    dos.writeBytes(lineEnd);
     
    bytesAvailable = fileInputStream.available();
    bufferSize = Math.min(bytesAvailable, maxBufferSize);
    buffer = new byte[bufferSize];
    bytesRead = fileInputStream.read(buffer, 0, bufferSize);
    while (bytesRead > 0) {
        dos.write(buffer, 0, bufferSize);
        bytesAvailable = fileInputStream.available();
        bufferSize = Math.min(bytesAvailable, maxBufferSize);
        bytesRead = fileInputStream.read(buffer, 0, bufferSize);
    }
        dos.writeBytes(lineEnd);
        dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);
         
        // Responses from the server (code and message)
        serverResponseCode = mUrlConnection.getResponseCode();
        String serverResponseMessage = mUrlConnection.getResponseMessage();
         
        if(serverResponseCode == REQUEST_SUCCESS_CODE) {
            InputStream is = mUrlConnection.getInputStream();
            int ch;
            StringBuffer b = new StringBuffer();
            while ((ch = is.read()) != -1) {
            b.append((char) ch);
            }
                 
            final String uploadedFilename = b.toString();
            mResult = "uploaded file at http://www.morkout.com/glass/uploads/ " + uploadedFilename;
        }
        is.close();
        fileInputStream.close();
        dos.close();

The server code upload.php is also pretty straightforward. (Again, this is just for reference; you don’t need to set up your web server or implement this code.)

<?
if (!isset($_FILES["Filedata"]) || !is_uploaded_file($_FILES["Filedata"]["tmp_name"]) || $_FILES["Filedata"]["error"] != 0) {
    echo 0;
}
else {
    $uploaded_filename = "glassupoad-" . md5($_FILES["Filedata"]["tmp_name"] . uniqid("")) . ".jpg";
    move_uploaded_file($_FILES["Filedata"]["tmp_name"], "uploads/" . $uploaded_filename);
    echo $uploaded_filename;
}
?>

Run the app and select HTTP UPLOAD, and you’ll see the uploaded file URL on your Glass, as shown in Figure 7-3. It will be something like http://www.morkout.com/glass/uploads/glassupoad-075cb1d03db3e039cbb5643ac1ea2740.png.

You can easily replace the code that copies a file from the project’s asset folder with code that uses a picture taken on your Glass and then upload the picture to your server for further processing or sharing. You’ll see how this works for sharing your Glass pictures with your WhatsApp or WeChat friends later in the chapter.

Now that you have the working code running on Glass that does the most common HTTP client tasks, the next step is to go a little lower level. Socket programming is a powerful networking solution that may work best for your own client-server requirements, such as a chat app or a Bluetooth-based app.

Glass Client vs. Android Server

Let’s first run a socket client on Glass talking to a socket server running on another Android device (real or virtual). In the Glass project NBSocial, create a new activity file, called SocketClientActivity.java, with the code in Listing 7-4.

Listing 7-4.  Socket Client Code in SocketClientActivity.java

public class SocketClientActivity extends Activity implements Runnable {
    private TextView mTvInfo;
    String mResult;
    Socket mClientSocket;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mTvInfo = (TextView) findViewById(R.id.info);
        mTvInfo.setText("Connecting to server ...");
        Thread thread = new Thread(this);
        thread.start();
    }
 
    @Override
    protected void onStop() {
        super.onStop();
        try {
            if (mClientSocket != null) mClientSocket.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public void run() {
        // This is the IP address of Android server running on an actual device or virtual device on computer. It's likely to be different on your device and if so, you should replace this with your IP
        String serverIP = "192.168.1.9";
         
        // This is the server socket port that client will connect to. It should be the same as in SocketServerActivity.java in Listing 7-5.
        int port = SocketServerActivity.PORT;
        try {
            mClientSocket = new Socket(serverIP, port);
            BufferedReader input = new BufferedReader(new InputStreamReader(mClientSocket.getInputStream()));
            mResult = input.readLine();
            runOnUiThread(new Runnable() {
                public void run() {
                    // This is used to get client's connection info including IP address
                    WifiManager wim= (WifiManager) getSystemService(WIFI_SERVICE);
                    List<WifiConfiguration> l =  wim.getConfiguredNetworks();
                    WifiConfiguration wc = l.get(0);
                    mTvInfo.setText("CLIENT IP: " + Formatter.formatIpAddress(wim.getConnectionInfo().getIpAddress()) + ", connected to " + mClientSocket.getRemoteSocketAddress() + ", received: "+mResult);
                }
            });
                         
            PrintWriter out = new PrintWriter(mClientSocket.getOutputStream(), true);
            // add the number received from server by 50 and send to server
            out.println(Integer.parseInt(mResult)+50);
            mClientSocket.close();
        }
                catch(IOException e) {
                    final IOException ex = e;
                    runOnUiThread(new Runnable() {
                        public void run() {
                            // let users know if socket exception occurs
                            mTvInfo.setText(ex.getMessage());
                        }
                    });
                }
        }
}

Now create a new Android app called SocketAndroidApp and add a file called SocketServerActivity.java with the code in Listing 7-5. Then copy the SocketServerActivity.java file to NBSocial to make the client app use the port defined in the server app (I have int port = SocketServerActivity.PORT; in Listing 7-4). Similarly, copy SocketClientActivity.java from NBSocial to AndroidSocketApp. In the next section, you’ll see Glass acting as a server and another Android device acting as a client.

Listing 7-5.  Socket Server Code in SocketServerActivity.java

public class SocketServerActivity extends Activity implements Runnable {
    public final static int PORT = 6604;
    private TextView mTvInfo;
    private ServerSocket mServerSocket;
    private Socket mClientSocket;
    String mResult;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mTvInfo = (TextView) findViewById(R.id.info);
        Thread thread = new Thread(this);
        thread.start();
    }
 
    @Override
    protected void onStop() {
        super.onStop();
         
        try {
            if (mClientSocket != null) mClientSocket.close();
            if (mServerSocket != null) mServerSocket.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public void run() {
        try {
            serverSocket = new ServerSocket(PORT);
            while(true)
            {
                mServerSocket = new ServerSocket(PORT);
                runOnUiThread(new Runnable() {
                    public void run() {
                        WifiManager wim= (WifiManager) getSystemService(WIFI_SERVICE);
                        List<WifiConfiguration> l =  wim.getConfiguredNetworks();
                        WifiConfiguration wc = l.get(0);
                        mTvInfo.setText(mTvInfo.getText() + "

Server IP: " + Formatter.formatIpAddress(wim.getConnectionInfo().getIpAddress())  + ". Waiting for client on port " + PORT);
                    }
                });
                mClientSocket = mServerSocket.accept();
 
                runOnUiThread(new Runnable() {
                    public void run() {
                        mTvInfo.setText(mTvInfo.getText() + "
Just connected from client" + mClientSocket.getRemoteSocketAddress());
                    }
                });
 
                OutputStream oStream = mClientSocket.getOutputStream();
                PrintWriter out = new PrintWriter(oStream, true);
                BufferedReader input = new BufferedReader(new InputStreamReader(mClientSocket.getInputStream()));
 
                out.println(2014);
                mResult = input.readLine();
 
                runOnUiThread(new Runnable() {
                    public void run() {
                        mTvInfo.setText(mTvInfo.getText() + "
Sent: 2014. Received: "+mResult);
                    }
                });
 
                mClientSocket.close();
                mServerSocket.close();
            }
        }
        catch(SocketTimeoutException s)
        {
            runOnUiThread(new Runnable() {
                public void run() {
                    mTvInfo.setText("Socket timed out!");
                }
            });
        }
        catch(IOException e)
        {
            final IOException ex = e;
            runOnUiThread(new Runnable() {
                public void run() {
                    mTvInfo.setText(ex.getMessage());
                }
            });
        }
    }
}

In Listings 7-4 and 7-5, after a socket connection is established between a client and a server, the server sends the number 2014 to the client. The client adds 50 to it and returns 2064 to the server.

The layout/main.xml file for both NBSocial and SocketAndroidApp has just a simple TextView.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android "
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:id="@+id/info"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/info"
    />
</LinearLayout>

Now in NBSocial, add two new menu entries in menu.xml, add the string definitions for socketclient and socketserver to strings.xml, and add the two activities in AndroidManifest.xml.

        case R.id.socketclient:
            Intent intent4 = new Intent(this, SocketClientActivity.class);
            startActivity(intent4);
            return true;
            
        case R.id.socketserver:
            Intent intent5 = new Intent(this, SocketServerActivity.class);
            startActivity(intent5);
            return true;
 
<string name="socketclient">SOCKET CLIENT</string>
<string name="socketserver">SOCKET SERVER</string>

In AndroidSocketApp’s AndroidManifest.xml file, make SocketServerActivity your MAIN action.

<activity
    android:name=".SocketServerActivity"
    android:label="@string/app_name" >
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />

        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Finally, make sure both your Glass and Android device are connected to the same wi-fi network and change the serverIP value in NBSocial’s SocketClientActivity.java file from 192.168.1.9 to your Android device’s IP or, if you use simulator (Android virtual device), your computer’s IP address. (You can find the IP address in Settings by selecting Wi-Fi and then your connected wi-fi network name.)

Now run the server app on your non-Glass Android device first. You’ll see a message like “Server IP: 192.168.1.9. Waiting for client on port 6604.” Start the Glass app NBSocial and select “SOCKET CLIENT.” You’ll see on your Glass a message similar to “CLIENT IP: 192.168.1.9, connected to /192.168.1.8:6680, received: 2014,” as shown in Figure 7-4.

On your Android device you’ll see new message like “Just connected from client/192.168.1.13:60787. Sent: 2014. Received: 2064,” followed by “Server IP: 192.168.1.9. Waiting for client on port 6604” again. The server code is in a loop that keeps waiting for a new client connection after a connection is established, data gets exchanged, and both client and server sockets are closed. You can swipe down on Glass to exit the client activity and then select SOCKET CLIENT to connect to the Android server again. Figure 7-5 shows the server messages.

If your Glass and Android device are not on the same wi-fi network and Glass cannot reach the Android device’s IP address, you’ll see on Glass a “No route to host” exception, as shown in Figure 7-6.

If your Glass and Android device are on the same wi-fi but the Android server app is running on a different port or is not running, you’ll see the message shown in Figure 7-7.

Based on the simple client and server interaction between Glass and another Android device shown here, you can build much richer interaction for your own apps.

Glass Server vs. Android Client

The steps to build a Glass server and an Android client are similar. You just need to run the NBSocial app on Glass first, select SOCKET SERVER, and then replace SocketServerActivity in your Android app’s AndroidManifest.xml file with SocketClientActivity (make sure you set serverIP in AndroidSocketApp’s SocketClientActivity.java file to your Glass’s IP address, shown earlier as “client IP” in Figures 7-4 and 7-5). Then run the app on Android. You’ll see on Android a message similar to Figure 7-4. Figure 7-8 shows a message similar to what you’ll see on Glass.

Glass Client vs. iOS Server

If you’re also an iOS developer, you may be interested to know how to let Glass talk to an iOS device. The good news is that using a C-level socket, you can easily connect to Glass as a client or server. There are some open source Objective-C socket libraries you can use too. Listing 7-6 is the code snippet that you can use on your iOS app to act as a socket server (the complete iOS project, called SocketiOSApp, is included in the book’s source code) to talk to the Glass socket client, as shown earlier in Listing 7-4.

Listing 7-6.  iOS Socket Server Code to Talk to Glass Client

- (IBAction)socketTapped:(id)sender {
    [self runSocketServer];
}
 
- (void) runSocketServer {
    int listenfd = 0;
    __block int connfd = 0;
    struct sockaddr_in serv_addr;
     
    __block char sendBuff[1024];
    __block NSString *info;
     
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&serv_addr, '0', sizeof(serv_addr));
    memset(sendBuff, '0', sizeof(sendBuff));
     
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(6606);
     
    bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
     
    listen(listenfd, 10);
     
    _lblInfo.text = @"Waiting for client on port 6606";
     
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        struct sockaddr_in client_addr;
        socklen_t addrlen=sizeof(client_addr);
        connfd = accept(listenfd, (struct sockaddr*)&client_addr, &addrlen);
        write(connfd, "2014
", 5);
        char recvBuff[1024];
        int n = read(connfd, recvBuff, sizeof(recvBuff)-1);
        recvBuff[n] = '';
         
        struct sockaddr_in localAddress;
        socklen_t addressLength = sizeof(localAddress);
        getsockname(connfd, (struct sockaddr*)&localAddress, &addressLength);
         
        info = [NSString stringWithFormat:@"SERVER IP: %@, connected from %@, received: %s",
                [NSString stringWithCString:inet_ntoa(localAddress.sin_addr) encoding:NSUTF8StringEncoding],
                [NSString stringWithCString:inet_ntoa(client_addr.sin_addr) encoding:NSUTF8StringEncoding],
                recvBuff];
        close(connfd);
        close(listenfd);
             
        dispatch_async(dispatch_get_main_queue(), ^{
            _lblInfo.text = [NSString stringWithFormat:@"%@
%@", _lblInfo.text, info];
        });
    });
}

After the iOS app runs on an iOS device or simulator, you tap or click the “run as server” button shown in Figure 7-9 to start the socket server. A UILabel is used to show the information “Waiting for client connection. . ..” Then you use the iOS device’s IP, or computer’s IP if you use the iOS simulator, to set serverIP in NBSocial’s SocketClientActivity.java file. Run the Glass app and then choose SOCKET CLIENT, and you’ll see the same numbers, 2014 and 2064, sent between your iOS app and Glass app. Figure 7-9 shows the server log in the iOS simulator.

Glass Server vs. iOS Client

Listing 7-7 shows the iOS code that acts as a socket client to communicate with the Glass server code shown earlier in Listing 7-5.

Listing 7-7.  iOS Socket Client Code to Talk to Glass Server

- (IBAction)clientTapped:(id)sender {
    [self runSocketClient];
}
 
- (void) runSocketClient {
    int sockfd = 0, n = 0;
    char recvBuff[1024];
    struct sockaddr_in serv_addr;
 
    memset(recvBuff, '0',sizeof(recvBuff));
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("unable to create socket
");
        return;
    }
 
    memset(&serv_addr, '0', sizeof(serv_addr));
 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(6604); // replace 6604 with Glass server port defined in "public final static int PORT = 6604;" of SocketServerActivity.java
 
    // Replace "10.0.0.6" with your Glass IP
    if(inet_pton(AF_INET, "10.0.0.6", &serv_addr.sin_addr)<=0)
    {
        printf("inet_pton error occurred
");
        return;
    }
 
    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        printf("unable to connect
");
    }
 
    if ( (n = read(sockfd, recvBuff, sizeof(recvBuff)-1)) > 0)
    {
        recvBuff[n] = 0;
        char result[1024];
        sprintf(result, "%d
", atoi(recvBuff)+50);
        write(sockfd, result, 5);
 
        // get server IP address
        struct sockaddr_in localAddress;
        socklen_t addressLength = sizeof(localAddress);
        getsockname(sockfd, (struct sockaddr*)&localAddress, &addressLength);
 
        _lblInfo.text = [NSString stringWithFormat:@"CLIENT IP: %@, connected to %@, received: %s",
                         [NSString stringWithCString:inet_ntoa(localAddress.sin_addr) encoding:NSUTF8StringEncoding],
                         [NSString stringWithCString:inet_ntoa(serv_addr.sin_addr) encoding:NSUTF8StringEncoding],
                         recvBuff];
        close(sockfd);
    }
}

Run the NBSocial app on Glass, select SOCKET SERVER, and then run the iOS app (make sure in Listing 7-7 to use your Glass’s IP and port). Tap or click the “run as client” button shown in Figure 7-10 to connect to the Glass socket server. After data exchange, you’ll see on Glass the message shown earlier in Figure 7-8, and you’ll see on an iOS device or in the simulator the message shown in Figure 7-10.

Let’s move on to another interesting topic that can be useful when you don’t have wi-fi available and you still want to transfer data between your Glass and other Android/iOS devices, or even some smart sensors.

Classic Bluetooth

If you haven’t already, you should review the Android developer site’s API documentation on Bluetooth first (again, http://developer.android.com/guide/topics/connectivity/bluetooth.html), or you could be lost. In this section, I’ll show you how Glass can act as a Classic Bluetooth client and talk to another Android app as a Classic Bluetooth server, and the other way around (Glass as a server and another Android app as a client).

Follow these steps to add the Classic Bluetooth feature to the Glass app NBSocial, which allows you to transfer a large file between Glass and another Android device:

1. Create two new menu entries in NBSocial by updating res/menu/main.xml and res/values/strings.xml and update MenuActivity.java.

   <item
       android:id="@+id/cbtclient"
       android:title="@string/cbtclient" />
    
   <item
       android:id="@+id/cbtserver"
       android:title="@string/cbtserver" /> 
   *****
   <string name="cbtclient">CBT CLIENT</string>
   <string name="cbtserver">CBT SERVER</string>
    
   *****
           case R.id.cbtclient:
               Intent intent6 = new Intent(this, ClassicBluetoothClient.class);
               startActivity(intent6);
               return true;
                
           case R.id.cbtserver:
               Intent intent7 = new Intent(this, ClassicBluetoothServer.class);
               startActivity(intent7);
               return true;

2. Add the following content to AndroidManifest.xml:

   <uses-permission android:name="android.permission.BLUETOOTH" />
   <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> 
       <activity
           android:name="com.morkout.nbsocial.ClassicBluetoothClient"
           android:enabled="true"
           android:label="@string/app_name" >
       </activity>
       <activity
           android:name="com.morkout.nbsocial.ClassicBluetoothServer"
           android:enabled="true"
           android:label="@string/app_name" >

   The BLUETOOTH permission is needed to perform any Bluetooth communication, including requesting a connection, accepting a connection, and transferring data. The BLUETOOTH_ADMIN permission is needed to initiate Bluetooth device discovery or change Bluetooth settings.

3. Create a new Activity file called ClassicBluetoothServer.java in NBSocial with the code in Listing 7-8.

   Listing 7-8.  Classic Bluetooth Server Code

   public class ClassicBluetoothServer extends Activity {
    
       public final static String TAG = "ClassicBluetoothServer";
       BluetoothAdapter mBluetoothAdapter;
       BluetoothServerSocket mBluetoothServerSocket;
       public static final int REQUEST_TO_START_BT = 100;
       public static final int REQUEST_FOR_SELF_DISCOVERY = 200;
       private TextView mTvInfo;
    
       UUID MY_UUID = UUID.fromString("D04E3068-E15B-4482-8306-4CABFA1726E7");
    
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.main);
           mTvInfo = (TextView) findViewById(R.id.info);
    
           // initialize BluetoothAdapter, for API 18 or above
           final BluetoothManager bluetoothManager =
               (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
           mBluetoothAdapter = bluetoothManager.getAdapter();
    
           if (mBluetoothAdapter == null) {
               return;
           } else {
               if (!mBluetoothAdapter.isEnabled()) {
                   Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                   startActivityForResult(enableBtIntent, REQUEST_TO_START_BT);
               } else {
                   new AcceptThread().start();
               }
           }
       }
    
       // the thread that waits for Bluetooth client connection
       private class AcceptThread extends Thread {
           private BluetoothServerSocket mServerSocket;
    
           public AcceptThread() {
               try {
                   // client should use the same MY_UUID to make connection request
                   mServerSocket = mBluetoothAdapter.listenUsingRfcommWithServiceRecord("ClassicBluetoothServer", MY_UUID);
               }
               catch (IOException e) {
                   Log.e(TAG, e.getMessage());
               }
           }
    
           public void run() {
               BluetoothSocket socket = null;
               while (true) {
                   try {
                       runOnUiThread(new Runnable() {
                           public void run() {
                               mTvInfo.setText(mTvInfo.getText() + "
   
   Waiting for Bluetooth Client ...");
                           }
                       });
                       // blocking call
                       socket = mServerSocket.accept();
    
                   } catch (IOException e) {
                       Log.v(TAG, e.getMessage());
                       break;
                   }
                    
                   if (socket != null) {
                       new ConnectedThread(socket).start();
       
                         try {
                             mServerSocket.close();
                       } catch (IOException e) {
                           Log.v(TAG, e.getMessage());
                       }
                       break;
                   }
               }
           }
       }
    
       // the thread that sends file to client
       private class ConnectedThread extends Thread {
           private final BluetoothSocket mSocket;
           private final OutputStream mOutStream;
           private int bytesRead;
           final private String FILE_TO_BE_TRANSFERRED = "marchmadness.png";
           final private String PATH = Environment.getExternalStorageDirectory().toString() + "/nbsocial/";
    
           public ConnectedThread(BluetoothSocket socket) {
               mSocket = socket;
               OutputStream tmpOut = null;
    
               try {
                   tmpOut = socket.getOutputStream();
               } catch (IOException e) {
                   Log.e(TAG, e.getMessage());
               }
               mOutStream = tmpOut;
           }
    
           // save as the function in MyVideoApps in Chapter 5
           String copyAsset(String filename) {
                ...
           }
    
           public void run() {
               byte[] buffer = new byte[1024];
               if (mOutStream != null) {
                   // copy a file from app asset folder
                   File myFile = new File( copyAsset("marchmadness.png") );
                   FileInputStream fis = null;
    
                   try {
                       fis = new FileInputStream(myFile);
                   } catch (FileNotFoundException e) {
                       Log.e(TAG, e.getMessage());
                   }
                   BufferedInputStream bis = new BufferedInputStream(fis);
                   runOnUiThread(new Runnable() {
                       public void run() {
                           mTvInfo.setText(mTvInfo.getText() + "
   before sending file "+  PATH + FILE_TO_BE_TRANSFERRED
                               + " of " + new File(  PATH + FILE_TO_BE_TRANSFERRED ).length() + " bytes");
                       }
                   });
                   // use standard streaming code to send socket data
                   try {
                       bytesRead = 0;
                       for (int read = bis.read(buffer); read >=0; read = bis.read(buffer))
                       {
                           mOutStream.write(buffer, 0, read);
                           bytesRead += read;
                       }
    
                       mSocket.close();
                       runOnUiThread(new Runnable() {
                           public void run() {
                               mTvInfo.setText(bytesRead + " bytes of file " +  PATH + FILE_TO_BE_TRANSFERRED + " has been sent.");
                           }
                       });
    
                   } catch (IOException e) {
                       Log.e(TAG, e.getMessage());
                   }
               }
               // wait for new client connection
               new AcceptThread().start();
           }
       }
   }

4. Create another Activity ClassicBluetoothClient.java in NBSocial with the code in Listing 7-9. Note that to test the Bluetooth client and server communication using Glass and another Android device, you’ll need to create a new Android app (called AndroidBluetooth in the book’s source code) and copy the two files in Listings 7-8 and 7-9 to the app. You’ll find more on this after this step.

   Listing 7-9.  Classic Bluetooth Client Code

   public class ClassicBluetoothClient extends Activity {
    
       public final static String TAG = "ClassicBluetoothClient";
       public static final int REQUEST_TO_ENABLE_BT = 100;
       private BluetoothAdapter mBluetoothAdapter;
       private TextView mTvInfo;
       private UUID MY_UUID = UUID.fromString("D04E3068-E15B-4482-8306-4CABFA1726E7");  // notice this UUID is the same as the server's
       private final static String FILE_PATH_RECEIVED = Environment.getExternalStorageDirectory().getPath()  +"/filefromCBTserver";
    
       // NOTE!!! you need to replace this with your own device name
       private final static String CBT_SERVER_DEVICE_NAME = "Jeff Tang's Glass";
    
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.main);
           mTvInfo = (TextView) findViewById(R.id.info);
           mTvInfo.setText("Classic Bluetooth Client");
    
           final BluetoothManager bluetoothManager =
               (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
           mBluetoothAdapter = bluetoothManager.getAdapter();
           if (mBluetoothAdapter == null) {
               return;
           }
           else {
               if (!mBluetoothAdapter.isEnabled()) {
                   Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                   startActivityForResult(enableBtIntent, REQUEST_TO_ENABLE_BT);
               }
               else{
                   // two ways to find and connect to server
                   // discover new Bluetooth devices
                   discoverBluetoothDevices();
    
                   // find devices that have been paired
                   getBondedDevices();
               }
           }
    
       }
    
       @Override
       protected void onActivityResult(int requestCode, int resultCode, Intent data) {
           if (requestCode == REQUEST_TO_ENABLE_BT) {
               discoverBluetoothDevices();
               getBondedDevices();
               return;
           }
       }
    
       void discoverBluetoothDevices () {
           // register a BroadcastReceiver for the ACTION_FOUND Intent
           // to receive info about each Bluetooth device discovered.
           IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
           registerReceiver(mReceiver, filter);
           mBluetoothAdapter.startDiscovery();
       }
    
       // for each device discovered, the broadcast info is received
       private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
           public void onReceive(Context context, Intent intent) {
               String action = intent.getAction();
               // When discovery finds a device
               if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                   // Get the BluetoothDevice object from the Intent
                   BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    
                   String name = device.getName();
                   // found Glass or an Android device running server
                   if (name != null && name.equalsIgnoreCase(CBT_SERVER_DEVICE_NAME)) {
                       new ConnectThread(device).start();
                   }
               }
           }
       };
    
       protected void onDestroy() {
           unregisterReceiver(mReceiver);
           super.onDestroy();
       }
    
       // bonded devices are those that have already paired with the current device sometime in the past
       void getBondedDevices () {
           Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
           if (pairedDevices.size() > 0) {
               for (BluetoothDevice device : pairedDevices) {
                   if (device.getName().equalsIgnoreCase(CBT_SERVER_DEVICE_NAME)) {
                       new ConnectThread(device).start();
                       break;
                   }
               }
           }
           else {
               Toast.makeText(ClassicBluetoothClient.this, "No bonded devices", Toast.LENGTH_LONG).show();
           }
       }
    
       private class ConnectThread extends Thread {
           int bytesRead;
           int total;
           private final BluetoothSocket mmSocket;
           public ConnectThread(BluetoothDevice device) {
               BluetoothSocket tmp = null;
               try {
                   tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
               } catch (IOException e) {
                   Log.v(TAG, e.getMessage());
               }
               mmSocket = tmp;
           }
           public void run() {
               try {
                   // blocking call to connect to server
                   mmSocket.connect();
               } catch (IOException e) {
                   Log.v(TAG, e.getMessage());
                   try {
                       mmSocket.close();
                   } catch (IOException closeException) { }
                   return;
               }
               manageConnectedSocket(mmSocket);
           }
    
           // receive file from server
           private void manageConnectedSocket(BluetoothSocket socket) {
               int bufferSize = 1024;
               byte[] buffer = new byte[bufferSize];
               FileOutputStream fos = null;
               BufferedOutputStream bos = null;
        
               try {
                   InputStream instream = socket.getInputStream();
                   fos = new FileOutputStream( FILE_PATH_RECEIVED );
                   bos = new BufferedOutputStream(fos);
                   bytesRead = -1;
                   total = 0;
                   while ((bytesRead = instream.read(buffer)) > 0) {
                       total += bytesRead;
                       bos.write(buffer, 0, bytesRead);
                   }
                   bos.close();
                   socket.close();
               } catch (IOException e) {
                   try {
                       socket.close();
                       bos.close();}
                   catch (IOException e2) {
                       Log.e(TAG, "socket close exception:", e2);
                   }
               }
           }
       }
   }

5. Create a new Android app called AndroidBluetooth, and copy the ClassicBluetoothClient.java and ClassicBluetoothServer.java files from NBSocial to AndroidBluetooth. Update the AndroidBluetooth app’s AndroidManifest.xml file to include the two Bluetooth permissions and make ClassicBluetoothClient the app’s MAIN LAUNCHER activity (ideally, the app should present a UI to let you choose whether to run it as a client or server).
6. In your Android device’s settings, choose Bluetooth and pair the device with your Glass. This is optional but recommended; if you don’t pair your devices in advance, Glass can still discover your Android device and prompt you if you want to pair, but this later process is not very reliable and may not work all the time. Also remember to change CBT_SERVER_DEVICE_NAME in ClassicBluetoothClient.java to your actual Glass name, shown in your Android device Bluetooth settings’ Paired Devices list. Figure 7-11 shows the Bluetooth settings on my Nexus 7 tablet.

   

   Figure 7-11. Pairing Android device with Glass via Bluetooth

7. Run the Glass app NBSocial and select CBT SERVER to run the Bluetooth server. Then start the AndroidBluetooth app on your Android device, and you’ll see the marchmadness.png file gets transferred via Classic Bluetooth from your Glass to your Android device, saved as /sdcard/filefromCBTserver in your Android device. Figure 7-12 shows what you see on your Glass.

   

   Figure 7-12. Sending file from Bluetooth server to client

8. Similarly, you can run the server on your Android device and client on your Glass. First, change AndroidBluetooth’s AndroidManifest.xml file to set ClassicBluetoothServer as its LAUNCHER activity. Then start the app on your Android device, run NBSocial on your Glass app, and select CBT CLIENT. You’ll see the marchmadness.png file gets transferred via Classic Bluetooth from your Android device to Glass, saved as /sdcard/filefromCBTserver in your Glass.

Here are a few points to note about the code in Listings 7-8 and 7-9:

1. The same universally unique identifier (UUID) is used in both the client’s createRfcommSocketToServiceRecord call and the server’s listenUsingRfcommWithServiceRecord call. By matching the UUID, the server accepts the client’s connection request. You can use a command-line tool called uuidgen to generate a unique UUID for your own app (for more information, see the “About UUID” note at ).
2. After a paired device is found, new ConnectThread(device).start(); is called, which uses createRfcommSocketToServiceRecord to create a socket and the socket’s connect method to establish a socket connection with the server.
3. After a connection request from the client is accepted by the server, the standard socket programming that you saw earlier can be used to transfer data between the client and the server. Here you transfer a relatively large file instead of some short text characters.

You can think of many use cases, such as audio or video streaming, that require a large amount of data transfer between Glass and smartphones or tablets based on Classic Bluetooth. Other use cases would require small but crucial data transfer between Glass and smart sensors, which is the next topic.

Bluetooth Low Energy

BLE is also called Bluetooth Smart, and it’s poised for explosive growth. More than 1 billion BLE devices in healthcare, sports, fitness, security, toys, home entertainment, and many other areas were shipped in 2013. BLE is an essential communication technology in all kinds of smart devices because of its low cost, widely adopted standard, and, of course, low energy. It is of essential importance to wearable computing, which is believed to be the next big thing after PC, Internet, and mobile computing. Apple has supported BLE in all its products since iPhone 4s and iOS 5. Google started the BLE support in Android 4.3, API Level 18.

Before proceeding, you have to check out the great Android BLE API guide at http://developer.android.com/guide/topics/connectivity/bluetooth-le.html to get yourself familiar with key BLE terms and concepts and sample Android code. Three most important BLE terms are generic attribute profile (GATT, such as the Heart Rate Profile), service (such as the Heart Rate Monitor service), and Characteristic (such as the Heart Rate Measurement characteristic). Each GATT can have one or more services, and each service can have one or more characteristics from which BLE client reads data. The BLE API guide also shows you how to set up BLE, find BLE devices, connect to a GATT server, read BLE attributes, and receive GATT notifications when a characteristic changes, but it doesn’t offer a direct and simple example to get data you’re interested from a BLE device. This is what I’ll do in this section; I’ll show you how to let Glass act as a BLE client and read heart rate data from a popular BLE sensor, the Polar H7 Heart Rate Sensor, available for purchase at http://amzn.to/1h6RjLY.

Other Tips

If you’re new to Classic Bluetooth or BLE, you may find it confusing sometimes how to pair Glass with a Bluetooth device. The truth is that with Classic Bluetooth, you have to pair another Bluetooth device, for example Google Glass, smartphone, or tablet, from your non-Glass Bluetooth device’s (most likely a smartphone or tablet) Bluetooth settings. With BLE, you don’t see the BLE devices in your smartphone or tablet’s Bluetooth settings; you discover and add the devices from your app.

Also, by default, Glass can only be discovered, meaning it can be seen and initiated for pairing only by your phone or tablet. To make Glass be able to go search and connect to other Classic Bluetooth devices, such as a Bluetooth keyboard or Logitech Boombox speaker, you can follow the steps in this Google I/O video: https://www.youtube.com/watch?v=OPethpwuYEk&feature=youtu.be&t=7m35s. Although the video is called Voiding Your Warranty: Hacking Glass, the part that makes your Glass discover other Bluetooth devices only requires you to install two apps and then use your familiar Android Settings app to pair your Glass with a device such as the Boombox speaker, which obviously cannot pair with your Glass proactively.