Merge "fix unnecessary (and erroneous) use of jutil.JString"
diff --git a/impl/google/channel/jni.go b/impl/google/channel/jni.go
index 4daff97..81ede12 100644
--- a/impl/google/channel/jni.go
+++ b/impl/google/channel/jni.go
@@ -7,10 +7,8 @@
package channel
import (
- "fmt"
"unsafe"
- "v.io/v23/verror"
jutil "v.io/x/jni/util"
)
@@ -18,12 +16,10 @@
import "C"
var (
- // Global reference for io.v.impl.google.channel.ChannelIterable class.
- jChannelIterableClass jutil.Class
+ // Global reference for io.v.impl.google.channel.InputChannelImpl class.
+ jInputChannelImplClass jutil.Class
// Global reference for io.v.impl.google.channel.OutputChannelImpl class.
jOutputChannelImplClass jutil.Class
- // Global reference for java.io.EOFException class.
- jEOFExceptionClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
@@ -31,7 +27,7 @@
// from the main Java thread (e.g., On_Load()).
func Init(env jutil.Env) error {
var err error
- jChannelIterableClass, err = jutil.JFindClass(env, "io/v/impl/google/channel/ChannelIterable")
+ jInputChannelImplClass, err = jutil.JFindClass(env, "io/v/impl/google/channel/InputChannelImpl")
if err != nil {
return err
}
@@ -39,63 +35,54 @@
if err != nil {
return err
}
- jEOFExceptionClass, err = jutil.JFindClass(env, "java/io/EOFException")
+ return nil
+}
+
+//export Java_io_v_impl_google_channel_InputChannelImpl_nativeRecv
+func Java_io_v_impl_google_channel_InputChannelImpl_nativeRecv(jenv *C.JNIEnv, jInputChannelImpl C.jobject, goRecvPtr C.jlong, jCallbackObj C.jobject) {
+ env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+ recv := *(*func() (jutil.Object, error))(jutil.NativePtr(goRecvPtr))
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
+ jutil.DoAsyncCall(env, jCallback, recv)
+}
+
+//export Java_io_v_impl_google_channel_InputChannelImpl_nativeFinalize
+func Java_io_v_impl_google_channel_InputChannelImpl_nativeFinalize(jenv *C.JNIEnv, jInputChannelImpl C.jobject, goRecvPtr C.jlong) {
+ jutil.GoUnref(jutil.NativePtr(goRecvPtr))
+}
+
+//export Java_io_v_impl_google_channel_OutputChannelImpl_nativeSend
+func Java_io_v_impl_google_channel_OutputChannelImpl_nativeSend(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goConvertPtr C.jlong, goSendPtr C.jlong, jItemObj C.jobject, jCallbackObj C.jobject) {
+ env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+ convert := *(*func(jutil.Object) (interface{}, error))(jutil.NativePtr(goConvertPtr))
+ send := *(*func(interface{}) error)(jutil.NativePtr(goSendPtr))
+ jItem := jutil.Object(uintptr(unsafe.Pointer(jItemObj)))
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
+ // NOTE(spetrovic): Conversion must be done outside of DoAsyncCall as it references a Java
+ // object.
+ item, err := convert(jItem)
if err != nil {
- return err
+ jutil.CallbackOnFailure(env, jCallback, err)
+ return
}
- return nil
-}
-
-//export Java_io_v_impl_google_channel_ChannelIterable_nativeReadValue
-func Java_io_v_impl_google_channel_ChannelIterable_nativeReadValue(jenv *C.JNIEnv, jChannelIterable C.jobject, goChanPtr C.jlong, goConvertPtr C.jlong) C.jobject {
- env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
- c := *(*chan interface{})(jutil.NativePtr(goChanPtr))
- convert := *(*func(jutil.Env, interface{})(jutil.Object, error))(jutil.NativePtr(goConvertPtr))
- val, ok := <-c
- if !ok { // channel closed
- jutil.JThrow(env, jEOFExceptionClass, "Reached end of input channel.")
- return nil
- }
- jVal, err := convert(env, val)
- if err == nil {
- return C.jobject(unsafe.Pointer(jVal))
- }
- if verr, ok := err.(verror.E); ok && verr.ID == verror.ErrCanceled.ID { // EOF
- jutil.JThrow(env, jEOFExceptionClass, "User canceled the operation.")
- return nil
- }
- jutil.JThrowV(env, err)
- return nil
-}
-
-//export Java_io_v_impl_google_channel_ChannelIterable_nativeFinalize
-func Java_io_v_impl_google_channel_ChannelIterable_nativeFinalize(jenv *C.JNIEnv, jChannelIterable C.jobject, goChanPtr C.jlong, goConvertPtr C.jlong) {
- jutil.GoUnref(jutil.NativePtr(goChanPtr))
- jutil.GoUnref(jutil.NativePtr(goConvertPtr))
-}
-
-//export Java_io_v_impl_google_channel_OutputChannelImpl_nativeWriteValue
-func Java_io_v_impl_google_channel_OutputChannelImpl_nativeWriteValue(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goChanPtr C.jlong, jObject C.jobject) {
- env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
- outCh := *(*outputChannel)(jutil.NativePtr(goChanPtr))
- // The other side of the channel is responsible for deleting this
- // global reference.
- if err := outCh.ReadFunc(jutil.NewGlobalRef(env, jutil.Object(uintptr(unsafe.Pointer(jObject))))); err != nil {
- jutil.JThrowV(env, fmt.Errorf("Exception while writing to OutputChannel: %+v", err))
- }
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return jutil.NullObject, send(item)
+ })
}
//export Java_io_v_impl_google_channel_OutputChannelImpl_nativeClose
-func Java_io_v_impl_google_channel_OutputChannelImpl_nativeClose(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goChanPtr C.jlong) {
+func Java_io_v_impl_google_channel_OutputChannelImpl_nativeClose(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goClosePtr C.jlong, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
- outCh := *(*outputChannel)(jutil.NativePtr(goChanPtr))
-
- if err := outCh.CloseFunc(); err != nil {
- jutil.JThrowV(env, fmt.Errorf("Exception while closing OutputChannel: %+v", err))
- }
+ close := *(*func() error)(jutil.NativePtr(goClosePtr))
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return jutil.NullObject, close()
+ })
}
//export Java_io_v_impl_google_channel_OutputChannelImpl_nativeFinalize
-func Java_io_v_impl_google_channel_OutputChannelImpl_nativeFinalize(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goChanPtr C.jlong) {
- jutil.GoUnref(jutil.NativePtr(goChanPtr))
+func Java_io_v_impl_google_channel_OutputChannelImpl_nativeFinalize(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goConvertPtr C.jlong, goSendPtr C.jlong, goClosePtr C.jlong) {
+ jutil.GoUnref(jutil.NativePtr(goConvertPtr))
+ jutil.GoUnref(jutil.NativePtr(goSendPtr))
+ jutil.GoUnref(jutil.NativePtr(goClosePtr))
}
diff --git a/impl/google/channel/util.go b/impl/google/channel/util.go
index 331d542..486307a 100644
--- a/impl/google/channel/util.go
+++ b/impl/google/channel/util.go
@@ -13,54 +13,30 @@
// #include "jni.h"
import "C"
-// JavaIterable converts the provided Go channel into a Java VIterable object, using the
-// given convert function.
-func JavaIterable(env jutil.Env, ch chan interface{}, convert func(jutil.Env, interface{}) (jutil.Object, error)) (jutil.Object, error) {
- jIterable, err := jutil.NewObject(env, jChannelIterableClass, []jutil.Sign{jutil.LongSign, jutil.LongSign}, int64(jutil.PtrValue(&ch)), int64(jutil.PtrValue(&convert)))
+// JavaInputChannel creates a new Java InputChannel object given the provided Go recv function.
+//
+// All objects returned by the recv function must be globally references.
+//
+// The recv function must return verror.ErrEndOfFile when there are no more elements
+// to receive.
+func JavaInputChannel(env jutil.Env, recv func() (jutil.Object, error)) (jutil.Object, error) {
+ jInputChannel, err := jutil.NewObject(env, jInputChannelImplClass, []jutil.Sign{jutil.LongSign}, int64(jutil.PtrValue(&recv)))
if err != nil {
return jutil.NullObject, err
}
- jutil.GoRef(&ch) // Un-refed when ChannelIterable is finalized.
- jutil.GoRef(&convert) // Un-refed when ChannelIterable is finalized.
- return jIterable, nil
+ jutil.GoRef(&recv) // Un-refed when jInputChannel is finalized.
+ return jInputChannel, nil
}
-// outputChannel represents the Go-side of a Java OutputChannel. Each time the
-// Java side writes an object, the ReadFunc will be called. If the ReadFunc
-// returns an error, an exception will be raised on the Java side.
-type outputChannel struct {
- // ReadFunc is invoked when an object has been read from Java.
- //
- // The jutil.Object passed to this function is globally referenced. It is
- // required that the ReadFunc implementation delete the global
- // reference jutil.DeleteGlobalRef. Failure to do so will
- // result in a reference leak.
- //
- // If the ReadFunc implementation returns an error, that error will be
- // passed back to the Java writer in the form of a VException to the
- // OutputChannel.writeValue() method.
- ReadFunc func(jutil.Object) error
-
- // CloseFunc is invoked when the Java side has closed its OutputChannel
- // and no more values will be written.
- //
- // If CloseFunc returns an error, that error will be passed back to the
- // Java side in the form of a VException OutputChannel.close() method.
- CloseFunc func() error
-}
-
-// JavaOutputChannel converts the provided Go channel of jutil.Object values
-// into a Java OutputChannel object.
-func JavaOutputChannel(env jutil.Env, readFunc func(jutil.Object) error, closeFunc func() error) (jutil.Object, error) {
- outCh := outputChannel{
- ReadFunc: readFunc,
- CloseFunc: closeFunc,
- }
-
- jOutputChannel, err := jutil.NewObject(env, jOutputChannelImplClass, []jutil.Sign{jutil.LongSign}, int64(jutil.PtrValue(&outCh)))
+// JavaOutputChannel creates a new Java OutputChannel object given the provided Go convert, send
+// and close functions. Send is invoked with the result of convert, which must be non-blocking.
+func JavaOutputChannel(env jutil.Env, convert func(jutil.Object) (interface{}, error), send func(interface{}) error, close func() error) (jutil.Object, error) {
+ jOutputChannel, err := jutil.NewObject(env, jOutputChannelImplClass, []jutil.Sign{jutil.LongSign, jutil.LongSign, jutil.LongSign}, int64(jutil.PtrValue(&convert)), int64(jutil.PtrValue(&send)), int64(jutil.PtrValue(&close)))
if err != nil {
return jutil.NullObject, err
}
- jutil.GoRef(&outCh) // Un-refed when the OutputChannel is finalized.
+ jutil.GoRef(&convert) // Un-refed when jOutputChannel is finalized.
+ jutil.GoRef(&send) // Un-refed when jOutputChannel is finalized.
+ jutil.GoRef(&close) // Un-refed when jOutputChannel is finalized.
return jOutputChannel, nil
}
diff --git a/impl/google/namespace/jni.go b/impl/google/namespace/jni.go
index 96a6035..35c9481 100644
--- a/impl/google/namespace/jni.go
+++ b/impl/google/namespace/jni.go
@@ -71,31 +71,39 @@
return
}
-func doGlob(env jutil.Env, n namespace.T, context *context.T, pattern string, opts []naming.NamespaceOpt) (jutil.Object, error) {
+func doGlob(n namespace.T, context *context.T, pattern string, opts []naming.NamespaceOpt) (jutil.Object, error) {
c, err := n.Glob(context, pattern, opts...)
if err != nil {
return jutil.NullObject, err
}
- valChan := make(chan interface{}, 100)
- go func() {
- for val := range c {
- valChan <- val
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
+ jChannel, err := jchannel.JavaInputChannel(env, func() (jutil.Object, error) {
+ // This is a blocking call, so don't call GetEnv() before this line.
+ val, ok := <-c
+ if !ok {
+ return jutil.NullObject, verror.NewErrEndOfFile(context)
}
- close(valChan)
- }()
- return jchannel.JavaIterable(env, valChan, func(env jutil.Env, val interface{}) (jutil.Object, error) {
globReply, ok := val.(naming.GlobReply)
if !ok {
return jutil.NullObject, fmt.Errorf("Expected value of GlobReply type, got type %T: %v", val, val)
}
- // Check for a canceled context error, we surface these as EOF.
- if errorEntry, ok := globReply.(*naming.GlobReplyError); ok {
- if verr, ok := errorEntry.Value.Error.(verror.E); ok && verr.ID == verror.ErrCanceled.ID {
- return jutil.NullObject, verr
- }
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
+ jReply, err := jutil.JVomCopy(env, globReply, jGlobReplyClass)
+ if err != nil {
+ return jutil.NullObject, err
}
- return jutil.JVomCopy(env, val, jGlobReplyClass)
+ // Must grab a global reference as we free up the env and all local references that come
+ // along with it.
+ return jutil.NewGlobalRef(env, jReply), nil // Un-refed by InputChannelImpl_nativeRecv
})
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jChannel), nil // Un-refed by DoAsyncCall
}
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeGlob
@@ -108,8 +116,8 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doGlob(env, n, context, pattern, opts)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doGlob(n, context, pattern, opts)
})
}
@@ -138,7 +146,7 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
return jutil.NullObject, n.Mount(context, name, server, duration, options...)
})
}
@@ -164,7 +172,7 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
return jutil.NullObject, n.Unmount(context, name, server, options...)
})
}
@@ -193,7 +201,7 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
return jutil.NullObject, n.Delete(context, name, deleteSubtree, options...)
})
}
@@ -211,12 +219,20 @@
return
}
-func doResolve(env jutil.Env, n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
+func doResolve(n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
entry, err := n.Resolve(context, name, options...)
if err != nil {
return jutil.NullObject, err
}
- return jutil.JVomCopy(env, entry, jMountEntryClass)
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
+ jEntry, err := jutil.JVomCopy(env, entry, jMountEntryClass)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jEntry), nil // Un-refed in DoAsyncCall
}
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeResolve
@@ -229,8 +245,8 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doResolve(env, n, context, name, options)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doResolve(n, context, name, options)
})
}
@@ -247,12 +263,20 @@
return
}
-func doResolveToMountTable(env jutil.Env, n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
+func doResolveToMountTable(n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
entry, err := n.ResolveToMountTable(context, name, options...)
if err != nil {
return jutil.NullObject, err
}
- return jutil.JVomCopy(env, entry, jMountEntryClass)
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
+ jEntry, err := jutil.JVomCopy(env, entry, jMountEntryClass)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jEntry), nil // Un-refed in DoAsyncCall
}
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeResolveToMountTable
@@ -265,8 +289,8 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doResolveToMountTable(env, n, context, name, options)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doResolveToMountTable(n, context, name, options)
})
}
@@ -327,7 +351,7 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
return jutil.NullObject, n.SetPermissions(context, name, permissions, version, options...)
})
}
@@ -345,18 +369,26 @@
return
}
-func doGetPermissions(env jutil.Env, n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
+func doGetPermissions(n namespace.T, context *context.T, name string, options []naming.NamespaceOpt) (jutil.Object, error) {
permissions, version, err := n.GetPermissions(context, name, options...)
if err != nil {
return jutil.NullObject, err
}
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
jPermissions, err := jutil.JVomCopy(env, permissions, jPermissionsClass)
if err != nil {
return jutil.NullObject, err
}
result := make(map[jutil.Object]jutil.Object)
result[jutil.JString(env, version)] = jPermissions
- return jutil.JObjectMap(env, result)
+ jResult, err := jutil.JObjectMap(env, result)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jResult), nil // Un-refed in DoAsyncCall
}
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeGetPermissions
@@ -369,8 +401,8 @@
jutil.CallbackOnFailure(env, jCallback, err)
return
}
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doGetPermissions(env, n, context, name, options)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doGetPermissions(n, context, name, options)
})
}
diff --git a/impl/google/rpc/invoker.go b/impl/google/rpc/invoker.go
index 28449b4..7dc85a6 100644
--- a/impl/google/rpc/invoker.go
+++ b/impl/google/rpc/invoker.go
@@ -201,24 +201,26 @@
return err
}
- readFunc := func(input jutil.Object) error {
+ convert := func(input jutil.Object) (interface{}, error) {
env, freeFunc := jutil.GetEnv()
- defer jutil.DeleteGlobalRef(env, input)
+ defer freeFunc()
var reply naming.GlobReply
- err := jutil.GoVomCopy(env, input, jGlobReplyClass, &reply)
- if err != nil {
- freeFunc()
- return err
+ if err := jutil.GoVomCopy(env, input, jGlobReplyClass, &reply); err != nil {
+ return nil, err
}
- freeFunc()
- call.SendStream().Send(reply)
+ return reply, nil
+ }
+ send := func(item interface{}) error {
+ reply, ok := item.(naming.GlobReply)
+ if !ok {
+ return fmt.Errorf("Expected item of type naming.GlobReply, got: %T", reply)
+ }
+ return call.SendStream().Send(reply)
+ }
+ close := func() error {
return nil
}
- closeFunc := func() error {
- return nil
- }
-
- jOutputChannel, err := jchannel.JavaOutputChannel(env, readFunc, closeFunc)
+ jOutputChannel, err := jchannel.JavaOutputChannel(env, convert, send, close)
if err != nil {
return err
}
diff --git a/impl/google/rpc/jni.go b/impl/google/rpc/jni.go
index be7af99..b643d86 100644
--- a/impl/google/rpc/jni.go
+++ b/impl/google/rpc/jni.go
@@ -22,6 +22,7 @@
jcontext "v.io/x/jni/v23/context"
jnaming "v.io/x/jni/v23/naming"
jsecurity "v.io/x/jni/v23/security"
+ "v.io/v23/verror"
)
// #include "jni.h"
@@ -74,8 +75,6 @@
jServerStateClass jutil.Class
// Global reference for io.v.v23.OptionDefs class.
jOptionDefsClass jutil.Class
- // Global reference for java.io.EOFException class.
- jEOFExceptionClass jutil.Class
// Global reference for io.v.v23.naming.Endpoint.
jEndpointClass jutil.Class
// Global reference for io.v.v23.vdlroot.signature.Interface class.
@@ -170,10 +169,6 @@
if err != nil {
return err
}
- jEOFExceptionClass, err = jutil.JFindClass(env, "java/io/EOFException")
- if err != nil {
- return err
- }
jEndpointClass, err = jutil.JFindClass(env, "io/v/v23/naming/Endpoint")
if err != nil {
return err
@@ -257,7 +252,7 @@
return args, nil
}
-func doStartCall(env jutil.Env, context *context.T, name, method string, skipServerAuth bool, goPtr C.jlong, args []interface{}) (jutil.Object, error) {
+func doStartCall(context *context.T, name, method string, skipServerAuth bool, goPtr C.jlong, args []interface{}) (jutil.Object, error) {
var opts []rpc.CallOpt
if skipServerAuth {
opts = append(opts,
@@ -269,11 +264,15 @@
if err != nil {
return jutil.NullObject, err
}
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
jCall, err := javaCall(env, call)
if err != nil {
return jutil.NullObject, err
}
- return jCall, nil
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jCall), nil // Un-refed in DoAsyncCall
}
//export Java_io_v_impl_google_rpc_ClientImpl_nativeStartCall
@@ -293,8 +292,8 @@
return
}
skipServerAuth := jSkipServerAuth == C.JNI_TRUE
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doStartCall(env, context, name, method, skipServerAuth, goPtr, args)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doStartCall(context, name, method, skipServerAuth, goPtr, args)
})
}
@@ -309,43 +308,46 @@
}
//export Java_io_v_impl_google_rpc_StreamImpl_nativeSend
-func Java_io_v_impl_google_rpc_StreamImpl_nativeSend(jenv *C.JNIEnv, jStream C.jobject, goPtr C.jlong, jVomItem C.jbyteArray) {
+func Java_io_v_impl_google_rpc_StreamImpl_nativeSend(jenv *C.JNIEnv, jStream C.jobject, goPtr C.jlong, jVomItem C.jbyteArray, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
vomItem := jutil.GoByteArray(env, jutil.Object(uintptr(unsafe.Pointer(jVomItem))))
- item, err := jutil.VomDecodeToValue(vomItem)
- if err != nil {
- jutil.JThrowV(env, err)
- return
- }
- if err := (*(*rpc.Stream)(jutil.NativePtr(goPtr))).Send(item); err != nil {
- jutil.JThrowV(env, err)
- return
- }
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ item, err := jutil.VomDecodeToValue(vomItem)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ return jutil.NullObject, (*(*rpc.Stream)(jutil.NativePtr(goPtr))).Send(item)
+ })
}
//export Java_io_v_impl_google_rpc_StreamImpl_nativeRecv
-func Java_io_v_impl_google_rpc_StreamImpl_nativeRecv(jenv *C.JNIEnv, jStream C.jobject, goPtr C.jlong) C.jbyteArray {
+func Java_io_v_impl_google_rpc_StreamImpl_nativeRecv(jenv *C.JNIEnv, jStream C.jobject, goPtr C.jlong, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
result := new(vdl.Value)
- if err := (*(*rpc.Stream)(jutil.NativePtr(goPtr))).Recv(&result); err != nil {
- if err == io.EOF {
- jutil.JThrow(env, jEOFExceptionClass, err.Error())
- return nil
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ if err := (*(*rpc.Stream)(jutil.NativePtr(goPtr))).Recv(&result); err != nil {
+ if err == io.EOF {
+ // Java uses EndOfFile error to detect EOF.
+ err = verror.NewErrEndOfFile(nil)
+ }
+ return jutil.NullObject, err
}
- jutil.JThrowV(env, err)
- return nil
- }
- vomResult, err := vom.Encode(result)
- if err != nil {
- jutil.JThrowV(env, err)
- return nil
- }
- jArr, err := jutil.JByteArray(env, vomResult)
- if err != nil {
- jutil.JThrowV(env, err)
- return nil
- }
- return C.jbyteArray(unsafe.Pointer(jArr))
+ vomResult, err := vom.Encode(result)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
+ jResult, err := jutil.JByteArray(env, vomResult)
+ if err != nil {
+ return jutil.NullObject, err
+ }
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jResult), nil // Un-refed in DoAsyncCall
+ })
}
//export Java_io_v_impl_google_rpc_StreamImpl_nativeFinalize
@@ -354,15 +356,15 @@
}
//export Java_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend
-func Java_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend(jenv *C.JNIEnv, jCall C.jobject, goPtr C.jlong) {
+func Java_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend(jenv *C.JNIEnv, jCall C.jobject, goPtr C.jlong, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
- if err := (*(*rpc.ClientCall)(jutil.NativePtr(goPtr))).CloseSend(); err != nil {
- jutil.JThrowV(env, err)
- return
- }
+ jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return jutil.NullObject, (*(*rpc.ClientCall)(jutil.NativePtr(goPtr))).CloseSend()
+ })
}
-func doFinish(env jutil.Env, goPtr C.jlong, numResults int) (jutil.Object, error) {
+func doFinish(goPtr C.jlong, numResults int) (jutil.Object, error) {
// Have all the results be decoded into *vdl.Value.
resultPtrs := make([]interface{}, numResults)
for i := 0; i < numResults; i++ {
@@ -384,11 +386,15 @@
return jutil.NullObject, err
}
}
+ env, freeFunc := jutil.GetEnv()
+ defer freeFunc()
jArr, err := jutil.JByteArrayArray(env, vomResults)
if err != nil {
return jutil.NullObject, err
}
- return jArr, nil
+ // Must grab a global reference as we free up the env and all local references that come along
+ // with it.
+ return jutil.NewGlobalRef(env, jArr), nil // Un-refed in DoAsyncCall
}
//export Java_io_v_impl_google_rpc_ClientCallImpl_nativeFinish
@@ -396,8 +402,8 @@
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
numResults := int(jNumResults)
jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
- jutil.DoAsyncCall(env, jCallback, func(env jutil.Env) (jutil.Object, error) {
- return doFinish(env, goPtr, numResults)
+ jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
+ return doFinish(goPtr, numResults)
})
}
diff --git a/test/fortune/fortune.vdl b/test/fortune/fortune.vdl
index 8b9470e..c829464 100644
--- a/test/fortune/fortune.vdl
+++ b/test/fortune/fortune.vdl
@@ -29,12 +29,17 @@
// Get returns a random fortune.
Get() (Fortune string | error) {access.Read}
- // StreamingGet returns a stream that can be used to obtain fortunes.
+ // StreamingGet returns a stream that can be used to obtain fortunes, and returns the
+ // total number of items sent.
StreamingGet() stream<bool, string> (total int32 | error) {access.Read}
// MultipleGet returns the same fortune twice.
MultipleGet() (Fortune string, Another string | error) {access.Read}
+ // MultipleStreamingGet returns a stream that can be used to obtain fortunes, and returns
+ // the total number of items sent, twice.
+ MultipleStreamingGet() stream<bool, string> (total int32, another int32 | error) {access.Read}
+
// GetComplexError returns (always!) ErrComplex.
GetComplexError() error {access.Read}
diff --git a/test/fortune/fortune.vdl.go b/test/fortune/fortune.vdl.go
index ae9937d..7197db2 100644
--- a/test/fortune/fortune.vdl.go
+++ b/test/fortune/fortune.vdl.go
@@ -65,10 +65,14 @@
Add(_ *context.T, Fortune string, _ ...rpc.CallOpt) error
// Get returns a random fortune.
Get(*context.T, ...rpc.CallOpt) (Fortune string, _ error)
- // StreamingGet returns a stream that can be used to obtain fortunes.
+ // StreamingGet returns a stream that can be used to obtain fortunes, and returns the
+ // total number of items sent.
StreamingGet(*context.T, ...rpc.CallOpt) (FortuneStreamingGetClientCall, error)
// MultipleGet returns the same fortune twice.
MultipleGet(*context.T, ...rpc.CallOpt) (Fortune string, Another string, _ error)
+ // MultipleStreamingGet returns a stream that can be used to obtain fortunes, and returns
+ // the total number of items sent, twice.
+ MultipleStreamingGet(*context.T, ...rpc.CallOpt) (FortuneMultipleStreamingGetClientCall, error)
// GetComplexError returns (always!) ErrComplex.
GetComplexError(*context.T, ...rpc.CallOpt) error
// NoTags is a method without tags.
@@ -117,6 +121,15 @@
return
}
+func (c implFortuneClientStub) MultipleStreamingGet(ctx *context.T, opts ...rpc.CallOpt) (ocall FortuneMultipleStreamingGetClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MultipleStreamingGet", nil, opts...); err != nil {
+ return
+ }
+ ocall = &implFortuneMultipleStreamingGetClientCall{ClientCall: call}
+ return
+}
+
func (c implFortuneClientStub) GetComplexError(ctx *context.T, opts ...rpc.CallOpt) (err error) {
err = v23.GetClient(ctx).Call(ctx, c.name, "GetComplexError", nil, nil, opts...)
return
@@ -234,6 +247,108 @@
return
}
+// FortuneMultipleStreamingGetClientStream is the client stream for Fortune.MultipleStreamingGet.
+type FortuneMultipleStreamingGetClientStream interface {
+ // RecvStream returns the receiver side of the Fortune.MultipleStreamingGet client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() string
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+ // SendStream returns the send side of the Fortune.MultipleStreamingGet client stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors
+ // encountered while sending, or if Send is called after Close or
+ // the stream has been canceled. Blocks if there is no buffer
+ // space; will unblock when buffer space is available or after
+ // the stream has been canceled.
+ Send(item bool) error
+ // Close indicates to the server that no more items will be sent;
+ // server Recv calls will receive io.EOF after all sent items.
+ // This is an optional call - e.g. a client might call Close if it
+ // needs to continue receiving items from the server after it's
+ // done sending. Returns errors encountered while closing, or if
+ // Close is called after the stream has been canceled. Like Send,
+ // blocks if there is no buffer space available.
+ Close() error
+ }
+}
+
+// FortuneMultipleStreamingGetClientCall represents the call returned from Fortune.MultipleStreamingGet.
+type FortuneMultipleStreamingGetClientCall interface {
+ FortuneMultipleStreamingGetClientStream
+ // Finish performs the equivalent of SendStream().Close, then blocks until
+ // the server is done, and returns the positional return values for the call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() (total int32, another int32, _ error)
+}
+
+type implFortuneMultipleStreamingGetClientCall struct {
+ rpc.ClientCall
+ valRecv string
+ errRecv error
+}
+
+func (c *implFortuneMultipleStreamingGetClientCall) RecvStream() interface {
+ Advance() bool
+ Value() string
+ Err() error
+} {
+ return implFortuneMultipleStreamingGetClientCallRecv{c}
+}
+
+type implFortuneMultipleStreamingGetClientCallRecv struct {
+ c *implFortuneMultipleStreamingGetClientCall
+}
+
+func (c implFortuneMultipleStreamingGetClientCallRecv) Advance() bool {
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implFortuneMultipleStreamingGetClientCallRecv) Value() string {
+ return c.c.valRecv
+}
+func (c implFortuneMultipleStreamingGetClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implFortuneMultipleStreamingGetClientCall) SendStream() interface {
+ Send(item bool) error
+ Close() error
+} {
+ return implFortuneMultipleStreamingGetClientCallSend{c}
+}
+
+type implFortuneMultipleStreamingGetClientCallSend struct {
+ c *implFortuneMultipleStreamingGetClientCall
+}
+
+func (c implFortuneMultipleStreamingGetClientCallSend) Send(item bool) error {
+ return c.c.Send(item)
+}
+func (c implFortuneMultipleStreamingGetClientCallSend) Close() error {
+ return c.c.CloseSend()
+}
+func (c *implFortuneMultipleStreamingGetClientCall) Finish() (o0 int32, o1 int32, err error) {
+ err = c.ClientCall.Finish(&o0, &o1)
+ return
+}
+
// FortuneServerMethods is the interface a server writer
// implements for Fortune.
//
@@ -243,10 +358,14 @@
Add(_ *context.T, _ rpc.ServerCall, Fortune string) error
// Get returns a random fortune.
Get(*context.T, rpc.ServerCall) (Fortune string, _ error)
- // StreamingGet returns a stream that can be used to obtain fortunes.
+ // StreamingGet returns a stream that can be used to obtain fortunes, and returns the
+ // total number of items sent.
StreamingGet(*context.T, FortuneStreamingGetServerCall) (total int32, _ error)
// MultipleGet returns the same fortune twice.
MultipleGet(*context.T, rpc.ServerCall) (Fortune string, Another string, _ error)
+ // MultipleStreamingGet returns a stream that can be used to obtain fortunes, and returns
+ // the total number of items sent, twice.
+ MultipleStreamingGet(*context.T, FortuneMultipleStreamingGetServerCall) (total int32, another int32, _ error)
// GetComplexError returns (always!) ErrComplex.
GetComplexError(*context.T, rpc.ServerCall) error
// NoTags is a method without tags.
@@ -265,10 +384,14 @@
Add(_ *context.T, _ rpc.ServerCall, Fortune string) error
// Get returns a random fortune.
Get(*context.T, rpc.ServerCall) (Fortune string, _ error)
- // StreamingGet returns a stream that can be used to obtain fortunes.
+ // StreamingGet returns a stream that can be used to obtain fortunes, and returns the
+ // total number of items sent.
StreamingGet(*context.T, *FortuneStreamingGetServerCallStub) (total int32, _ error)
// MultipleGet returns the same fortune twice.
MultipleGet(*context.T, rpc.ServerCall) (Fortune string, Another string, _ error)
+ // MultipleStreamingGet returns a stream that can be used to obtain fortunes, and returns
+ // the total number of items sent, twice.
+ MultipleStreamingGet(*context.T, *FortuneMultipleStreamingGetServerCallStub) (total int32, another int32, _ error)
// GetComplexError returns (always!) ErrComplex.
GetComplexError(*context.T, rpc.ServerCall) error
// NoTags is a method without tags.
@@ -323,6 +446,10 @@
return s.impl.MultipleGet(ctx, call)
}
+func (s implFortuneServerStub) MultipleStreamingGet(ctx *context.T, call *FortuneMultipleStreamingGetServerCallStub) (int32, int32, error) {
+ return s.impl.MultipleStreamingGet(ctx, call)
+}
+
func (s implFortuneServerStub) GetComplexError(ctx *context.T, call rpc.ServerCall) error {
return s.impl.GetComplexError(ctx, call)
}
@@ -370,7 +497,7 @@
},
{
Name: "StreamingGet",
- Doc: "// StreamingGet returns a stream that can be used to obtain fortunes.",
+ Doc: "// StreamingGet returns a stream that can be used to obtain fortunes, and returns the\n// total number of items sent.",
OutArgs: []rpc.ArgDesc{
{"total", ``}, // int32
},
@@ -386,6 +513,15 @@
Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
},
{
+ Name: "MultipleStreamingGet",
+ Doc: "// MultipleStreamingGet returns a stream that can be used to obtain fortunes, and returns\n// the total number of items sent, twice.",
+ OutArgs: []rpc.ArgDesc{
+ {"total", ``}, // int32
+ {"another", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
Name: "GetComplexError",
Doc: "// GetComplexError returns (always!) ErrComplex.",
Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
@@ -485,3 +621,87 @@
func (s implFortuneStreamingGetServerCallSend) Send(item string) error {
return s.s.Send(item)
}
+
+// FortuneMultipleStreamingGetServerStream is the server stream for Fortune.MultipleStreamingGet.
+type FortuneMultipleStreamingGetServerStream interface {
+ // RecvStream returns the receiver side of the Fortune.MultipleStreamingGet server stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() bool
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+ // SendStream returns the send side of the Fortune.MultipleStreamingGet server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item string) error
+ }
+}
+
+// FortuneMultipleStreamingGetServerCall represents the context passed to Fortune.MultipleStreamingGet.
+type FortuneMultipleStreamingGetServerCall interface {
+ rpc.ServerCall
+ FortuneMultipleStreamingGetServerStream
+}
+
+// FortuneMultipleStreamingGetServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements FortuneMultipleStreamingGetServerCall.
+type FortuneMultipleStreamingGetServerCallStub struct {
+ rpc.StreamServerCall
+ valRecv bool
+ errRecv error
+}
+
+// Init initializes FortuneMultipleStreamingGetServerCallStub from rpc.StreamServerCall.
+func (s *FortuneMultipleStreamingGetServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// RecvStream returns the receiver side of the Fortune.MultipleStreamingGet server stream.
+func (s *FortuneMultipleStreamingGetServerCallStub) RecvStream() interface {
+ Advance() bool
+ Value() bool
+ Err() error
+} {
+ return implFortuneMultipleStreamingGetServerCallRecv{s}
+}
+
+type implFortuneMultipleStreamingGetServerCallRecv struct {
+ s *FortuneMultipleStreamingGetServerCallStub
+}
+
+func (s implFortuneMultipleStreamingGetServerCallRecv) Advance() bool {
+ s.s.errRecv = s.s.Recv(&s.s.valRecv)
+ return s.s.errRecv == nil
+}
+func (s implFortuneMultipleStreamingGetServerCallRecv) Value() bool {
+ return s.s.valRecv
+}
+func (s implFortuneMultipleStreamingGetServerCallRecv) Err() error {
+ if s.s.errRecv == io.EOF {
+ return nil
+ }
+ return s.s.errRecv
+}
+
+// SendStream returns the send side of the Fortune.MultipleStreamingGet server stream.
+func (s *FortuneMultipleStreamingGetServerCallStub) SendStream() interface {
+ Send(item string) error
+} {
+ return implFortuneMultipleStreamingGetServerCallSend{s}
+}
+
+type implFortuneMultipleStreamingGetServerCallSend struct {
+ s *FortuneMultipleStreamingGetServerCallStub
+}
+
+func (s implFortuneMultipleStreamingGetServerCallSend) Send(item string) error {
+ return s.s.Send(item)
+}
diff --git a/util/call.go b/util/call.go
index 31ff97f..57560f4 100644
--- a/util/call.go
+++ b/util/call.go
@@ -295,7 +295,8 @@
// DoAsyncCall invokes the given fnToWrap in a goroutine. If fnToWrap returns an
// error, the given callback's onFailure method is invoked with the error as a
// parameter. If fnToWrap succeeds, its Object result is passed as a
-// parameter to the callback's onSuccess method.
+// parameter to the callback's onSuccess method. fnToWrap must return a global reference
+// to any non-null objects - this reference will be deleted by DoAsyncCall.
//
// The caller of doAsyncCall must take care that no local JNI references are
// used in fnToWrap's closure. For example:
@@ -312,31 +313,39 @@
// JNI references are only valid in the scope of a particular thread. You are
// free to capture any pure-Go variables and we recommend that you use that
// approach to pass parameters through to fnToWrap.
-func DoAsyncCall(env Env, jCallback Object, fnToWrap func(env Env) (Object, error)) {
+func DoAsyncCall(env Env, jCallback Object, fnToWrap func() (Object, error)) {
go func(jCallback Object) {
+ jResult, err := fnToWrap() // probably blocking, so don't call GetEnv() before this line
env, freeFunc := GetEnv()
defer freeFunc()
defer DeleteGlobalRef(env, jCallback)
- if result, err := fnToWrap(env); err != nil {
- CallbackOnFailure(env, jCallback, err)
- } else {
- CallbackOnSuccess(env, jCallback, result)
+ if !jResult.IsNull() {
+ if !IsGlobalRef(env, jResult) {
+ CallbackOnFailure(env, jCallback, fmt.Errorf("Function passed to DoAsyncCall must return global object references"))
+ return
+ }
+ defer DeleteGlobalRef(env, jResult)
}
+ if err != nil {
+ CallbackOnFailure(env, jCallback, err)
+ return
+ }
+ CallbackOnSuccess(env, jCallback, jResult)
}(NewGlobalRef(env, jCallback))
}
// CallbackOnFailure calls the given callback's "onFailure" method with the given error and
// panic-s if the method couldn't be invoked.
-func CallbackOnFailure(env Env, callback Object, err error) {
- if err := CallVoidMethod(env, callback, "onFailure", []Sign{VExceptionSign}, err); err != nil {
+func CallbackOnFailure(env Env, jCallback Object, err error) {
+ if err := CallVoidMethod(env, jCallback, "onFailure", []Sign{VExceptionSign}, err); err != nil {
panic(fmt.Sprintf("couldn't call Java onFailure method: %v", err))
}
}
// CalbackOnSuccess calls the given callback's "onSuccess" method with the given result
// and panic-s if the method couldn't be invoked.
-func CallbackOnSuccess(env Env, callback Object, jClientCall Object) {
- if err := CallVoidMethod(env, callback, "onSuccess", []Sign{ObjectSign}, jClientCall); err != nil {
+func CallbackOnSuccess(env Env, jCallback Object, jResult Object) {
+ if err := CallVoidMethod(env, jCallback, "onSuccess", []Sign{ObjectSign}, jResult); err != nil {
panic(fmt.Sprintf("couldn't call Java onSuccess method: %v", err))
}
}
diff --git a/util/jni_wrapper.c b/util/jni_wrapper.c
index 21c4a74..054a94c 100644
--- a/util/jni_wrapper.c
+++ b/util/jni_wrapper.c
@@ -166,6 +166,10 @@
(*env)->DeleteGlobalRef(env, globalRef);
}
+jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj) {
+ return (*env)->GetObjectRefType(env, obj);
+}
+
jint GetJavaVM(JNIEnv* env, JavaVM** vm) {
return (*env)->GetJavaVM(env, vm);
}
diff --git a/util/jni_wrapper.h b/util/jni_wrapper.h
index 2241c30..ef66a03 100644
--- a/util/jni_wrapper.h
+++ b/util/jni_wrapper.h
@@ -115,6 +115,10 @@
// Deletes the global reference pointed to by globalRef.
void DeleteGlobalRef(JNIEnv* env, jobject globalRef);
+// Returns the type of the object referred to by the obj argument.
+// The argument obj can either be a local, global or weak global reference.
+jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj);
+
// Returns the Java VM interface (used in the Invocation API) associated with
// the current thread.
jint GetJavaVM(JNIEnv* env, JavaVM** vm);
diff --git a/util/ref.go b/util/ref.go
index 2b19433..7fdbc11 100644
--- a/util/ref.go
+++ b/util/ref.go
@@ -40,6 +40,16 @@
C.DeleteLocalRef(env.value(), obj.value())
}
+// IsGlobalRef returns true iff the reference pointed to by obj is a global reference.
+func IsGlobalRef(env Env, obj Object) bool {
+ return C.GetObjectRefType(env.value(), obj.value()) == C.JNIGlobalRefType
+}
+
+// IsLocalRef returns true iff the reference pointed to by obj is a local reference.
+func IsLocalRef(env Env, obj Object) bool {
+ return C.GetObjectRefType(env.value(), obj.value()) == C.JNILocalRefType
+}
+
// GoRef creates a new reference to the value addressed by the provided pointer.
// The value will remain referenced until it is explicitly unreferenced using
// goUnref().
diff --git a/util/util.go b/util/util.go
index 18cdde5..f2d97bd 100644
--- a/util/util.go
+++ b/util/util.go
@@ -233,7 +233,6 @@
C.AttachCurrentThreadAsDaemon(jVM, &jenv, nil)
}
env = Env(uintptr(unsafe.Pointer(jenv)))
- //env := Env{jenv}
// GetEnv is called by Go code that wishes to call Java methods. In
// this case, JNI cannot automatically free unused local refererences.
// We must do it manually by pushing a new local reference frame. The
