mirror of
https://github.com/netbirdio/gomobile-tvos-fork.git
synced 2026-05-22 18:43:29 -07:00
go.mobile/bind/java: cgo-JNI bridge using seq
Details: http://golang.org/s/gobind LGTM=adonovan R=adonovan CC=golang-codereviews https://golang.org/cl/110550044
This commit is contained in:
David Crawshaw
@@ -0,0 +1,251 @@
|
||||
package go;
|
||||
|
||||
import android.util.Log;
|
||||
import android.util.SparseArray;
|
||||
import android.util.SparseIntArray;
|
||||
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
|
||||
// Seq is a sequence of machine-dependent encoded values.
|
||||
// Used by automatically generated language bindings to talk to Go.
|
||||
public class Seq {
|
||||
@SuppressWarnings("UnusedDeclaration")
|
||||
private long memptr; // holds C-allocated pointer
|
||||
|
||||
public Seq() {
|
||||
ensure(64);
|
||||
}
|
||||
|
||||
// Ensure that at least size bytes can be written to the Seq.
|
||||
// Any existing data in the buffer is preserved.
|
||||
public native void ensure(int size);
|
||||
|
||||
// Moves the internal buffer offset back to zero.
|
||||
// Length and contents are maintained. Data can be read after a reset.
|
||||
public native void resetOffset();
|
||||
|
||||
public native void log(String label);
|
||||
|
||||
public native byte readInt8();
|
||||
public native short readInt16();
|
||||
public native int readInt32();
|
||||
public native long readInt64();
|
||||
public long readInt() { return readInt64(); }
|
||||
|
||||
public native float readFloat32();
|
||||
public native double readFloat64();
|
||||
public native String readUTF16();
|
||||
public native byte[] readByteArray();
|
||||
|
||||
public native void writeInt8(byte v);
|
||||
public native void writeInt16(short v);
|
||||
public native void writeInt32(int v);
|
||||
public native void writeInt64(long v);
|
||||
public void writeInt(long v) { writeInt64(v); }
|
||||
|
||||
public native void writeFloat32(float v);
|
||||
public native void writeFloat64(double v);
|
||||
public native void writeUTF16(String v);
|
||||
public native void writeByteArray(byte[] v);
|
||||
|
||||
public void writeRef(Ref ref) {
|
||||
writeInt32(ref.refnum);
|
||||
}
|
||||
|
||||
public Ref readRef() {
|
||||
int refnum = readInt32();
|
||||
return tracker.get(refnum);
|
||||
}
|
||||
|
||||
// Informs the Go ref tracker that Java is done with this ref.
|
||||
static native void destroyRef(int refnum);
|
||||
|
||||
// createRef creates a Ref to a Java object.
|
||||
public static Ref createRef(Seq.Object o) {
|
||||
return tracker.createRef(o);
|
||||
}
|
||||
|
||||
// sends a function invocation request to Go.
|
||||
//
|
||||
// Blocks until the function completes.
|
||||
// If the request is for a method, the first element in src is
|
||||
// a Ref to the receiver.
|
||||
public static native void send(String descriptor, int code, Seq src, Seq dst);
|
||||
|
||||
// recv returns the next request from Go for a Java call.
|
||||
static native void recv(Seq in, Receive params);
|
||||
|
||||
// recvRes sends the result of a Java call back to Go.
|
||||
static native void recvRes(int handle, Seq out);
|
||||
|
||||
static final class Receive {
|
||||
int refnum;
|
||||
int code;
|
||||
int handle;
|
||||
}
|
||||
|
||||
protected void finalize() throws Throwable {
|
||||
super.finalize();
|
||||
free();
|
||||
}
|
||||
private native void free();
|
||||
|
||||
private static final ExecutorService receivePool = Executors.newCachedThreadPool();
|
||||
|
||||
// receive listens for callback requests from Go, invokes them on a thread
|
||||
// pool and sends the responses.
|
||||
public static void receive() {
|
||||
Seq.Receive params = new Seq.Receive();
|
||||
while (true) {
|
||||
final Seq in = new Seq();
|
||||
Seq.recv(in, params);
|
||||
|
||||
final int code = params.code;
|
||||
final int handle = params.handle;
|
||||
final int refnum = params.refnum;
|
||||
|
||||
if (code == -1) {
|
||||
// Special signal from seq.FinalizeRef.
|
||||
tracker.dec(refnum);
|
||||
Seq out = new Seq();
|
||||
Seq.recvRes(handle, out);
|
||||
continue;
|
||||
}
|
||||
|
||||
receivePool.execute(new Runnable() {
|
||||
public void run() {
|
||||
Ref r = tracker.get(refnum);
|
||||
Seq out = new Seq();
|
||||
r.obj.call(code, in, out);
|
||||
Seq.recvRes(handle, out);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// An Object is a Java object that matches a Go object.
|
||||
// The implementation of the object may be in either Java or Go,
|
||||
// with a proxy instance in the other language passing calls
|
||||
// through to the other language.
|
||||
//
|
||||
// Don't implement an Object directly. Instead, look for the
|
||||
// generated abstract Stub.
|
||||
public interface Object {
|
||||
public Ref ref();
|
||||
public void call(int code, Seq in, Seq out);
|
||||
}
|
||||
|
||||
// A Ref is an object tagged with an integer for passing back and
|
||||
// forth across the language boundary.
|
||||
//
|
||||
// A Ref may represent either an instance of a Java Object subclass,
|
||||
// or an instance of a Go object. The explicit allocation of a Ref
|
||||
// is used to pin Go object instances when they are passed to Java.
|
||||
// The Go Seq library maintains a reference to the instance in a map
|
||||
// keyed by the Ref number. When the JVM calls finalize, we ask Go
|
||||
// to clear the entry in the map.
|
||||
public static final class Ref {
|
||||
// ref < 0: Go object tracked by Java
|
||||
// ref > 0: Java object tracked by Go
|
||||
int refnum;
|
||||
public Seq.Object obj;
|
||||
|
||||
private Ref(int refnum, Seq.Object o) {
|
||||
this.refnum = refnum;
|
||||
this.obj = o;
|
||||
tracker.inc(refnum);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void finalize() throws Throwable {
|
||||
tracker.dec(refnum);
|
||||
super.finalize();
|
||||
}
|
||||
}
|
||||
|
||||
static final RefTracker tracker = new RefTracker();
|
||||
|
||||
static final class RefTracker {
|
||||
// Next Java object reference number.
|
||||
//
|
||||
// Reference numbers are positive for Java objects,
|
||||
// and start, arbitrarily at a different offset to Go
|
||||
// to make debugging by reading Seq hex a little easier.
|
||||
private int next = 42; // next Java object ref
|
||||
|
||||
// TODO(crawshaw): We could cut down allocations for frequently
|
||||
// sent Go objects by maintaining a map to weak references. This
|
||||
// however, would require allocating two objects per reference
|
||||
// instead of one. It also introduces weak references, the bane
|
||||
// of any Java debugging session.
|
||||
//
|
||||
// When we have real code, examine the tradeoffs.
|
||||
|
||||
// Number of active references to a Go object. refnum -> count
|
||||
private SparseIntArray goObjs = new SparseIntArray();
|
||||
|
||||
// Java objects that have been passed to Go. refnum -> Ref
|
||||
// The Ref obj field is non-null.
|
||||
// This map pins Java objects so they don't get GCed while the
|
||||
// only reference to them is held by Go code.
|
||||
private SparseArray<Ref> javaObjs = new SparseArray<Ref>();
|
||||
|
||||
// inc increments the reference count to a Go object.
|
||||
synchronized void inc(int refnum) {
|
||||
if (refnum > 0) {
|
||||
return; // we don't count java objects
|
||||
}
|
||||
int count = goObjs.get(refnum);
|
||||
if (count == Integer.MAX_VALUE) {
|
||||
throw new RuntimeException("refnum " + refnum + " overflow");
|
||||
}
|
||||
goObjs.put(refnum, count+1);
|
||||
}
|
||||
|
||||
// dec decrements the reference count to a Go object.
|
||||
// If the count reaches zero, the Go reference tracker is informed.
|
||||
synchronized void dec(int refnum) {
|
||||
if (refnum > 0) {
|
||||
// Java objects are removed on request of Go.
|
||||
javaObjs.remove(refnum);
|
||||
return;
|
||||
}
|
||||
int count = goObjs.get(refnum);
|
||||
if (count == 0) {
|
||||
throw new RuntimeException("refnum " + refnum + " underflow");
|
||||
}
|
||||
count--;
|
||||
if (count <= 0) {
|
||||
goObjs.delete(refnum);
|
||||
Seq.destroyRef(refnum);
|
||||
} else {
|
||||
goObjs.put(refnum, count);
|
||||
}
|
||||
}
|
||||
|
||||
synchronized Ref createRef(Seq.Object o) {
|
||||
// TODO(crawshaw): use single Ref for null.
|
||||
if (next == Integer.MAX_VALUE) {
|
||||
throw new RuntimeException("createRef overflow for " + o);
|
||||
}
|
||||
int refnum = next++;
|
||||
Ref ref = new Ref(refnum, o);
|
||||
javaObjs.put(refnum, ref);
|
||||
return ref;
|
||||
}
|
||||
|
||||
// get returns an existing Ref to either a Java or Go object.
|
||||
// It may be the first time we have seen the Go object.
|
||||
synchronized Ref get(int refnum) {
|
||||
if (refnum > 0) {
|
||||
Ref ref = javaObjs.get(refnum);
|
||||
if (ref == null) {
|
||||
throw new RuntimeException("unknown java Ref: "+refnum);
|
||||
}
|
||||
return ref;
|
||||
}
|
||||
return new Ref(refnum, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user