Android Open Source - crtaci Seq






From Project

Back to project page crtaci.

License

The source code is released under:

GNU General Public License

If you think the Android project crtaci listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.

Java Source Code

package go;
/* w ww  .j  av a 2s  .c  o m*/
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);
    }
  }
}




Java Source Code List

com.github.gen2brain.crtaci.activities.CartoonsActivity.java
com.github.gen2brain.crtaci.activities.CharactersActivity.java
com.github.gen2brain.crtaci.activities.PlayerActivity.java
com.github.gen2brain.crtaci.entities.Cartoon.java
com.github.gen2brain.crtaci.entities.Character.java
com.github.gen2brain.crtaci.fragments.CartoonsFragment.java
com.github.gen2brain.crtaci.fragments.CharactersFragment.java
com.github.gen2brain.crtaci.utils.Connectivity.java
com.github.gen2brain.crtaci.utils.Update.java
com.github.gen2brain.crtaci.utils.Utils.java
com.github.gen2brain.crtaci.utils.VideoEnabledWebChromeClient.java
com.github.gen2brain.crtaci.utils.VideoEnabledWebView.java
go.Go.java
go.Seq.java
go.main.Main.java