// GoAuthorizer converts the given Java authorizer into a Go authorizer.
func GoAuthorizer(env jutil.Env, jAuth jutil.Object) (security.Authorizer, error) {
if jAuth.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jAuth, jPermissionsAuthorizerClass) {
// Called with our implementation of Authorizer, which maintains a Go reference - use it.
ref, err := jutil.JLongField(env, jAuth, "nativeRef")
if err != nil {
return nil, err
}
return *(*security.Authorizer)(jutil.GoRefValue(jutil.Ref(ref))), nil
}
// Reference Java dispatcher; it will be de-referenced when the go
// dispatcher created below is garbage-collected (through the finalizer
// callback we setup below).
jAuth = jutil.NewGlobalRef(env, jAuth)
a := &authorizer{
jAuth: jAuth,
}
runtime.SetFinalizer(a, func(a *authorizer) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, a.jAuth)
})
return a, nil
}
func initDriverFactory(env jutil.Env) error {
jDriverClass, err := jutil.JFindClass(env, "io/v/android/impl/google/discovery/plugins/ble/Driver")
if err != nil {
return err
}
factory := func(ctx *context.T, _ string) (ble.Driver, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jCtx, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
return nil, err
}
jDriver, err := jutil.NewObject(env, jDriverClass, []jutil.Sign{contextSign}, jCtx)
if err != nil {
return nil, err
}
// Reference the driver; it will be de-referenced when the driver is garbage-collected.
jDriver = jutil.NewGlobalRef(env, jDriver)
d := &driver{jDriver}
runtime.SetFinalizer(d, func(*driver) {
env, freeFunc := jutil.GetEnv()
jutil.DeleteGlobalRef(env, d.jDriver)
freeFunc()
})
return d, nil
}
ble.SetDriverFactory(factory)
return nil
}
// GoBlessingStore creates an instance of security.BlessingStore that uses the
// provided Java BlessingStore as its underlying implementation.
func GoBlessingStore(env jutil.Env, jBlessingStore jutil.Object) (security.BlessingStore, error) {
if jBlessingStore.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jBlessingStore, jBlessingStoreImplClass) {
// Called with our implementation of BlessingStore, which maintains a Go reference - use it.
ref, err := jutil.JLongField(env, jBlessingStore, "nativeRef")
if err != nil {
return nil, err
}
return (*(*security.BlessingStore)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java BlessingStore; it will be de-referenced when the Go
// BlessingStore created below is garbage-collected (through the finalizer
// callback we setup just below).
jBlessingStore = jutil.NewGlobalRef(env, jBlessingStore)
s := &blessingStore{
jBlessingStore: jBlessingStore,
}
runtime.SetFinalizer(s, func(s *blessingStore) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, s.jBlessingStore)
})
return s, nil
}
// GoBlessingRoots creates an instance of security.BlessingRoots that uses the
// provided Java BlessingRoots as its underlying implementation.
func GoBlessingRoots(env jutil.Env, jBlessingRoots jutil.Object) (security.BlessingRoots, error) {
if jBlessingRoots.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jBlessingRoots, jBlessingRootsImplClass) {
// Called with our implementation of BlessingRoots, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jBlessingRoots, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.BlessingRoots)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java BlessingRoots; it will be de-referenced when the Go
// BlessingRoots created below is garbage-collected (through the finalizer
// callback we setup just below).
jBlessingRoots = jutil.NewGlobalRef(env, jBlessingRoots)
r := &blessingRoots{
jBlessingRoots: jBlessingRoots,
}
runtime.SetFinalizer(r, func(r *blessingRoots) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, r.jBlessingRoots)
})
return r, nil
}
// GoCall creates instance of security.Call that uses the provided Java
// Call as its underlying implementation.
func GoCall(env jutil.Env, jCall jutil.Object) (security.Call, error) {
if jCall.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jCall, jCallImplClass) {
// Called with our implementation of Call, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jCall, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.Call)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java call; it will be de-referenced when the go call
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jCall = jutil.NewGlobalRef(env, jCall)
call := &callImpl{
jCall: jCall,
}
runtime.SetFinalizer(call, func(c *callImpl) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, c.jCall)
})
return call, nil
}
func (i *invoker) Prepare(ctx *context.T, method string, numArgs int) (argptrs []interface{}, tags []*vdl.Value, err error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return nil, nil, err
}
// Have all input arguments be decoded into *vdl.Value.
argptrs = make([]interface{}, numArgs)
for i := 0; i < numArgs; i++ {
value := new(vdl.Value)
argptrs[i] = &value
}
// This method will invoke the freeFunc().
jVomTags, err := jutil.CallStaticFutureMethod(env, freeFunc, jServerRPCHelperClass, "prepare", []jutil.Sign{invokerSign, contextSign, jutil.StringSign}, i.jInvoker, jContext, jutil.CamelCase(method))
if err != nil {
return nil, nil, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jVomTags)
vomTags, err := jutil.GoByteArrayArray(env, jVomTags)
if err != nil {
return nil, nil, err
}
tags = make([]*vdl.Value, len(vomTags))
for i, vomTag := range vomTags {
var err error
if tags[i], err = jutil.VomDecodeToValue(vomTag); err != nil {
return nil, nil, err
}
}
return
}
func (i *invoker) Signature(ctx *context.T, call rpc.ServerCall) ([]signature.Interface, error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return nil, err
}
// This method will invoke the freeFunc().
jInterfaces, err := jutil.CallFutureMethod(env, freeFunc, i.jInvoker, "getSignature", []jutil.Sign{contextSign}, jContext)
if err != nil {
return nil, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jInterfaces)
interfacesArr, err := jutil.GoObjectArray(env, jInterfaces)
if err != nil {
return nil, err
}
result := make([]signature.Interface, len(interfacesArr))
for i, jInterface := range interfacesArr {
err = jutil.GoVomCopy(env, jInterface, jInterfaceClass, &result[i])
if err != nil {
return nil, err
}
}
return result, nil
}
// GoPrincipal converts the provided Java VPrincipal object into a Go Principal.
func GoPrincipal(env jutil.Env, jPrincipal jutil.Object) (security.Principal, error) {
if jPrincipal.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jPrincipal, jVPrincipalImplClass) {
// Called with our implementation of VPrincipal, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jPrincipal, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.Principal)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java VPrincipal; it will be de-referenced when the Go Principal
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jPrincipal = jutil.NewGlobalRef(env, jPrincipal)
// Create Go Principal.
p := &principal{
jPrincipal: jPrincipal,
}
runtime.SetFinalizer(p, func(p *principal) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, p.jPrincipal)
})
return p, nil
}
// javaOutputWriter translates an implementation of the Java Vango.OutputWriter interface to Go's io.Writer
func newJavaOutputWriter(env jutil.Env, o jutil.Object) io.Writer {
ret := &javaOutputWriter{jutil.NewGlobalRef(env, o)}
runtime.SetFinalizer(ret, func(w *javaOutputWriter) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, w.obj)
})
return ret
}
// newConnection creates a new Go connection. The passed-in Java Stream object
// is assumed to hold a global reference.
func newConnection(env jutil.Env, jStream jutil.Object) flow.Conn {
c := &btReadWriteCloser{jStream}
runtime.SetFinalizer(c, func(c *btReadWriteCloser) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, c.jStream)
})
addrStr, _ := jutil.CallStringMethod(env, jStream, "localAddress", nil)
localAddr := &btAddr{addrStr}
return btConn{framer.New(c), localAddr}
}
func newListener(env jutil.Env, jListener jutil.Object) flow.Listener {
// Reference Java Listener; it will be de-referenced when the Go Listener
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jListener = jutil.NewGlobalRef(env, jListener)
l := &btListener{jListener}
runtime.SetFinalizer(l, func(l *btListener) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, l.jListener)
})
return l
}
func (c *bleReadWriteCloser) Read(b []byte) (n int, err error) {
env, freeFunc := jutil.GetEnv()
// This method will invoke the freeFunc().
jResult, err := jutil.CallCallbackMethod(env, freeFunc, c.jStream, "read", []jutil.Sign{jutil.IntSign}, len(b))
if err != nil {
return 0, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jResult)
data := jutil.GoByteArray(env, jResult)
return copy(b, data), nil
}
//export Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites
func Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites(jenv *C.JNIEnv, jDatabase C.jobject, jContext C.jobject, jInviteHandler C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
database := jutil.Object(uintptr(unsafe.Pointer(jDatabase)))
handler := jutil.Object(uintptr(unsafe.Pointer(jInviteHandler)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return
}
jDbId, err := jutil.CallObjectMethod(env, database, "id", nil, idSign)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbName, err := jutil.CallStringMethod(env, jDbId, "getName", nil)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbBlessing, err := jutil.CallStringMethod(env, jDbId, "getBlessing", nil)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbId := wire.Id{Name: dbName, Blessing: dbBlessing}
// Note: There is no need to use a buffered channel here. ListenForInvites
// spawns a goroutine for this listener that acts as an infinite buffer so we can
// process invites at our own pace.
ch := make(chan discovery.Invite)
if err := discovery.ListenForInvites(ctx, dbId, ch); err != nil {
jutil.JThrowV(env, err)
return
}
handler = jutil.NewGlobalRef(env, handler)
go func() {
for invite := range ch {
if err := handleInvite(invite, handler); err != nil {
// TODO(mattr): We should cancel the stream and return an error to
// the user here.
ctx.Errorf("couldn't call invite handler: %v", err)
}
}
env, free := jutil.GetEnv()
jutil.DeleteGlobalRef(env, handler)
free()
}()
}
// GoAddressChooser converts a Java AddressChooser object into a Go address
// chooser function.
func GoAddressChooser(env jutil.Env, jChooser jutil.Object) rpc.AddressChooser {
// Reference Java chooser; it will be de-referenced when the go function
// created below is garbage-collected (through the finalizer callback we
// setup just below).
chooser := &jniAddressChooser{
jChooser: jutil.NewGlobalRef(env, jChooser),
}
runtime.SetFinalizer(chooser, func(chooser *jniAddressChooser) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, chooser.jChooser)
})
return chooser
}
func goInvoker(env jutil.Env, jInvoker jutil.Object) (rpc.Invoker, error) {
// Reference Java invoker; it will be de-referenced when the go invoker
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jInvoker = jutil.NewGlobalRef(env, jInvoker)
i := &invoker{
jInvoker: jInvoker,
}
runtime.SetFinalizer(i, func(i *invoker) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, i.jInvoker)
})
return i, nil
}
// GoSigner creates an instance of security.Signer that uses the provided
// Java VSigner as its underlying implementation.
func GoSigner(env jutil.Env, jSigner jutil.Object) (security.Signer, error) {
// Reference Java VSigner; it will be de-referenced when the Go Signer
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jSigner = jutil.NewGlobalRef(env, jSigner)
s := &signer{
jSigner: jSigner,
}
runtime.SetFinalizer(s, func(s *signer) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, s.jSigner)
})
return s, nil
}
// GoContextValue returns the Go Context value given the Java Context value.
func GoContextValue(env jutil.Env, jValue jutil.Object) (interface{}, error) {
// Reference Java object; it will be de-referenced when the Go wrapper
// object created below is garbage-collected (via the finalizer we setup
// just below.)
jValue = jutil.NewGlobalRef(env, jValue)
value := &goContextValue{
jObj: jValue,
}
runtime.SetFinalizer(value, func(value *goContextValue) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, value.jObj)
})
return value, nil
}
// GoDispatcher creates a new rpc.Dispatcher given the Java Dispatcher object.
func GoDispatcher(env jutil.Env, jDispatcher jutil.Object) (rpc.Dispatcher, error) {
// Reference Java dispatcher; it will be de-referenced when the go
// dispatcher created below is garbage-collected (through the finalizer
// callback we setup below).
jDispatcher = jutil.NewGlobalRef(env, jDispatcher)
d := &dispatcher{
jDispatcher: jDispatcher,
}
runtime.SetFinalizer(d, func(d *dispatcher) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, d.jDispatcher)
})
return d, nil
}
func (i *invoker) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, err error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return nil, err
}
jStreamServerCall, err := javaStreamServerCall(env, jContext, call)
if err != nil {
freeFunc()
return nil, err
}
vomArgs := make([][]byte, len(argptrs))
for i, argptr := range argptrs {
arg := interface{}(jutil.DerefOrDie(argptr))
var err error
if vomArgs[i], err = vom.Encode(arg); err != nil {
freeFunc()
return nil, err
}
}
// This method will invoke the freeFunc().
jResult, err := jutil.CallStaticFutureMethod(env, freeFunc, jServerRPCHelperClass, "invoke", []jutil.Sign{invokerSign, contextSign, streamServerCallSign, jutil.StringSign, jutil.ArraySign(jutil.ArraySign(jutil.ByteSign))}, i.jInvoker, jContext, jStreamServerCall, jutil.CamelCase(method), vomArgs)
if err != nil {
return nil, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jResult)
vomResults, err := jutil.GoByteArrayArray(env, jResult)
if err != nil {
return nil, err
}
results = make([]interface{}, len(vomResults))
for i, vomResult := range vomResults {
var err error
if results[i], err = jutil.VomDecodeToValue(vomResult); err != nil {
return nil, err
}
}
return results, nil
}
func (i *invoker) MethodSignature(ctx *context.T, call rpc.ServerCall, method string) (signature.Method, error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return signature.Method{}, err
}
// This method will invoke the freeFunc().
jMethod, err := jutil.CallFutureMethod(env, freeFunc, i.jInvoker, "getMethodSignature", []jutil.Sign{contextSign, jutil.StringSign}, jContext, method)
if err != nil {
return signature.Method{}, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jMethod)
var result signature.Method
err = jutil.GoVomCopy(env, jMethod, jMethodClass, &result)
if err != nil {
return signature.Method{}, err
}
return result, nil
}
//export Java_io_v_impl_google_rpc_ClientImpl_nativeStartCall
func Java_io_v_impl_google_rpc_ClientImpl_nativeStartCall(jenv *C.JNIEnv, jClientObj C.jobject, goRef C.jlong,
jContext C.jobject, jName C.jstring, jMethod C.jstring, jVomArgs C.jobjectArray, jOptionsObj C.jobject, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
method := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jMethod))))
jOptions := jutil.Object(uintptr(unsafe.Pointer(jOptionsObj)))
jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
ctx, cancel, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.CallbackOnFailure(env, jCallback, err)
return
}
args, err := decodeArgs(env, jVomArgs)
if err != nil {
jutil.CallbackOnFailure(env, jCallback, err)
return
}
opts, err := jopts.GoRpcOpts(env, jOptions)
if err != nil {
jutil.CallbackOnFailure(env, jCallback, err)
return
}
// Create a global reference to the client object for the duration of the call
// so that the java object doesn't get garbage collected while the async call
// is happening. This is an issue because if the java object is garbage collected,
// the go ref will also be collected causing doStartCall to panic.
jClient := jutil.NewGlobalRef(env, jutil.Object(uintptr(unsafe.Pointer(jClientObj))))
jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
obj, err := doStartCall(ctx, cancel, name, method, opts, goRef, args)
env, freeFunc := jutil.GetEnv()
jutil.DeleteGlobalRef(env, jClient)
freeFunc()
return obj, err
})
}
