diff --git a/impl/google/discovery/jni.go b/impl/google/discovery/jni.go
index 9deeb36..487f21c 100644
--- a/impl/google/discovery/jni.go
+++ b/impl/google/discovery/jni.go
@@ -11,8 +11,12 @@
 	"encoding/binary"
 	"unsafe"
 
+	"v.io/v23/discovery"
+	"v.io/v23/security"
+	idiscovery "v.io/x/ref/lib/discovery"
+
 	jutil "v.io/x/jni/util"
-	"v.io/x/ref/lib/discovery"
+	jcontext "v.io/x/jni/v23/context"
 )
 
 // #include "jni.h"
@@ -20,9 +24,26 @@
 import "C"
 
 var (
-	classSign = jutil.ClassSign("java.lang.Class")
+	updateSign = jutil.ClassSign("io.v.v23.discovery.Update")
+
+
 	// Global reference for java.util.UUID class.
 	jUUIDClass jutil.Class
+
+	// Global reference io.v.impl.google.lib.discovery.ScanHandler
+	jScanHandlerClass jutil.Class
+
+	// Global reference io.v.v23.discovery.Service
+	jServiceClass jutil.Class
+
+	// Global reference io.v.v23.security.BlessingPattern
+	jBlessingPatternClass jutil.Class
+
+	// Global reference io.v.v23.discovery.Update
+	jUpdateClass jutil.Class
+
+	// Global reference io.v.impl.google.lib.discovery.VDiscoveryImpl
+	jVDiscoveryImplClass jutil.Class
 )
 
 // Init initializes the JNI code with the given Java environment. This method
@@ -33,11 +54,35 @@
 	// thread, so we aren't able to invoke FindClass in other threads.
 	var err error
 	jUUIDClass, err = jutil.JFindClass(env, "java/util/UUID")
+	if err != nil {
+		return err
+	}
+	jScanHandlerClass, err = jutil.JFindClass(env, "io/v/impl/google/lib/discovery/ScanHandler")
+	if err != nil {
+		return err
+	}
+	jServiceClass, err = jutil.JFindClass(env, "io/v/v23/discovery/Service")
+	if err != nil {
+		return err
+	}
+	jBlessingPatternClass, err = jutil.JFindClass(env, "io/v/v23/security/BlessingPattern")
+	if err != nil {
+		return err
+	}
+	jUpdateClass, err = jutil.JFindClass(env, "io/v/v23/discovery/Update")
+	if err != nil {
+		return err
+	}
 
-	return err
+	jVDiscoveryImplClass, err = jutil.JFindClass(env, "io/v/impl/google/lib/discovery/VDiscoveryImpl")
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func convertStringtoUUID(jenv *C.JNIEnv, _ C.jclass, jName C.jstring, generator func(string) discovery.Uuid) C.jobject {
+func convertStringtoUUID(jenv *C.JNIEnv, _ C.jclass, jName C.jstring, generator func(string) idiscovery.Uuid) C.jobject {
 	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
 	name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
 	uuid := generator(name)
@@ -55,13 +100,128 @@
 
 //export Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForInterfaceName
 func Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForInterfaceName(jenv *C.JNIEnv, jclass C.jclass, jName C.jstring) C.jobject {
-	return convertStringtoUUID(jenv, jclass, jName, discovery.NewServiceUUID)
+	return convertStringtoUUID(jenv, jclass, jName, idiscovery.NewServiceUUID)
 }
 
 //export Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForAttributeKey
 func Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForAttributeKey(jenv *C.JNIEnv, jclass C.jclass, jName C.jstring) C.jobject {
-	converter := func(s string) discovery.Uuid {
-		return discovery.NewAttributeUUID(s)
+	converter := func(s string) idiscovery.Uuid {
+		return idiscovery.NewAttributeUUID(s)
 	}
 	return convertStringtoUUID(jenv, jclass, jName, converter)
 }
+
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_nativeFinalize
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_nativeFinalize(jenv *C.JNIEnv, _ C.jobject, discovery C.jlong, trigger C.jlong) {
+	jutil.GoUnref(jutil.NativePtr(discovery))
+	jutil.GoUnref(jutil.NativePtr(trigger))
+}
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_advertise
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_advertise(jenv *C.JNIEnv, jDiscoveryObj C.jobject, jContext C.jobject, jServiceObject C.jobject, jPerms C.jobject, jCallback C.jobject) {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		return
+	}
+	jService := jutil.Object(uintptr(unsafe.Pointer(jServiceObject)))
+	var service discovery.Service
+	if err := jutil.GoVomCopy(env, jService, jServiceClass, &service); err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	permsArray, err := jutil.GoObjectList(env, jutil.Object(uintptr(unsafe.Pointer(jPerms))))
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	permsSlice := make([]security.BlessingPattern, len(permsArray))
+	for i, jPattern := range permsArray {
+		if err := jutil.GoVomCopy(env, jPattern, jBlessingPatternClass, &permsSlice[i]); err != nil {
+			jutil.JThrowV(env, err)
+			return
+		}
+	}
+	jDiscovery := jutil.Object(uintptr(unsafe.Pointer(jDiscoveryObj)))
+	discoveryPtr, err := jutil.JLongField(env, jDiscovery, "nativeDiscovery")
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	ds := *(*discovery.T)(jutil.NativePtr(discoveryPtr))
+
+	triggerPtr, err := jutil.JLongField(env, jDiscovery, "nativeTrigger")
+
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	trigger := (*idiscovery.Trigger)(jutil.NativePtr(triggerPtr))
+
+	done, err := ds.Advertise(ctx, service, permsSlice)
+
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	cb := jutil.Object(uintptr(unsafe.Pointer(jCallback)))
+	cb = jutil.NewGlobalRef(env, cb)
+	trigger.Add(func() {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		// TODO(bjornick): What should we do on errors?
+		if err := jutil.CallVoidMethod(env, cb, "done", nil); err != nil {
+			ctx.Errorf("failed to call done:", err)
+		}
+		jutil.DeleteGlobalRef(env, cb)
+	}, done)
+}
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_scan
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_scan(jenv *C.JNIEnv, jDiscoveryObj C.jobject, jContext C.jobject, jQuery C.jstring, jCallback C.jobject) {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		return
+	}
+	query := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jQuery))))
+
+	jDiscovery := jutil.Object(uintptr(unsafe.Pointer(jDiscoveryObj)))
+	discoveryPtr, err := jutil.JLongField(env, jDiscovery, "nativeDiscovery")
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	ds := *(*discovery.T)(jutil.NativePtr(discoveryPtr))
+
+	updates, err := ds.Scan(ctx, query)
+
+	jutil.NewGlobalRef(env, jutil.Object(uintptr(unsafe.Pointer(jCallback))))
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	cb := jutil.Object(uintptr(unsafe.Pointer(jCallback)))
+	cb = jutil.NewGlobalRef(env, cb)
+	go func() {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		for v := range updates {
+			jUpdate, err := jutil.JVomCopy(env, v, jUpdateClass)
+			if err != nil {
+				ctx.Errorf("Failed to convert update: %v", err)
+				continue
+			}
+			err = jutil.CallVoidMethod(env, cb, "handleUpdate", []jutil.Sign{updateSign}, jUpdate)
+			if err != nil {
+				ctx.Errorf("Failed to call handler: %v", err)
+				continue
+			}
+		}
+		jutil.DeleteGlobalRef(env, cb)
+	}()
+}
diff --git a/impl/google/discovery/util.go b/impl/google/discovery/util.go
new file mode 100644
index 0000000..d788469
--- /dev/null
+++ b/impl/google/discovery/util.go
@@ -0,0 +1,29 @@
+// 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.
+
+// +build java android
+
+package discovery
+
+import (
+	jutil "v.io/x/jni/util"
+
+	"v.io/v23/discovery"
+	idiscovery "v.io/x/ref/lib/discovery"
+)
+// #include "jni.h"
+import "C"
+
+// JavaDiscovery converts a Go discovery instance into a Java discovery instance.
+func JavaDiscovery(env jutil.Env, d discovery.T) (jutil.Object, error) {
+	trigger := idiscovery.NewTrigger()
+	// This reference will get unrefed when the jDiscovery object below is finalized.
+	jutil.GoRef(trigger)
+
+	jDiscovery, err := jutil.NewObject(env, jVDiscoveryImplClass, []jutil.Sign{jutil.LongSign, jutil.LongSign}, int64(jutil.PtrValue(&d)), int64(jutil.PtrValue(trigger)))
+	if err != nil {
+		return jutil.NullObject, err
+	}
+	return jDiscovery, nil
+}
diff --git a/impl/google/rt/jni.go b/impl/google/rt/jni.go
index c5239ba..f9d7415 100644
--- a/impl/google/rt/jni.go
+++ b/impl/google/rt/jni.go
@@ -11,12 +11,12 @@
 
 	"v.io/v23"
 	"v.io/v23/context"
-	_ "v.io/x/ref/runtime/factories/roaming"
 
 	jns "v.io/x/jni/impl/google/namespace"
 	jrpc "v.io/x/jni/impl/google/rpc"
 	jutil "v.io/x/jni/util"
 	jcontext "v.io/x/jni/v23/context"
+	jdiscovery "v.io/x/jni/impl/google/discovery"
 	jsecurity "v.io/x/jni/v23/security"
 )
 
@@ -27,6 +27,7 @@
 	contextSign = jutil.ClassSign("io.v.v23.context.VContext")
 	serverSign  = jutil.ClassSign("io.v.v23.rpc.Server")
 
+	// Global reference io.v.impl.google.rt.VRuntimeImpl
 	jVRuntimeImplClass jutil.Class
 )
 
@@ -39,6 +40,7 @@
 	if err != nil {
 		return err
 	}
+
 	return nil
 }
 
@@ -272,3 +274,20 @@
 	}
 	return C.jobject(unsafe.Pointer(jSpec))
 }
+
+//export Java_io_v_impl_google_rt_VRuntimeImpl_nativeGetDiscovery
+func Java_io_v_impl_google_rt_VRuntimeImpl_nativeGetDiscovery(jenv *C.JNIEnv, jRuntime C.jclass, jContext C.jobject) C.jobject {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		jutil.JThrowV(env, err);
+		return nil
+	}
+
+	jDiscovery, err := jdiscovery.JavaDiscovery(env, v23.GetDiscovery(ctx))
+	if err != nil {
+		jutil.JThrowV(env, err);
+		return nil
+	}
+	return C.jobject(unsafe.Pointer(jDiscovery))
+}
diff --git a/jni_android.go b/jni_android.go
index fe97370..88bd374 100644
--- a/jni_android.go
+++ b/jni_android.go
@@ -11,20 +11,30 @@
 
 	"v.io/v23/context"
 	"v.io/x/lib/vlog"
+	_ "v.io/x/ref/runtime/factories/android"
+	"v.io/x/ref/lib/discovery/factory"
 
 	jutil "v.io/x/jni/util"
 	jcontext "v.io/x/jni/v23/context"
+	jdiscovery "v.io/x/jni/libs/discovery"
 )
 
 // #include "jni.h"
 import "C"
 
-//export Java_io_v_android_v23_V_nativeInitLogging
-func Java_io_v_android_v23_V_nativeInitLogging(jenv *C.JNIEnv, jVClass C.jclass, jContext C.jobject, jOptions C.jobject) C.jobject {
+//export Java_io_v_android_v23_V_nativeInit
+func Java_io_v_android_v23_V_nativeInit(jenv *C.JNIEnv, jVClass C.jclass, jContext C.jobject, jAndroidContext C.jobject, jOptions C.jobject) C.jobject {
 	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
 	jCtx := jutil.Object(uintptr(unsafe.Pointer(jContext)))
 	jOpts := jutil.Object(uintptr(unsafe.Pointer(jOptions)))
 
+	if err := jdiscovery.Init(env); err != nil {
+		jutil.JThrowV(env, err)
+		return nil
+	}
+
+	factory.SetBleFactory(jdiscovery.NewBleCreator(env, jutil.Object(uintptr(unsafe.Pointer(jAndroidContext)))))
+
 	_, _, level, vmodule, err := loggingOpts(env, jOpts)
 	if err != nil {
 		jutil.JThrowV(env, err)
diff --git a/jni_java.go b/jni_java.go
new file mode 100644
index 0000000..614c455
--- /dev/null
+++ b/jni_java.go
@@ -0,0 +1,11 @@
+// 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.
+
+// +build java
+
+package jni
+
+import (
+	_ "v.io/x/ref/runtime/factories/roaming"
+)
\ No newline at end of file
diff --git a/libs/discovery/jni.go b/libs/discovery/jni.go
new file mode 100644
index 0000000..e6bf2a3
--- /dev/null
+++ b/libs/discovery/jni.go
@@ -0,0 +1,73 @@
+// 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.
+
+// +build android
+
+package discovery
+
+import (
+	"unsafe"
+
+	jutil "v.io/x/jni/util"
+	"v.io/x/ref/lib/discovery"
+)
+// #include "jni.h"
+import "C"
+var (
+	androidContextSign = jutil.ClassSign("android.content.Context")
+	contextSign = jutil.ClassSign("io.v.v23.context.VContext")
+	advertisementSign = jutil.ClassSign("io.v.x.ref.lib.discovery.Advertisement")
+	uuidSign = jutil.ClassSign("java.util.UUID")
+	scanHandlerSign = jutil.ClassSign("io.v.impl.google.lib.discovery.ScanHandler")
+
+	// Global reference for io.v.android.libs.discovery.ble.BlePlugin
+	jBlePluginClass jutil.Class
+	// Global reference for io.v.x.ref.lib.discovery.Advertisement
+	jAdvertisementClass jutil.Class
+	// Global reference for java.util.UUID
+	jUUIDClass jutil.Class
+	// Global reference for io.v.android.libs.discovery.ble.NativeScanHandler
+	jNativeScanHandlerClass jutil.Class
+)
+
+func Init(env jutil.Env) error {
+	var err error
+
+	jUUIDClass, err = jutil.JFindClass(env, "java/util/UUID")
+	if err != nil {
+		return err
+	}
+
+	jNativeScanHandlerClass, err = jutil.JFindClass(env, "io/v/android/libs/discovery/ble/NativeScanHandler")
+	if err != nil {
+		return err
+	}
+
+	jBlePluginClass, err = jutil.JFindClass(env, "io/v/android/libs/discovery/ble/BlePlugin")
+	if err != nil {
+		return err
+	}
+
+	jAdvertisementClass, err = jutil.JFindClass(env, "io/v/x/ref/lib/discovery/Advertisement")
+	return err
+}
+
+//export Java_io_v_android_libs_discovery_ble_NativeScanHandler_nativeHandleUpdate
+func Java_io_v_android_libs_discovery_ble_NativeScanHandler_nativeHandleUpdate(jenv *C.JNIEnv, _ C.jobject, jAdvObj C.jobject, goPtr C.jlong)  {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ch := (*(*chan <-discovery.Advertisement)(jutil.NativePtr(goPtr)))
+
+	jAdv := jutil.Object(uintptr(unsafe.Pointer(jAdvObj)))
+	var adv discovery.Advertisement
+	if err := jutil.GoVomCopy(env, jAdv, jAdvertisementClass, &adv); err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	ch <-adv
+}
+
+//export Java_io_v_android_libs_discovery_ble_NativeScanHandler_nativeFinalize
+func Java_io_v_android_libs_discovery_ble_NativeScanHandler_nativeFinalize(jenv *C.JNIEnv, _ C.jobject, goPtr C.jlong) {
+	jutil.GoUnref(jutil.NativePtr(goPtr))
+}
diff --git a/libs/discovery/plugin.go b/libs/discovery/plugin.go
new file mode 100644
index 0000000..8632349
--- /dev/null
+++ b/libs/discovery/plugin.go
@@ -0,0 +1,119 @@
+// 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.
+
+// +build android
+
+package discovery
+import (
+	"bytes"
+	"encoding/binary"
+	"runtime"
+
+	"v.io/v23/context"
+
+	"v.io/x/ref/lib/discovery"
+
+	jcontext "v.io/x/jni/v23/context"
+	jutil "v.io/x/jni/util"
+)
+
+// #include "jni.h"
+import "C"
+
+func NewBleCreator(env jutil.Env, context jutil.Object) func(string) (discovery.Plugin, error) {
+	// Reference Android Context; it will be de-referenced when the plugin
+	// created below is garbage-collected (through the finalizer callback we
+	// setup in the function below).  This function should only be executed once.
+	jContext := jutil.NewGlobalRef(env, context)
+	return func(host string) (discovery.Plugin, error) {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		jPlugin, err := jutil.NewObject(env, jBlePluginClass, []jutil.Sign{androidContextSign}, jContext)
+
+		jutil.DeleteGlobalRef(env, jContext)
+		if err != nil {
+			return nil, err
+		}
+		// Reference Android BlePlugin; it will be de-referenced when the plugin
+		// created below is garbage-collected (through the finalizer callback we
+		// setup below).
+		jPlugin = jutil.NewGlobalRef(env, jPlugin)
+		p := &plugin{
+			trigger: discovery.NewTrigger(),
+			jPlugin: jPlugin,
+		}
+		runtime.SetFinalizer(p, func(p *plugin) {
+			env, freeFunc := jutil.GetEnv()
+			defer freeFunc()
+			jutil.DeleteGlobalRef(env, p.jPlugin)
+		})
+		return p, nil
+	}
+
+}
+
+type plugin struct {
+	trigger *discovery.Trigger
+	jPlugin jutil.Object
+}
+
+func (p *plugin) Advertise(ctx *context.T, ad discovery.Advertisement, done func()) error {
+	env, freeFunc := jutil.GetEnv()
+	defer freeFunc()
+	jContext, err := jcontext.JavaContext(env, ctx)
+	if err != nil {
+		return err
+	}
+	jAdv, err := jutil.JVomCopy(env, ad, jAdvertisementClass)
+	if err != nil {
+		return err
+	}
+
+	err = jutil.CallVoidMethod(env, p.jPlugin, "addAdvertisement", []jutil.Sign{contextSign, advertisementSign}, jContext, jAdv)
+
+	p.trigger.Add(done, ctx.Done())
+
+	return err
+}
+
+func (p *plugin) Scan(ctx *context.T, serviceUuid discovery.Uuid, ch chan<- discovery.Advertisement, done func()) error {
+	env, freeFunc := jutil.GetEnv()
+	defer freeFunc()
+	jContext, err := jcontext.JavaContext(env, ctx)
+	if err != nil {
+		return err
+	}
+
+	jUuid, err := JavaUUID(env, serviceUuid)
+
+	if err != nil {
+		return err
+	}
+
+
+	jutil.GoRef(&ch)
+	jNativeScanHandler, err := jutil.NewObject(env, jNativeScanHandlerClass, []jutil.Sign{jutil.LongSign}, int64(jutil.PtrValue(&ch)))
+	if err != nil {
+		return err
+	}
+
+	err = jutil.CallVoidMethod(env, p.jPlugin, "addScanner", []jutil.Sign{contextSign, uuidSign, scanHandlerSign},
+		jContext, jUuid, jNativeScanHandler)
+
+	if err != nil {
+		return err
+	}
+	p.trigger.Add(done, ctx.Done())
+	return nil
+}
+
+
+// JavaUUID converts a Go UUID type to a Java UUID object.
+func JavaUUID(env jutil.Env, uuid discovery.Uuid) (jutil.Object, error) {
+	buf := bytes.NewBuffer(uuid)
+	var high, low int64
+	binary.Read(buf, binary.BigEndian, &high)
+	binary.Read(buf, binary.BigEndian, &low)
+	return jutil.NewObject(env, jUUIDClass, []jutil.Sign{jutil.LongSign, jutil.LongSign}, high, low)
+}