diff --git a/android-lib/build.gradle b/android-lib/build.gradle
index dbd25cf..d21fcc6 100644
--- a/android-lib/build.gradle
+++ b/android-lib/build.gradle
@@ -15,11 +15,11 @@
 apply plugin: 'wrapper'
 
 android {
-    buildToolsVersion '21.1.2'
-    compileSdkVersion 19
+    buildToolsVersion '22.0.1'
+    compileSdkVersion 22
 
     defaultConfig {
-        minSdkVersion 19
+        minSdkVersion 21
     }
 
     lintOptions {
@@ -41,7 +41,7 @@
     androidTestCompile 'com.google.truth:truth:0.25'
     // This dependency exists only to work around an issue in the sdkmanager plugin v0.12.0. This
     // should be fixed when http://git.io/vIXec is checked in and a release is made.
-    androidTestCompile('com.android.support:support-v4:21.0.0')
+    androidTestCompile 'com.android.support:support-v4:21.0.0'
     androidTestCompile('com.android.support.test:runner:0.3') {
         exclude group: 'junit'  // junit:junit-dep conflicts with junit:unit
     }
diff --git a/android-lib/src/main/java/io/v/android/libs/discovery/ble/BlePlugin.java b/android-lib/src/main/java/io/v/android/libs/discovery/ble/BlePlugin.java
new file mode 100644
index 0000000..a729bf8
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/libs/discovery/ble/BlePlugin.java
@@ -0,0 +1,337 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.libs.discovery.ble;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattServer;
+import android.bluetooth.BluetoothGattServerCallback;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.le.AdvertiseCallback;
+import android.bluetooth.le.AdvertiseData;
+import android.bluetooth.le.AdvertiseSettings;
+import android.bluetooth.le.BluetoothLeAdvertiser;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanFilter;
+import android.bluetooth.le.ScanResult;
+import android.bluetooth.le.ScanRecord;
+import android.bluetooth.le.ScanSettings;
+import android.content.Context;
+import android.util.Log;
+
+import org.joda.time.Duration;
+
+import com.google.common.util.concurrent.Uninterruptibles;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.UUID;
+
+import io.v.impl.google.lib.discovery.DeviceCache;
+import io.v.impl.google.lib.discovery.UUIDUtil;
+import io.v.impl.google.lib.discovery.VScanner;
+import io.v.impl.google.lib.discovery.ble.BleAdvertisementConverter;
+import io.v.v23.context.VContext;
+import io.v.impl.google.lib.discovery.ScanHandler;
+import io.v.x.ref.lib.discovery.Advertisement;
+
+/**
+ * The discovery plugin interface for Bluetooth.
+ */
+public class BlePlugin {
+    // We are using a constant for the MTU because Android and paypal/gatt don't get along
+    // when the paypal gatt client sends a setMTU message.  The Android server seems to send
+    // a malformed L2CAP message.
+    private static final int MTU = 23;
+
+    // Object used to lock advertisement objects.
+    private final Object advertisementLock = new Object();
+    // The id to assign to the next advertisment.
+    private int nextAdv;
+    // A map of advertisement ids to the advertisement that corresponds to them.
+    private final Map<Integer, BluetoothGattService> advertisements = new HashMap<>();
+    // A map of advertisement ids to the thread waiting for cancellation of the context.
+    private final Map<Integer, Thread> advCancellationThreads = new HashMap<>();
+
+    // Object used to lock scanner objects
+    private final Object scannerLock = new Object();
+    // A map of scanner ids to the thread waiting for cancellation of the context.
+    private final Map<Integer, Thread> scanCancellationThreads = new HashMap<>();
+    private final DeviceCache cachedDevices;
+    // Used to track the set of devices we currently talking to.
+    private final Set<String> pendingCalls = new HashSet<>();
+
+    // Set of Ble objects that will be interacted with to perform operations.
+    private BluetoothLeAdvertiser bluetoothLeAdvertise;
+    private BluetoothLeScanner bluetoothLeScanner;
+    private BluetoothGattServer bluetoothGattServer;
+
+    // We need to hold onto the callbacks for scan an advertise because that is what is used
+    // to stop the operation.
+    private ScanCallback scanCallback;
+    private AdvertiseCallback advertiseCallback;
+
+    private boolean isScanning;
+
+    private final Context androidContext;
+
+
+    // A thread to wait for the cancellation of a particular advertisement.  VContext.done().await()
+    // is blocking so have to spin up a thread per outstanding advertisement.
+    private class AdvertisementCancellationRunner implements Runnable{
+        private final VContext ctx;
+
+        private final int id;
+        AdvertisementCancellationRunner(VContext ctx, int id) {
+            this.id = id;
+            this.ctx = ctx;
+        }
+
+        @Override
+        public void run() {
+            Uninterruptibles.awaitUninterruptibly(ctx.done());
+            BlePlugin.this.removeAdvertisement(id);
+        }
+    }
+
+    // Similar to AdvertisementCancellationRunner except for scanning.
+    private class ScannerCancellationRunner implements Runnable{
+        private VContext ctx;
+
+        private int id;
+        ScannerCancellationRunner(VContext ctx, int id) {
+            this.id = id;
+            this.ctx = ctx;
+        }
+
+        @Override
+        public void run() {
+            Uninterruptibles.awaitUninterruptibly(ctx.done());
+            BlePlugin.this.removeScanner(id);
+        }
+    }
+
+    public BlePlugin(Context androidContext) {
+        cachedDevices = new DeviceCache(Duration.standardMinutes(1));
+        bluetoothLeAdvertise = BluetoothAdapter.getDefaultAdapter().getBluetoothLeAdvertiser();
+        bluetoothLeScanner = BluetoothAdapter.getDefaultAdapter().getBluetoothLeScanner();
+        this.androidContext = androidContext;
+        BluetoothManager manager = (BluetoothManager) androidContext.getSystemService(
+                Context.BLUETOOTH_SERVICE);
+        bluetoothGattServer = manager.openGattServer(androidContext,
+                new BluetoothGattServerCallback() {
+            @Override
+            public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
+                super.onConnectionStateChange(device, status, newState);
+            }
+
+            @Override
+            public void onCharacteristicReadRequest(BluetoothDevice device, int requestId,
+                                                    int offset,
+                                                    BluetoothGattCharacteristic characteristic) {
+                super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
+                byte[] total =characteristic.getValue();
+                byte[] res = {};
+                // Only send MTU - 1 bytes. The first byte of all packets is the op code.
+                if (offset < total.length) {
+                    int finalByte = offset + MTU - 1;
+                    if (finalByte > total.length) {
+                        finalByte = total.length;
+                    }
+                    res = Arrays.copyOfRange(total, offset, finalByte);
+                    bluetoothGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, res);
+                } else {
+                    bluetoothGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_FAILURE, 0,  res);
+                }
+            }
+        });
+    }
+
+
+    // Converts a Vanadium Advertisement to a Bluetooth gatt service.
+    private BluetoothGattService convertToService(Advertisement adv) throws IOException {
+        Map<UUID, byte[]> attributes = BleAdvertisementConverter.vAdvertismentToBleAttr(adv);
+        BluetoothGattService service = new BluetoothGattService(
+                UUIDUtil.UuidToUUID(adv.getServiceUuid()), BluetoothGattService.SERVICE_TYPE_PRIMARY);
+        for (Map.Entry<UUID, byte[]> entry : attributes.entrySet()) {
+            BluetoothGattCharacteristic ch = new BluetoothGattCharacteristic(entry.getKey(), 0,
+                    BluetoothGattCharacteristic.PERMISSION_READ);
+            ch.setValue(entry.getValue());
+            service.addCharacteristic(ch);
+        }
+        return service;
+    }
+
+    public void addAdvertisement(VContext ctx, Advertisement advertisement) throws IOException {
+        BluetoothGattService service = convertToService(advertisement);
+        synchronized (advertisementLock) {
+            int currentId = nextAdv++;
+            advertisements.put(currentId, service);
+            Thread t = new Thread(new AdvertisementCancellationRunner(ctx, currentId));
+            t.start();
+            advCancellationThreads.put(currentId, t);
+            bluetoothGattServer.addService(service);
+            readvertise();
+        }
+    }
+
+    private void removeAdvertisement(int id) {
+        synchronized (advertisements) {
+            BluetoothGattService s = advertisements.get(id);
+            if (s != null) {
+                bluetoothGattServer.removeService(s);
+            }
+            advertisements.remove(id);
+            advCancellationThreads.remove(id);
+            readvertise();
+        }
+    }
+
+    public void addScanner(VContext ctx, UUID serviceUUID,  ScanHandler handler) {
+        VScanner scanner = new VScanner(serviceUUID, handler);
+        int currentId = cachedDevices.addScanner(scanner);
+        synchronized (scannerLock) {
+            Thread t = new Thread(new ScannerCancellationRunner(ctx, currentId));
+            t.start();
+            scanCancellationThreads.put(currentId, t);
+            updateScanning();
+        }
+    }
+
+    private void removeScanner(int id) {
+        cachedDevices.removeScanner(id);
+        synchronized (scannerLock) {
+            scanCancellationThreads.remove(id);
+            updateScanning();
+        }
+    }
+
+    private void updateScanning() {
+        if (isScanning && scanCancellationThreads.size() == 0) {
+            isScanning = false;
+            bluetoothLeScanner.stopScan(scanCallback);
+            return;
+        }
+
+        if (!isScanning && scanCancellationThreads.size() > 0) {
+            isScanning = true;
+            ScanFilter.Builder builder = new ScanFilter.Builder();
+            byte[] manufacturerData = {};
+            byte[] manufacturerMask = {};
+
+            builder.setManufacturerData(1001, manufacturerData, manufacturerMask);
+            final List<ScanFilter> scanFilter = new ArrayList<>();
+            scanFilter.add(builder.build());
+
+
+            scanCallback = new ScanCallback() {
+                @Override
+                public void onScanResult(int callbackType, ScanResult result) {
+                    // in L the only value for callbackType is CALLBACK_TYPE_ALL_MATCHES, so
+                    // we don't look at its value.
+                    ScanRecord record = result.getScanRecord();
+                    // Use 1001 to denote that this is a Vanadium device.  We picked an id that is
+                    // currently not in use.
+                    byte[] data = record.getManufacturerSpecificData(1001);
+                    ByteBuffer buffer = ByteBuffer.wrap(data);
+                    final long hash = buffer.getLong();
+                    final String deviceId = result.getDevice().getAddress();
+                    if (cachedDevices.haveSeenHash(hash, deviceId)) {
+                        return;
+                    }
+                    synchronized (scannerLock) {
+                        if (pendingCalls.contains(deviceId)) {
+                            Log.d("vanadium", "not connecting to " + deviceId + " because of pending connection");
+                            return;
+                        }
+                        pendingCalls.add(deviceId);
+                    }
+                    BluetoothGattClientCallback.Callback ccb = new BluetoothGattClientCallback.Callback() {
+                        @Override
+                        public void handle(Map<UUID, Map<UUID, byte[]>> services) {
+                            Set<Advertisement> advs = new HashSet<>();
+                            for (Map.Entry<UUID, Map<UUID, byte[]>> entry : services.entrySet()) {
+                                try {
+                                    Advertisement adv =
+                                            BleAdvertisementConverter.
+                                                    bleAttrToVAdvertisement(entry.getValue());
+                                    advs.add(adv);
+                                } catch (IOException e) {
+                                    Log.e("vanadium","Failed to convert advertisement" + e);
+                                }
+                            }
+                            cachedDevices.saveDevice(hash, advs, deviceId);
+                            synchronized (scannerLock) {
+                                pendingCalls.remove(deviceId);
+                            }
+                            bluetoothLeScanner.startScan(scanFilter, new ScanSettings.Builder().
+                                    setScanMode(ScanSettings.SCAN_MODE_BALANCED).build(), scanCallback);
+                        }
+                    };
+                    BluetoothGattClientCallback cb = new BluetoothGattClientCallback(ccb);
+                    bluetoothLeScanner.stopScan(scanCallback);
+                    Log.d("vanadium", "connecting to " + result.getDevice());
+                    result.getDevice().connectGatt(androidContext, false, cb);
+                }
+
+                @Override
+                public void onBatchScanResults(List<ScanResult> results) {
+                }
+
+                @Override
+                public void onScanFailed(int errorCode) {
+                }
+            };
+            bluetoothLeScanner.startScan(scanFilter, new ScanSettings.Builder().
+                    setScanMode(ScanSettings.SCAN_MODE_BALANCED).build(), scanCallback);
+        }
+    }
+
+    private void readvertise() {
+        if (advertiseCallback != null) {
+            bluetoothLeAdvertise.stopAdvertising(advertiseCallback);
+            advertiseCallback = null;
+        }
+        if (advertisements.size() == 0) {
+            return;
+        }
+
+        int hash = advertisements.hashCode();
+
+        AdvertiseData.Builder builder = new AdvertiseData.Builder();
+        ByteBuffer buf = ByteBuffer.allocate(9);
+        buf.put((byte) 8);
+        buf.putLong(hash);
+        builder.addManufacturerData(1001, buf.array());
+        AdvertiseSettings.Builder settingsBuilder = new AdvertiseSettings.Builder();
+        settingsBuilder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY);
+        settingsBuilder.setConnectable(true);
+        advertiseCallback = new AdvertiseCallback() {
+                    @Override
+                    public void onStartSuccess(AdvertiseSettings settingsInEffect) {
+                        Log.i("vanadium", "Successfully started " + settingsInEffect);
+                    }
+
+                    @Override
+                    public void onStartFailure(int errorCode) {
+                        Log.i("vanadium", "Failed to start advertising " + errorCode);
+                    }
+                };
+        bluetoothLeAdvertise.startAdvertising(settingsBuilder.build(), builder.build(),
+                advertiseCallback);
+    }
+}
\ No newline at end of file
diff --git a/android-lib/src/main/java/io/v/android/libs/discovery/ble/BluetoothGattClientCallback.java b/android-lib/src/main/java/io/v/android/libs/discovery/ble/BluetoothGattClientCallback.java
new file mode 100644
index 0000000..991ed60
--- /dev/null
+++ b/android-lib/src/main/java/io/v/android/libs/discovery/ble/BluetoothGattClientCallback.java
@@ -0,0 +1,106 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.android.libs.discovery.ble;
+
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattService;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * A handler for responses from a GattServer.
+ */
+public class BluetoothGattClientCallback extends BluetoothGattCallback {
+    /**
+     * A handler that will get called when all the services from a gatt service
+     * are read.
+     */
+    public interface Callback {
+        /**
+         * Called with the map of service ids to their attributes.
+         * @param services A map from service id to (characteristics uuid to values).
+         */
+        void handle(Map<UUID, Map<UUID, byte[]>> services);
+    }
+    // We want to ignore the GATT and GAP services, which are 1800 and 1801 respectively.
+    static final String GATT_AND_GAP_PREFIX = "0000180";
+
+    private final Callback callback;
+
+    private final Map<UUID, Map<UUID, byte[]>> services = new HashMap<>();
+
+    private BluetoothGatt gatt;
+
+    private final List<BluetoothGattCharacteristic> chars = new ArrayList<>();
+    private int pos;
+
+    BluetoothGattClientCallback(Callback cb) {
+        callback = cb;
+    }
+
+    @Override
+    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+        for (BluetoothGattService service : gatt.getServices()) {
+            // Skip the GATT AND GAP Services.
+            if (service.getUuid().toString().startsWith(GATT_AND_GAP_PREFIX)) {
+                continue;
+            }
+            services.put(service.getUuid(), new HashMap<UUID, byte[]>());
+            // We only keep track of the characteristics that can be read.
+            for (BluetoothGattCharacteristic ch : chars) {
+                if ((ch.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) != 0) {
+                    chars.add(ch);
+                }
+            }
+        }
+        pos = 0;
+        maybeReadNextCharacteristic();
+    }
+
+    // Reads the next characteristic if there is one.  Otherwise calls callback and
+    // closes the gatt connection.
+    private void maybeReadNextCharacteristic() {
+        if (pos >= chars.size()) {
+            gatt.disconnect();
+            gatt.close();
+            callback.handle(services);
+            return;
+        }
+        BluetoothGattCharacteristic c = chars.get(pos++);
+        if (!gatt.readCharacteristic(c)) {
+            Log.d("vanadium", "Failed to read characteristic " + c.getUuid());
+            maybeReadNextCharacteristic();
+        }
+    }
+
+    @Override
+    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+        UUID serviceUUID = characteristic.getService().getUuid();
+        services.get(serviceUUID).put(characteristic.getUuid(), characteristic.getValue());
+        maybeReadNextCharacteristic();
+    }
+
+    @Override
+    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
+        Log.d("vanadium", "new connections state is " + newState);
+
+        this.gatt = gatt;
+        if (status != BluetoothGatt.GATT_SUCCESS || newState != BluetoothGatt.STATE_CONNECTED) {
+            Log.d("vanadium", "failed to connect with status " + status + " state" + newState);
+            gatt.close();
+            callback.handle(null);
+            return;
+        }
+        gatt.discoverServices();
+    }
+}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c938d52..3adbe3f 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Fri Apr 03 13:08:46 PDT 2015
+#Thu Oct 01 14:08:26 PDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-all.zip
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/DeviceCache.java b/lib/src/main/java/io/v/impl/google/lib/discovery/DeviceCache.java
new file mode 100644
index 0000000..4bf4ab2
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/DeviceCache.java
@@ -0,0 +1,174 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.Sets;
+
+import org.joda.time.Duration;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.v.x.ref.lib.discovery.Advertisement;
+
+/**
+ * A cache of ble devices that were seen recently.  The current Vanadium BLE protocol requires
+ * connecting to the advertiser to grab the attributes and the addrs.  This can be expensive
+ * so we only refetch the data if it hash changed.
+ */
+public class DeviceCache {
+    final private Map<Long, CacheEntry> cachedDevices = new HashMap<>();
+    final private Map<String, CacheEntry> knownIds = new HashMap<>();
+
+
+    final AtomicInteger nextScanner = new AtomicInteger(0);
+    final private SetMultimap<UUID, Advertisement> knownServices = HashMultimap.create();
+    final private Map<Integer, VScanner> scannersById = new HashMap<>();
+    final private SetMultimap<UUID, VScanner> scannersByUUID = HashMultimap.create();
+
+    final private Duration maxAge;
+
+
+    public DeviceCache(Duration maxAge) {
+        this.maxAge = maxAge;
+    }
+
+    /**
+     * Returns whether this hash has been seen before.
+     *
+     * @param hash the hash of the advertisement
+     * @param deviceId the deviceId of the advertisement (used to handle rotating ids).
+     * @return true iff this hash is in the cache.
+     */
+    public boolean haveSeenHash(long hash, String deviceId) {
+        synchronized (this) {
+            CacheEntry entry = cachedDevices.get(hash);
+            if (entry != null) {
+                entry.lastSeen = new Date();
+                if (!entry.deviceId.equals(deviceId)) {
+                    // This probably happened becuase a device has changed it's ble mac address.
+                    // We need to update the mac address for this entry.
+                    knownIds.remove(entry.deviceId);
+                    entry.deviceId = deviceId;
+                    knownIds.put(deviceId, entry);
+                }
+            }
+            return entry != null;
+        }
+    }
+
+    /**
+     * Saves the set of advertisements for this deviceId and hash
+     *
+     * @param hash the hash provided by the advertisement.
+     * @param advs the advertisements exposed by the device.
+     * @param deviceId the id of the device.
+     */
+    public void saveDevice(long hash, Set<Advertisement> advs, String deviceId) {
+        CacheEntry entry = new CacheEntry(advs, hash, deviceId);
+        synchronized (this) {
+            CacheEntry oldEntry = knownIds.get(deviceId);
+            Set<Advertisement> oldValues = null;
+            if (oldEntry != null) {
+                cachedDevices.remove(oldEntry.hash);
+                knownIds.remove(oldEntry.deviceId);
+                oldValues = oldEntry.advertisements;
+            } else {
+                oldValues = new HashSet<>();
+            }
+            Set<Advertisement> removed = Sets.difference(oldValues, advs);
+            for (Advertisement adv : removed) {
+                UUID uuid = UUIDUtil.UuidToUUID(adv.getServiceUuid());
+                adv.setLost(true);
+                knownServices.remove(uuid, adv);
+                handleUpdate(adv);
+            }
+
+            Set<Advertisement> added = Sets.difference(advs, oldValues);
+            for (Advertisement adv: added) {
+                UUID uuid = UUIDUtil.UuidToUUID(adv.getServiceUuid());
+                knownServices.put(uuid, adv);
+                handleUpdate(adv);
+            }
+            cachedDevices.put(hash, entry);
+            CacheEntry oldDeviceEntry = knownIds.get(deviceId);
+            if (oldDeviceEntry != null) {
+                // Delete the old hash value.
+                cachedDevices.remove(hash);
+            }
+            knownIds.put(deviceId, entry);
+        }
+    }
+
+    private void handleUpdate(Advertisement adv) {
+        UUID uuid = UUIDUtil.UuidToUUID(adv.getServiceUuid());
+        Set<VScanner> scanners = scannersByUUID.get(uuid);
+        if (scanners == null) {
+            return;
+        }
+        for (VScanner scanner : scanners) {
+            scanner.getHandler().handleUpdate(adv);
+        }
+    }
+
+    /**
+     * Adds a scanner that will be notified when advertisements that match its query have changed.
+     *
+     * @return the handle of the scanner that can be used to remove the scanner.
+     */
+    public int addScanner(VScanner scanner) {
+        synchronized (this) {
+            int id = nextScanner.addAndGet(1);
+            scannersById.put(id, scanner);
+            scannersByUUID.put(scanner.getServiceUUID(), scanner);
+            Set<Advertisement> knownAdvs = knownServices.get(scanner.getServiceUUID());
+            if (knownAdvs != null) {
+                for (Advertisement adv : knownAdvs) {
+                    scanner.getHandler().handleUpdate(adv);
+                }
+            }
+            return id;
+        }
+    }
+
+    /**
+     * Removes the scanner matching this id.  This scanner will stop getting updates.
+     */
+    public void removeScanner(int id) {
+        synchronized (this) {
+            VScanner scanner = scannersById.get(id);
+            if (scanner != null) {
+                scannersByUUID.remove(scanner.getServiceUUID(), scanner);
+                scannersById.remove(id);
+            }
+        }
+    }
+
+    private class CacheEntry {
+        Set<Advertisement> advertisements;
+
+        long hash;
+
+        Date lastSeen;
+
+        String deviceId;
+
+        CacheEntry(Set<Advertisement> advs, long hash, String deviceId) {
+            advertisements = advs;
+            this.hash = hash;
+            lastSeen = new Date();
+            this.deviceId = deviceId;
+        }
+    }
+
+}
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/EncodingUtil.java b/lib/src/main/java/io/v/impl/google/lib/discovery/EncodingUtil.java
new file mode 100644
index 0000000..ca88cad
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/EncodingUtil.java
@@ -0,0 +1,136 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+
+import com.google.common.primitives.Bytes;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+import io.v.v23.vom.BinaryUtil;
+import io.v.x.ref.lib.discovery.EncryptionKey;
+
+/**
+ * A utility to encode and decode fields in io.v.v23.Service fields for use in discovery.
+ */
+public class EncodingUtil {
+    static final Charset UTF8_CHARSET = Charset.forName("UTF-8");
+
+    /**
+     * Encodes the addresses passed in.
+     *
+     * @param addrs the list of addresses to encode.
+     * @return the byte representation of the encoded addresses.
+     * @throws IOException if the address can't be encoded.
+     */
+    public static byte[] packAddresses(List<String> addrs) throws IOException {
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        for (String addr : addrs) {
+            BinaryUtil.encodeUint(stream, addr.length());
+            stream.write(addr.getBytes(UTF8_CHARSET));
+        }
+        return stream.toByteArray();
+    }
+
+    /**
+     * Decodes addresses from a byte array that was encoded by packAddresses
+     *
+     * @param input the byte array toe decode
+     * @return the list of addresses.
+     * @throws IOException if the addresses can't be decoded.
+     */
+    public static List<String> unpackAddresses(byte[] input) throws IOException {
+        ByteArrayInputStream stream = new ByteArrayInputStream(input);
+        List<String> output = new ArrayList<>();
+        while (stream.available() > 0) {
+            int stringSize = (int)BinaryUtil.decodeUint(stream);
+            byte[] data = new byte[stringSize];
+            int read = stream.read(data);
+            if (read != stringSize) {
+                throw new IOException("Unexpected end of stream while reading address");
+            }
+            output.add(new String(data, UTF8_CHARSET));
+        }
+        return output;
+    }
+
+    /**
+     * Encode the encryption keys and algorithm passed in.
+     *
+     * @param encryptionAlgorithm the encryption algorithm to use.
+     *                            See io.v.x.ref.lib.discovery.Constants for valid values.
+     * @param keys the keys to encode
+     * @return the byte array that is the encoded form.
+     * @throws IOException if the keys can't be encoded.
+     */
+    public static byte[] packEncryptionKeys(int encryptionAlgorithm, List<EncryptionKey> keys)
+            throws IOException {
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        BinaryUtil.encodeUint(stream, encryptionAlgorithm);
+        for (EncryptionKey key : keys) {
+            byte[] byteKey = Bytes.toArray(key);
+            BinaryUtil.encodeUint(stream, byteKey.length);
+            stream.write(byteKey);
+        }
+        return stream.toByteArray();
+    }
+
+
+    /**
+     * Decodes the encryption algorithm and keys that was encoded by packEncryptionKeys.
+     *
+     * @param input the byte array containg the keys.
+     * @return the keys and the encryption algorithm in input.
+     * @throws IOException if the keys can't be decoded.
+     */
+    public static KeysAndAlgorithm unpackEncryptionKeys(byte[] input) throws IOException {
+        ByteArrayInputStream stream = new ByteArrayInputStream(input);
+        int algo = (int) BinaryUtil.decodeUint(stream);
+        List<EncryptionKey> keys = new ArrayList<>();
+        while (stream.available() > 0) {
+            int size = (int) BinaryUtil.decodeUint(stream);
+            byte[] key = new byte[size];
+            int read = stream.read(key);
+            if (read != size) {
+                throw new IOException("Unexpected end of file reading keys");
+            }
+            keys.add(new EncryptionKey(Bytes.asList(key)));
+        }
+        return new KeysAndAlgorithm(algo, keys);
+    }
+
+    /**
+     * Stores {@link EncryptionKey}s and the encryption algorithm.
+     */
+    public static class KeysAndAlgorithm {
+        int encryptionAlgorithm;
+        List<EncryptionKey> keys;
+
+        /**
+         * Returns the stored encryption algorithm.
+         */
+        public int getEncryptionAlgorithm() {
+            return encryptionAlgorithm;
+        }
+
+        /**
+         * Returns the stored keys.
+         */
+        public List<EncryptionKey> getKeys() {
+            return keys;
+        }
+
+        KeysAndAlgorithm(int encryptionAlgo, List<EncryptionKey> keys) {
+            encryptionAlgorithm = encryptionAlgo;
+            this.keys = keys;
+        }
+    }
+
+}
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/ScanHandler.java b/lib/src/main/java/io/v/impl/google/lib/discovery/ScanHandler.java
new file mode 100644
index 0000000..ec4268b
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/ScanHandler.java
@@ -0,0 +1,19 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+import io.v.x.ref.lib.discovery.Advertisement;
+
+/**
+ * An interface that is passed into a Vanadium Discovery Scan operation that will handle updates.
+ */
+public interface ScanHandler {
+    /**
+     * Called when there is a new advertisement or an update to and old advertisement
+     */
+    void handleUpdate(Advertisement advertisement);
+}
+
+
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/UUIDUtil.java b/lib/src/main/java/io/v/impl/google/lib/discovery/UUIDUtil.java
new file mode 100644
index 0000000..da95af9
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/UUIDUtil.java
@@ -0,0 +1,44 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+import com.google.common.primitives.Bytes;
+
+import java.nio.ByteBuffer;
+import java.util.UUID;
+
+import io.v.x.ref.lib.discovery.Uuid;
+
+/**
+ * A class for generating v5 UUIDs and converting from {@link UUID} and
+ * {@link Uuid}.  {@link UUID} does not provide
+ * any mechanism to compute v5 UUIDs which are used to convert InterfaceNames to service
+ * UUIDs.  Conversion from {@link Uuid} and {@link UUID} is necessary because the VDL type
+ * and the native type are annoying to convert to.
+ */
+public class UUIDUtil {
+    public static native UUID UUIDForInterfaceName(String name);
+
+    public static native UUID UUIDForAttributeKey(String key);
+
+    /**
+     * Converts from {@link UUID} to {@link Uuid}.
+     */
+    public static Uuid UUIDToUuid(UUID id) {
+        ByteBuffer b = ByteBuffer.allocate(16);
+        b.putLong(id.getMostSignificantBits());
+        b.putLong(id.getLeastSignificantBits());
+        return new Uuid(Bytes.asList(b.array()));
+    }
+
+    /**
+     * Converts from {@link Uuid} to {@link UUID}
+     */
+    public static UUID UuidToUUID(Uuid id) {
+        ByteBuffer b = ByteBuffer.wrap(Bytes.toArray(id));
+        return new UUID(b.getLong(), b.getLong());
+    }
+}
+
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/VScanner.java b/lib/src/main/java/io/v/impl/google/lib/discovery/VScanner.java
new file mode 100644
index 0000000..1f99a4d
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/VScanner.java
@@ -0,0 +1,34 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+import java.util.UUID;
+
+import io.v.impl.google.lib.discovery.ScanHandler;
+
+/**
+ * Stores a {@link UUID} and a {@link ScanHandler}.
+ */
+public class VScanner {
+    private UUID serviceUUID;
+
+    private ScanHandler handler;
+
+    public VScanner(UUID serviceUUID, ScanHandler handler) {
+        this.serviceUUID = serviceUUID;
+        this.handler = handler;
+    }
+
+    /** Returns the {@link UUID} */
+    public UUID getServiceUUID() {
+        return serviceUUID;
+    }
+
+    /** Returns the {@link ScanHandler} */
+    public ScanHandler getHandler() {
+        return handler;
+    }
+
+}
diff --git a/lib/src/main/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverter.java b/lib/src/main/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverter.java
new file mode 100644
index 0000000..03c966f
--- /dev/null
+++ b/lib/src/main/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverter.java
@@ -0,0 +1,117 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery.ble;
+
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import io.v.impl.google.lib.discovery.EncodingUtil;
+import io.v.impl.google.lib.discovery.UUIDUtil;
+import io.v.x.ref.lib.discovery.Advertisement;
+import io.v.v23.discovery.Attributes;
+import io.v.v23.discovery.Service;
+import io.v.x.ref.lib.discovery.EncryptionAlgorithm;
+import io.v.x.ref.lib.discovery.EncryptionKey;
+import io.v.x.ref.lib.discovery.plugins.ble.Constants;
+
+/**
+ * Converts from {@link Advertisement} to the gatt services and vice-versa.
+ */
+public class BleAdvertisementConverter {
+    private static Charset utf8 = Charset.forName("UTF-8");
+
+    /**
+     * Converts from {@link Advertisement} to the ble representation.
+     *
+     * @return map of Characteristic UUIDs to their values.
+     * @throws IOException
+     */
+    public static Map<UUID, byte[]> vAdvertismentToBleAttr(Advertisement adv)
+            throws IOException {
+        Map<UUID, byte[]> attr = new HashMap<>();
+        Service service = adv.getService();
+        attr.put(UUID.fromString(Constants.INTERFACE_NAME_UUID),
+                service.getInterfaceName().getBytes(utf8));
+        attr.put(UUID.fromString(Constants.INSTANCE_UUID), service.getInstanceUuid());
+        attr.put(UUID.fromString(Constants.ADDRS_UUID),
+                EncodingUtil.packAddresses(service.getAddrs()));
+
+        String instanceName = service.getInstanceName();
+        if (instanceName != null && !instanceName.equals("")) {
+            attr.put(UUID.fromString(Constants.INSTANCE_NAME_UUID), instanceName.getBytes(utf8));
+        }
+
+        if (adv.getEncryptionAlgorithm().getValue() != 0) {
+            attr.put(UUID.fromString(Constants.ENCRYPTION_UUID),
+                    EncodingUtil.packEncryptionKeys(adv.getEncryptionAlgorithm().getValue(),
+                            adv.getEncryptionKeys()));
+        }
+
+        for (Map.Entry<String, String> keyAndValue : service.getAttrs().entrySet()) {
+            String key = keyAndValue.getKey();
+            UUID attrKey = UUIDUtil.UUIDForAttributeKey(key);
+            String attrValue = key + "=" + keyAndValue.getValue();
+            attr.put(attrKey, attrValue.getBytes(utf8));
+        }
+        return attr;
+    }
+
+    /**
+     * Converts from Map of Characteristic UUIDs -> values to a {@link Advertisement}
+     *
+     * @param attr the map of characteristic uuids to their values
+     * @return the Vanadium Advertisement based on characteristics.
+     * @throws IOException
+     */
+    public static Advertisement bleAttrToVAdvertisement(Map<UUID, byte[]> attr)
+            throws IOException {
+        Map<String, String> cleanAttrs = new HashMap<String, String>();
+        byte[] instanceId = null;
+        String interfaceName = null;
+        String instanceName = null;
+        List<String> addrs = null;
+        int encryptionAlgo = 0;
+        List<EncryptionKey> encryptionKeys = null;
+
+        for (Map.Entry<UUID, byte[]> entry : attr.entrySet()) {
+            String uuidKey = entry.getKey().toString();
+            System.out.println("key is " + uuidKey);
+            byte[] value = entry.getValue();
+            if (uuidKey.equals(Constants.INSTANCE_UUID)) {
+                instanceId = value;
+            } else if (uuidKey.equals(Constants.INSTANCE_NAME_UUID)) {
+                instanceName = new String(value, utf8);
+            } else if (uuidKey.equals(Constants.INTERFACE_NAME_UUID)) {
+                interfaceName = new String(value, utf8);
+            } else if (uuidKey.equals(Constants.ADDRS_UUID)) {
+                addrs = EncodingUtil.unpackAddresses(value);
+            } else if (uuidKey.equals(Constants.ENCRYPTION_UUID)) {
+                EncodingUtil.KeysAndAlgorithm res = EncodingUtil.unpackEncryptionKeys(value);
+                encryptionAlgo = res.getEncryptionAlgorithm();
+                encryptionKeys = res.getKeys();
+            } else {
+                String keyAndValue = new String(value, utf8);
+                String[] parts = keyAndValue.split("=", 2);
+                if (parts.length != 2) {
+                    System.err.println("Failed to parse key and value" + keyAndValue);
+                    continue;
+                }
+                cleanAttrs.put(parts[0], parts[1]);
+            }
+        }
+        return new Advertisement(
+                new Service(instanceId, instanceName, interfaceName, new Attributes(cleanAttrs),
+                        addrs),
+                UUIDUtil.UUIDToUuid(UUIDUtil.UUIDForInterfaceName(interfaceName)),
+                new EncryptionAlgorithm(encryptionAlgo),
+                encryptionKeys,
+                false);
+    }
+}
diff --git a/lib/src/main/java/io/v/v23/vom/BinaryUtil.java b/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
index 1a73d90..e739dbb 100644
--- a/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
+++ b/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
@@ -15,7 +15,7 @@
 /**
  * Binary encoding and decoding routines.
  */
-final class BinaryUtil {
+public final class BinaryUtil {
     /**
      * Every binary stream starts with this magic byte, to distinguish the binary encoding from
      * the JSON encoding. Note that every valid JSON encoding must start with an ASCII character,or
diff --git a/lib/src/test/java/io/v/impl/google/lib/discovery/DeviceCacheTest.java b/lib/src/test/java/io/v/impl/google/lib/discovery/DeviceCacheTest.java
new file mode 100644
index 0000000..7ea8bc7
--- /dev/null
+++ b/lib/src/test/java/io/v/impl/google/lib/discovery/DeviceCacheTest.java
@@ -0,0 +1,209 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+import junit.framework.TestCase;
+import org.joda.time.Duration;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+import io.v.v23.discovery.Service;
+import io.v.x.ref.lib.discovery.Advertisement;
+import io.v.x.ref.lib.discovery.EncryptionAlgorithm;
+import io.v.x.ref.lib.discovery.Uuid;
+
+/**
+ * Testis for {@link DeviceCache}.
+ */
+public class DeviceCacheTest extends TestCase {
+    private abstract class CountingHandler implements ScanHandler {
+        protected int mNumCalls = 0;
+
+        @Override
+        public void handleUpdate(Advertisement adv) {}
+    }
+
+    public void testSaveDeveice() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        // The advertisements here are not relevant since we are just checking
+        // the seen hash function.
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+        cache.saveDevice(hash, advs, "newDevice");
+        assertTrue(cache.haveSeenHash(hash, "newDevice"));
+    }
+
+    public void testSaveDeviceWithDifferentHashCode() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        // The advertisements here are not relevant since we are just checking
+        // the seen hash function.
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+        cache.saveDevice(hash, advs, "newDevice");
+        assertTrue(cache.haveSeenHash(hash, "newDevice"));
+        cache.saveDevice(hash + 1, advs, "newDevice");
+        assertTrue(cache.haveSeenHash(hash + 1, "newDevice"));
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+    }
+
+    public void testAddingScannerBeforeSavingDevice() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+
+        Service service1 = new Service();
+        service1.setInterfaceName("randomInterface");
+        Uuid uuid1 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        final Advertisement adv1 = new Advertisement(service1, uuid1, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv1);
+
+        CountingHandler handler = new CountingHandler() {
+            @Override
+            public void handleUpdate(Advertisement advertisement) {
+                assertEquals(adv1, advertisement);
+                assertEquals(mNumCalls, 0);
+                mNumCalls++;
+            }
+        };
+
+        cache.addScanner(new VScanner(UUIDUtil.UuidToUUID(uuid1), handler));
+
+        Service service2 = new Service();
+        service1.setInterfaceName("randomInterface2");
+        Uuid uuid2 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        Advertisement adv2 = new Advertisement(service2, uuid2, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv2);
+
+        cache.saveDevice(hash, advs, "newDevice");
+
+        // Make sure that the handler is called;
+        assertEquals(1, handler.mNumCalls);
+    }
+
+    public void testAddingScannerAfterSavingDevice() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+
+        Service service1 = new Service();
+        service1.setInterfaceName("randomInterface");
+        Uuid uuid1 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        final Advertisement adv1 = new Advertisement(service1, uuid1, new EncryptionAlgorithm(0), null, false);
+
+        advs.add(adv1);
+
+        CountingHandler handler = new CountingHandler() {
+            @Override
+            public void handleUpdate(Advertisement advertisement) {
+                assertEquals(adv1, advertisement);
+                assertEquals(mNumCalls, 0);
+                mNumCalls++;
+            }
+        };
+
+        Service service2 = new Service();
+        service1.setInterfaceName("randomInterface2");
+        Uuid uuid2 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        Advertisement adv2 = new Advertisement(service2, uuid2, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv2);
+        cache.saveDevice(hash, advs, "newDevice");
+
+        cache.addScanner(new VScanner(UUIDUtil.UuidToUUID(uuid1), handler));
+
+        // Make sure that the handler is called;
+        assertEquals(1, handler.mNumCalls);
+    }
+
+    public void testRemovingAnAdvertisementCallsHandler() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+
+        Service service1 = new Service();
+        service1.setInterfaceName("randomInterface");
+        Uuid uuid1 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        final Advertisement adv1 = new Advertisement(service1, uuid1, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv1);
+
+        CountingHandler handler = new CountingHandler() {
+            @Override
+            public void handleUpdate(Advertisement advertisement) {
+                // The first call should be an add and the second call should be
+                // a remove.
+                if (mNumCalls == 0) {
+                    assertEquals(adv1, advertisement);
+                } else {
+                    Advertisement removed = new Advertisement(
+                            adv1.getService(), adv1.getServiceUuid(),
+                            adv1.getEncryptionAlgorithm(), adv1.getEncryptionKeys(), true);
+                    assertEquals(removed, advertisement);
+                }
+                mNumCalls++;
+            }
+        };
+
+        cache.addScanner(new VScanner(UUIDUtil.UuidToUUID(uuid1), handler));
+
+        Service service2 = new Service();
+        service2.setInterfaceName("randomInterface2");
+        Uuid uuid2 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        Advertisement adv2 = new Advertisement(service2, uuid2, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv2);
+
+        cache.saveDevice(hash, advs, "newDevice");
+
+        Set<Advertisement> newAdvs = new HashSet<>();
+        newAdvs.add(adv2);
+
+        cache.saveDevice(10002, newAdvs, "newDevice");
+
+        // Make sure that the handler is called;
+        assertEquals(2, handler.mNumCalls);
+    }
+
+    public void testAddingtheSameAdvertisementDoesNotCallsHandler() {
+        DeviceCache cache = new DeviceCache(new Duration(1000 * 60 * 60));
+        Set<Advertisement> advs = new HashSet<>();
+        long hash = 10001;
+        assertFalse(cache.haveSeenHash(hash, "newDevice"));
+
+        Service service1 = new Service();
+        service1.setInterfaceName("randomInterface");
+        Uuid uuid1 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        final Advertisement adv1 = new Advertisement(service1, uuid1, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv1);
+
+        CountingHandler handler = new CountingHandler() {
+            @Override
+            public void handleUpdate(Advertisement advertisement) {
+                assertEquals(adv1, advertisement);
+                mNumCalls++;
+            }
+        };
+
+        cache.addScanner(new VScanner(UUIDUtil.UuidToUUID(uuid1), handler));
+
+        Service service2 = new Service();
+        service2.setInterfaceName("randomInterface2");
+        Uuid uuid2 = UUIDUtil.UUIDToUuid(UUID.randomUUID());
+        Advertisement adv2 = new Advertisement(service2, uuid2, new EncryptionAlgorithm(0), null, false);
+        advs.add(adv2);
+
+        cache.saveDevice(hash, advs, "newDevice");
+
+        Set<Advertisement> advs2 = new HashSet<>(advs);
+        cache.saveDevice(10002, advs2, "newDevice");
+
+        // Make sure that the handler is called;
+        assertEquals(1, handler.mNumCalls);
+    }
+}
diff --git a/lib/src/test/java/io/v/impl/google/lib/discovery/EncodingUtilTest.java b/lib/src/test/java/io/v/impl/google/lib/discovery/EncodingUtilTest.java
new file mode 100644
index 0000000..7f2c6cf
--- /dev/null
+++ b/lib/src/test/java/io/v/impl/google/lib/discovery/EncodingUtilTest.java
@@ -0,0 +1,52 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+
+import junit.framework.TestCase;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import io.v.x.ref.lib.discovery.EncryptionAlgorithm;
+import io.v.x.ref.lib.discovery.testdata.PackAddressTest;
+import io.v.x.ref.lib.discovery.testdata.Constants;
+import io.v.x.ref.lib.discovery.testdata.PackEncryptionKeysTest;
+
+/**
+ * Tests for {@link EncodingUtil}.
+ */
+public class EncodingUtilTest extends TestCase {
+    public void testPackAddresses() throws IOException {
+        for (PackAddressTest test : Constants.PACK_ADDRESS_TEST_DATA) {
+            assertEquals(Arrays.toString(test.getPacked()),
+                    Arrays.toString(EncodingUtil.packAddresses(test.getIn())));
+        }
+    }
+
+    public void testUnpackAddresses() throws IOException {
+         for (PackAddressTest test : Constants.PACK_ADDRESS_TEST_DATA) {
+            assertEquals(test.getIn(),
+                    EncodingUtil.unpackAddresses(test.getPacked()));
+        }
+    }
+
+    public void testPackEncryptionKeys() throws IOException {
+        for (PackEncryptionKeysTest test : Constants.PACK_ENCRYPTION_KEYS_TEST_DATA) {
+            byte[] res = EncodingUtil.packEncryptionKeys(test.getAlgo().getValue(),
+                    test.getKeys());
+            assertEquals(Arrays.toString(test.getPacked()), Arrays.toString(res));
+        }
+    }
+
+    public void testUnpackEncryptionKeys() throws IOException {
+         for (PackEncryptionKeysTest test : Constants.PACK_ENCRYPTION_KEYS_TEST_DATA) {
+             EncodingUtil.KeysAndAlgorithm res = EncodingUtil.unpackEncryptionKeys(
+                     test.getPacked());
+             assertEquals(test.getAlgo(), new EncryptionAlgorithm(res.getEncryptionAlgorithm()));
+             assertEquals(test.getKeys(), res.getKeys());
+        }
+    }
+}
diff --git a/lib/src/test/java/io/v/impl/google/lib/discovery/UUIDUtilTest.java b/lib/src/test/java/io/v/impl/google/lib/discovery/UUIDUtilTest.java
new file mode 100644
index 0000000..f28ea48
--- /dev/null
+++ b/lib/src/test/java/io/v/impl/google/lib/discovery/UUIDUtilTest.java
@@ -0,0 +1,27 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery;
+
+import junit.framework.TestCase;
+
+import java.util.UUID;
+
+import io.v.v23.V;
+import io.v.v23.context.VContext;
+import io.v.x.ref.lib.discovery.testdata.Constants;
+import io.v.x.ref.lib.discovery.testdata.UuidTestData;
+
+/**
+ * Tests for {@link UUIDUtil}.
+ */
+public class UUIDUtilTest extends TestCase {
+    public void testInterfaceNameUUID() {
+        VContext ctx = V.init();
+        for (UuidTestData test: Constants.INTERFACE_NAME_TEST) {
+            UUID id = UUIDUtil.UUIDForInterfaceName(test.getIn());
+            assertEquals(test.getWant(), id.toString());
+        }
+    }
+}
diff --git a/lib/src/test/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverterTest.java b/lib/src/test/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverterTest.java
new file mode 100644
index 0000000..90809d4
--- /dev/null
+++ b/lib/src/test/java/io/v/impl/google/lib/discovery/ble/BleAdvertisementConverterTest.java
@@ -0,0 +1,55 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.impl.google.lib.discovery.ble;
+
+import junit.framework.TestCase;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import io.v.v23.V;
+import io.v.x.ref.lib.discovery.Advertisement;
+import io.v.x.ref.lib.discovery.plugins.ble.testdata.AdvertisementConversionTestCase;
+import io.v.x.ref.lib.discovery.plugins.ble.testdata.Constants;
+
+/**
+ * Tests for {@link BleAdvertisementConverter}
+ */
+public class BleAdvertisementConverterTest extends TestCase {
+    private static Map<UUID, byte[]> convertBAdv(Map<String, byte[]> in) {
+        Map<UUID, byte[]> res = new HashMap<>(in.size());
+        for (Map.Entry<String, byte[]> entry : in.entrySet()) {
+            res.put(UUID.fromString(entry.getKey()), entry.getValue());
+        }
+        return res;
+    }
+
+    public void testConversionToBle() throws IOException {
+        // V.init() sets up the jni bindings.
+        V.init();
+        for (AdvertisementConversionTestCase test : Constants.CONVERSION_TEST_DATA) {
+            Map<UUID, byte[]> res = BleAdvertisementConverter.vAdvertismentToBleAttr(
+                    test.getVAdvertisement());
+            Map<String, byte[]> want = test.getBleAdvertisement();
+            assertEquals(want.size(), res.size());
+            for (Map.Entry<UUID, byte[]> entry : res.entrySet()) {
+                String stringKey = entry.getKey().toString();
+                assertTrue(Arrays.equals(want.get(stringKey), entry.getValue()));
+            }
+        }
+    }
+    public void testConversionFromBle() throws IOException {
+        // V.init() sets up the jni bindings.
+        V.init();
+        for (AdvertisementConversionTestCase test : Constants.CONVERSION_TEST_DATA) {
+            Map<UUID, byte[]> bleAdv = convertBAdv(test.getBleAdvertisement());
+            Advertisement res = BleAdvertisementConverter.bleAttrToVAdvertisement(bleAdv);
+            assertEquals(test.getVAdvertisement(), res);
+        }
+    }
+}
diff --git a/projects/build.gradle b/projects/build.gradle
index e69de29..571b417 100644
--- a/projects/build.gradle
+++ b/projects/build.gradle
@@ -0,0 +1,2 @@
+dependencies {
+}
\ No newline at end of file
diff --git a/projects/discovery_sample/.gitignore b/projects/discovery_sample/.gitignore
new file mode 100644
index 0000000..9c4de58
--- /dev/null
+++ b/projects/discovery_sample/.gitignore
@@ -0,0 +1,7 @@
+.gradle
+/local.properties
+/.idea/workspace.xml
+/.idea/libraries
+.DS_Store
+/build
+/captures
diff --git a/projects/discovery_sample/app/.gitignore b/projects/discovery_sample/app/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/projects/discovery_sample/app/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/projects/discovery_sample/app/build.gradle b/projects/discovery_sample/app/build.gradle
new file mode 100644
index 0000000..02fe43b
--- /dev/null
+++ b/projects/discovery_sample/app/build.gradle
@@ -0,0 +1,73 @@
+buildscript {
+    repositories {
+        mavenCentral()
+        maven {
+            url 'https://maven.v.io'
+        }
+    }
+    dependencies {
+        // This introduces the Android plugin to make building Android
+        // applications easier.
+        classpath 'com.android.tools.build:gradle:1.3.0'
+        // We are going to define a custom VDL service. The Vanadium
+        // Gradle plugin makes that easier, so let's use that.
+        classpath 'io.v:gradle-plugin:0.1-SNAPSHOT'
+        // Use the Android SDK manager, which will automatically download
+        // the required Android SDK.
+        classpath 'com.jakewharton.sdkmanager:gradle-plugin:0.12.0'
+    }
+}
+
+// Make our lives easier by automatically downloading the appropriate Android
+// SDK.
+apply plugin: 'android-sdk-manager'
+// It's an Android application.
+apply plugin: 'com.android.application'
+// It's going to use VDL.
+apply plugin: 'io.v.vdl'
+
+repositories {
+    mavenCentral()
+    maven {
+        url 'https://maven.v.io/'
+    }
+}
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+    packagingOptions {
+        exclude 'META-INF/LICENSE.txt'
+        exclude 'META-INF/NOTICE.txt'
+    }
+
+    defaultConfig {
+        applicationId "io.v.discovery_sample"
+        minSdkVersion 22
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile project(':lib')
+    compile project(':android-lib')
+}
+
+vdl {
+    // This is where the VDL tool will look for VDL definitions.
+    inputPaths += 'src/main/java'
+}
diff --git a/projects/discovery_sample/app/proguard-rules.pro b/projects/discovery_sample/app/proguard-rules.pro
new file mode 100644
index 0000000..75fe971
--- /dev/null
+++ b/projects/discovery_sample/app/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/google/home/bjornick/Android/Sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
diff --git a/projects/discovery_sample/app/src/androidTest/java/io/v/discoverysample/ApplicationTest.java b/projects/discovery_sample/app/src/androidTest/java/io/v/discoverysample/ApplicationTest.java
new file mode 100644
index 0000000..05649f9
--- /dev/null
+++ b/projects/discovery_sample/app/src/androidTest/java/io/v/discoverysample/ApplicationTest.java
@@ -0,0 +1,17 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.discoverysample;
+
+import android.app.Application;
+import android.test.ApplicationTestCase;
+
+/**
+ * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
+ */
+public class ApplicationTest extends ApplicationTestCase<Application> {
+    public ApplicationTest() {
+        super(Application.class);
+    }
+}
\ No newline at end of file
diff --git a/projects/discovery_sample/app/src/main/AndroidManifest.xml b/projects/discovery_sample/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..523e8c4
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/AndroidManifest.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.v.discoverysample" >
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
+    <uses-permission android:name="android.permission.BLUETOOTH"/>
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme" >
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/projects/discovery_sample/app/src/main/java/io/v/discoverysample/AttrAdapter.java b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/AttrAdapter.java
new file mode 100644
index 0000000..13219ab
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/AttrAdapter.java
@@ -0,0 +1,79 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.discoverysample;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ListAdapter;
+import android.widget.TextView;
+
+import org.w3c.dom.Text;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import io.v.v23.discovery.Attributes;
+
+public class AttrAdapter extends BaseAdapter implements ListAdapter {
+    private class Entry implements Comparable<Entry> {
+        String key;
+        String value;
+
+        Entry(Map.Entry<String, String> entry) {
+            key = entry.getKey();
+            value = entry.getValue();
+        }
+
+        @Override
+        public int compareTo(Entry entry) {
+            return key.compareTo(entry.key);
+        }
+    }
+
+    List<Entry> entries;
+    Context ctx;;
+    LayoutInflater inflater;
+    public AttrAdapter(LayoutInflater inflater, Attributes attrs) {
+        this.inflater = inflater;
+        entries = new ArrayList<>(attrs.size());
+        for (Map.Entry<String, String> entry : attrs.entrySet()) {
+            entries.add(new Entry(entry));
+        }
+        Collections.sort(entries);
+    }
+
+    @Override
+    public int getCount() {
+        return entries.size();
+    }
+
+    @Override
+    public Object getItem(int i) {
+        return entries.get(i);
+    }
+
+    @Override
+    public long getItemId(int i) {
+        return i;
+    }
+
+    @Override
+    public View getView(int i, View view, ViewGroup viewGroup) {
+        if (view == null) {
+            view = inflater.inflate(R.layout.attribute, null);
+        }
+        Entry e = entries.get(i);
+        TextView key = (TextView) view.findViewById(R.id.key);
+        key.setText(e.key);
+        TextView value = (TextView) view.findViewById(R.id.value);
+        value.setText(e.value);
+        return view;
+    }
+}
diff --git a/projects/discovery_sample/app/src/main/java/io/v/discoverysample/MainActivity.java b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/MainActivity.java
new file mode 100644
index 0000000..affb56a
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/MainActivity.java
@@ -0,0 +1,203 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.discoverysample;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ListView;
+import android.widget.Toast;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import io.v.android.libs.discovery.ble.BlePlugin;
+import io.v.android.libs.security.BlessingsManager;
+import io.v.android.v23.V;
+import io.v.android.v23.services.blessing.BlessingCreationException;
+import io.v.android.v23.services.blessing.BlessingService;
+import io.v.impl.google.lib.discovery.UUIDUtil;
+import io.v.v23.context.CancelableVContext;
+import io.v.v23.context.VContext;
+import io.v.v23.discovery.Attributes;
+import io.v.v23.discovery.Service;
+import io.v.v23.security.Blessings;
+import io.v.v23.verror.VException;
+import io.v.v23.vom.VomUtil;
+import io.v.x.ref.lib.discovery.Advertisement;
+import io.v.x.ref.lib.discovery.EncryptionAlgorithm;
+
+
+public class MainActivity extends Activity {
+
+    private static final int BLESSINGS_REQUEST = 1;
+    private Button chooseBlessingsButton;
+    private Button scanButton;
+    private Button advertiseButton;
+    private Blessings blessings;
+    private BlePlugin plugin;
+
+    private VContext rootCtx;
+    private CancelableVContext scanCtx;
+    private CancelableVContext advCtx;
+
+    private boolean isScanning;
+    private boolean isAdvertising;
+
+    private ScanHandlerAdapter adapter;
+
+    private Advertisement advertisement;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        rootCtx = V.init(this);
+        isScanning = false;
+        isAdvertising = false;
+
+        setContentView(R.layout.activity_main);
+        chooseBlessingsButton = (Button)findViewById(R.id.blessingsButton);
+        chooseBlessingsButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                fetchBlessings(false);
+            }
+        });
+
+        scanButton = (Button)findViewById(R.id.scanForService);
+        scanButton.setEnabled(false);
+        scanButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                flipScan();
+            }
+        });
+
+        advertiseButton = (Button) findViewById(R.id.advertiseButton);
+        advertiseButton.setEnabled(false);
+        advertiseButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                flipAdvertise();
+            }
+        });
+
+        byte[] instanceId = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15};
+        Attributes attrs = new Attributes();
+        attrs.put("foo", "bar");
+        List<String> addrs = new ArrayList<>();
+        addrs.add("localhost:2000");
+        String interfaceName = "v.io/x/ref.Interface";
+        advertisement = new Advertisement(
+                new Service(instanceId, "Android instance",
+                        interfaceName, attrs, addrs),
+                UUIDUtil.UUIDToUuid(UUIDUtil.UUIDForInterfaceName(interfaceName)),
+                new EncryptionAlgorithm(0),
+                null,
+                false);
+        adapter = new ScanHandlerAdapter(this);
+        ListView devices = (ListView) findViewById(R.id.list_view);
+        devices.setAdapter(adapter);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        // Inflate the menu; this adds items to the action bar if it is present.
+        getMenuInflater().inflate(R.menu.menu_main, menu);
+        return true;
+    }
+
+    private void flipAdvertise() {
+        if (plugin == null) {
+            plugin = new BlePlugin(this);
+        }
+
+        if (!isAdvertising) {
+            isAdvertising = true;
+
+            advCtx = rootCtx.withCancel();
+            try {
+                plugin.addAdvertisement(advCtx, advertisement);
+                advertiseButton.setText("Stop Advertisement");
+            } catch (IOException e) {
+                advCtx.cancel();
+                isAdvertising = false;
+            }
+        } else {
+            isAdvertising = false;
+            advCtx.cancel();
+            advertiseButton.setText("Advertise");
+        }
+    }
+    private void flipScan() {
+        if (plugin == null) {
+            plugin = new BlePlugin(this);
+        }
+        if (!isScanning) {
+            scanCtx = rootCtx.withCancel();
+            plugin.addScanner(scanCtx,
+                    UUIDUtil.UUIDForInterfaceName("v.io/x/ref.Interface"),
+                    adapter);
+            isScanning = true;
+            scanButton.setText("Stop scanning");
+        } else {
+            isScanning = false;
+            scanCtx.cancel();
+            scanButton.setText("Start Scan");
+        }
+    }
+
+    private void fetchBlessings(boolean startScan) {
+        Intent intent = BlessingService.newBlessingIntent(this);
+        startActivityForResult(intent, BLESSINGS_REQUEST);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        switch (requestCode) {
+            case BLESSINGS_REQUEST:
+                try {
+                    // The Account Manager will pass us the blessings to use as
+                    // an array of bytes. Use VomUtil to decode them...
+                    byte[] blessingsVom =
+                        BlessingService.extractBlessingReply(resultCode, data);
+                    blessings = (Blessings) VomUtil.decode(blessingsVom, Blessings.class);
+                    BlessingsManager.addBlessings(this, blessings);
+                    Toast.makeText(this, "Success, ready to listen!",
+                            Toast.LENGTH_SHORT).show();
+
+                    // Enable the "start service" button.
+                    scanButton.setEnabled(true);
+                    advertiseButton.setEnabled(true);
+                } catch (BlessingCreationException e) {
+                    String msg = "Couldn't create blessing: " + e.getMessage();
+                    Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
+                } catch (VException e) {
+                    String msg = "Couldn't store blessing: " + e.getMessage();
+                    Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
+                }
+                return;
+        }
+    }
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle action bar item clicks here. The action bar will
+        // automatically handle clicks on the Home/Up button, so long
+        // as you specify a parent activity in AndroidManifest.xml.
+        int id = item.getItemId();
+
+        //noinspection SimplifiableIfStatement
+        if (id == R.id.action_settings) {
+            return true;
+        }
+
+        return super.onOptionsItemSelected(item);
+    }
+}
diff --git a/projects/discovery_sample/app/src/main/java/io/v/discoverysample/ScanHandlerAdapter.java b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/ScanHandlerAdapter.java
new file mode 100644
index 0000000..3f1999f
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/java/io/v/discoverysample/ScanHandlerAdapter.java
@@ -0,0 +1,114 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.discoverysample;
+
+import android.app.Activity;
+import android.content.Context;
+import android.database.DataSetObserver;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Adapter;
+import android.widget.BaseAdapter;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.google.common.base.Joiner;
+
+import org.w3c.dom.Text;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.v.impl.google.lib.discovery.ScanHandler;
+import io.v.x.ref.lib.discovery.Advertisement;
+
+public class ScanHandlerAdapter extends BaseAdapter implements ScanHandler{
+
+    List<Advertisement> knownAdvertisements;
+
+    List<DataSetObserver> observers;
+
+    LayoutInflater inflater;
+
+    Activity activity;
+
+    ScanHandlerAdapter(Activity activity) {
+        knownAdvertisements = new ArrayList<>();
+        observers = new ArrayList<>();
+        this.activity = activity;
+        inflater = (LayoutInflater) activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    @Override
+    public int getCount() {
+        return knownAdvertisements.size();
+    }
+
+    @Override
+    public Object getItem(int i) {
+        if (i < knownAdvertisements.size()) {
+            return knownAdvertisements.get(i);
+        }
+        return null;
+    }
+
+    @Override
+    public long getItemId(int i) {
+        if (i < knownAdvertisements.size()) {
+            return knownAdvertisements.get(i).hashCode();
+        }
+        return 0;
+    }
+
+    @Override
+    public View getView(int i, View view, ViewGroup viewGroup) {
+        if (view == null) {
+            view = inflater.inflate(R.layout.item, null);
+        }
+        Advertisement adv = knownAdvertisements.get(i);
+        TextView displayName = (TextView)view.findViewById(R.id.display_name);
+        displayName.setText(adv.getService().getInstanceName());
+        TextView interfaceName = (TextView)view.findViewById(R.id.interface_name);
+        interfaceName.setText(adv.getService().getInterfaceName());
+        TextView addrs = (TextView)view.findViewById(R.id.addrs);
+        addrs.setText(Joiner.on(",").join(adv.getService().getAddrs()));
+        ListView attrs = (ListView)view.findViewById(R.id.attributes);
+        attrs.setAdapter(new AttrAdapter(inflater, adv.getService().getAttrs()));
+        return view;
+    }
+
+    @Override
+    public int getItemViewType(int i) {
+        return 0;
+    }
+
+    @Override
+    public int getViewTypeCount() {
+        return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return knownAdvertisements.isEmpty();
+    }
+
+    @Override
+    public void handleUpdate(Advertisement advertisement) {
+        if (!advertisement.getLost()) {
+            knownAdvertisements.add(advertisement);
+        } else {
+            advertisement.setLost(false);
+            knownAdvertisements.remove(advertisement);
+        }
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                notifyDataSetChanged();
+            }
+        });
+    }
+}
diff --git a/projects/discovery_sample/app/src/main/res/layout/activity_main.xml b/projects/discovery_sample/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..67646aa
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,33 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
+    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
+
+    <Button
+        android:id="@+id/blessingsButton"
+        android:text="Get Blessings"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true"/>
+    <Button
+        android:id="@+id/scanForService"
+        android:text="Start Scan"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true"
+        android:layout_toRightOf="@id/blessingsButton"/>
+    <Button
+        android:id="@+id/advertiseButton"
+        android:text="Advertise"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true"
+        android:layout_toRightOf="@id/scanForService"/>
+    <ListView
+        android:id="@+id/list_view"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_below="@id/blessingsButton"/>
+</RelativeLayout>
diff --git a/projects/discovery_sample/app/src/main/res/layout/attribute.xml b/projects/discovery_sample/app/src/main/res/layout/attribute.xml
new file mode 100644
index 0000000..933b071
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/layout/attribute.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="horizontal" android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <TextView
+        android:id="@+id/key"
+        android:layout_width="wrap_content"
+        android:layout_height="fill_parent" />
+    <TextView
+        android:id="@+id/value"
+        android:layout_width="wrap_content"
+        android:layout_height="fill_parent" />
+</LinearLayout>
\ No newline at end of file
diff --git a/projects/discovery_sample/app/src/main/res/layout/item.xml b/projects/discovery_sample/app/src/main/res/layout/item.xml
new file mode 100644
index 0000000..434fdae
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/layout/item.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical" android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <TextView
+        android:id="@+id/display_name"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content" />
+    <TextView
+        android:id="@+id/interface_name"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content" />
+    <TextView
+        android:id="@+id/addrs"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content" />
+    <ListView
+        android:id="@+id/attributes"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"/>
+</LinearLayout>
\ No newline at end of file
diff --git a/projects/discovery_sample/app/src/main/res/menu/menu_main.xml b/projects/discovery_sample/app/src/main/res/menu/menu_main.xml
new file mode 100644
index 0000000..87a750e
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/menu/menu_main.xml
@@ -0,0 +1,5 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" tools:context=".MainActivity">
+    <item android:id="@+id/action_settings" android:title="@string/action_settings"
+        android:orderInCategory="100" android:showAsAction="never" />
+</menu>
diff --git a/projects/discovery_sample/app/src/main/res/mipmap-hdpi/ic_launcher.png b/projects/discovery_sample/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000..cde69bc
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/mipmap-hdpi/ic_launcher.png
Binary files differ
diff --git a/projects/discovery_sample/app/src/main/res/mipmap-mdpi/ic_launcher.png b/projects/discovery_sample/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000..c133a0c
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/mipmap-mdpi/ic_launcher.png
Binary files differ
diff --git a/projects/discovery_sample/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/projects/discovery_sample/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..bfa42f0
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/mipmap-xhdpi/ic_launcher.png
Binary files differ
diff --git a/projects/discovery_sample/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/projects/discovery_sample/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..324e72c
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
Binary files differ
diff --git a/projects/discovery_sample/app/src/main/res/values-v21/styles.xml b/projects/discovery_sample/app/src/main/res/values-v21/styles.xml
new file mode 100644
index 0000000..dba3c41
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/values-v21/styles.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="AppTheme" parent="android:Theme.Material.Light">
+    </style>
+</resources>
diff --git a/projects/discovery_sample/app/src/main/res/values-w820dp/dimens.xml b/projects/discovery_sample/app/src/main/res/values-w820dp/dimens.xml
new file mode 100644
index 0000000..63fc816
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/values-w820dp/dimens.xml
@@ -0,0 +1,6 @@
+<resources>
+    <!-- Example customization of dimensions originally defined in res/values/dimens.xml
+         (such as screen margins) for screens with more than 820dp of available width. This
+         would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively). -->
+    <dimen name="activity_horizontal_margin">64dp</dimen>
+</resources>
diff --git a/projects/discovery_sample/app/src/main/res/values/dimens.xml b/projects/discovery_sample/app/src/main/res/values/dimens.xml
new file mode 100644
index 0000000..47c8224
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/values/dimens.xml
@@ -0,0 +1,5 @@
+<resources>
+    <!-- Default screen margins, per the Android Design guidelines. -->
+    <dimen name="activity_horizontal_margin">16dp</dimen>
+    <dimen name="activity_vertical_margin">16dp</dimen>
+</resources>
diff --git a/projects/discovery_sample/app/src/main/res/values/strings.xml b/projects/discovery_sample/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..78a6bfc
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/values/strings.xml
@@ -0,0 +1,6 @@
+<resources>
+    <string name="app_name">DiscoverySample</string>
+
+    <string name="hello_world">Hello world!</string>
+    <string name="action_settings">Settings</string>
+</resources>
diff --git a/projects/discovery_sample/app/src/main/res/values/styles.xml b/projects/discovery_sample/app/src/main/res/values/styles.xml
new file mode 100644
index 0000000..ff6c9d2
--- /dev/null
+++ b/projects/discovery_sample/app/src/main/res/values/styles.xml
@@ -0,0 +1,8 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+    </style>
+
+</resources>
diff --git a/projects/discovery_sample/build.gradle b/projects/discovery_sample/build.gradle
new file mode 100644
index 0000000..1b7886d
--- /dev/null
+++ b/projects/discovery_sample/build.gradle
@@ -0,0 +1,19 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.0'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
diff --git a/projects/discovery_sample/gradle.properties b/projects/discovery_sample/gradle.properties
new file mode 100644
index 0000000..1d3591c
--- /dev/null
+++ b/projects/discovery_sample/gradle.properties
@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
\ No newline at end of file
diff --git a/projects/discovery_sample/gradle/wrapper/gradle-wrapper.jar b/projects/discovery_sample/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..8c0fb64
--- /dev/null
+++ b/projects/discovery_sample/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/projects/discovery_sample/gradle/wrapper/gradle-wrapper.properties b/projects/discovery_sample/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..0c71e76
--- /dev/null
+++ b/projects/discovery_sample/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Wed Apr 10 15:27:10 PDT 2013
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip
diff --git a/projects/discovery_sample/gradlew b/projects/discovery_sample/gradlew
new file mode 100755
index 0000000..91a7e26
--- /dev/null
+++ b/projects/discovery_sample/gradlew
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/projects/discovery_sample/settings.gradle b/projects/discovery_sample/settings.gradle
new file mode 100644
index 0000000..e7b4def
--- /dev/null
+++ b/projects/discovery_sample/settings.gradle
@@ -0,0 +1 @@
+include ':app'
diff --git a/settings.gradle b/settings.gradle
index d9d2af5..f626ccc 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1 +1 @@
-include 'lib', 'tests', 'android-lib', 'benchmarks:syncbench', 'projects:syncslides', 'projects:syncslides:app', 'projects:syncslidepresenter'
+include 'lib', 'tests', 'android-lib', 'benchmarks:syncbench', 'projects:syncslides', 'projects:syncslides:app', 'projects:syncslidepresenter', 'projects:discovery_sample', 'projects:discovery_sample:app'