|
|
@@ -1,263 +0,0 @@
|
|
|
-package go;
|
|
|
-
|
|
|
-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.
|
|
|
-
|
|
|
- // TEMP FIX -- this can remove references for valid objects
|
|
|
- // The problem appears to be that references are added when
|
|
|
- // a Java object is created (only once) but removed after the
|
|
|
- // object is passed to Go and then no longer referenced by Go
|
|
|
- // (via runtime.SetFinalizer: https://github.com/golang/mobile/blob/b2e453e1cda693a5a97d5c97cc9f3016a64b7dfa/bind/seq/buffer.go#L110)
|
|
|
- // But if the same Java object is passed to Go again, then it
|
|
|
- // will no longer be in javaObjs (after Go GCs the Ref)!
|
|
|
- // This temp fix keeps eternal references to Java objects,
|
|
|
- // which is ok for us since we only have one. Another workaround
|
|
|
- // would be to create temporary proxy objects, once per call into 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);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|