Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 104ef500 authored by Elliott Hughes's avatar Elliott Hughes Committed by Android (Google) Code Review
Browse files

Merge "Track API."

parents 78e51f36 0a4d4275

api/current.txt

+200 −0
Original line number Diff line number Diff line
@@ -48279,6 +48279,35 @@ package java.util.concurrent { 
    method public V replace(K, V);

  }













  public class ConcurrentLinkedDeque extends java.util.AbstractCollection implements java.util.Deque java.io.Serializable {













    ctor public ConcurrentLinkedDeque();













    ctor public ConcurrentLinkedDeque(java.util.Collection<? extends E>);













    method public void addFirst(E);













    method public void addLast(E);













    method public java.util.Iterator<E> descendingIterator();













    method public E element();













    method public E getFirst();













    method public E getLast();













    method public java.util.Iterator<E> iterator();













    method public boolean offer(E);













    method public boolean offerFirst(E);













    method public boolean offerLast(E);













    method public E peek();













    method public E peekFirst();













    method public E peekLast();













    method public E poll();













    method public E pollFirst();













    method public E pollLast();













    method public E pop();













    method public void push(E);













    method public E remove();













    method public E removeFirst();













    method public boolean removeFirstOccurrence(java.lang.Object);













    method public E removeLast();













    method public boolean removeLastOccurrence(java.lang.Object);













    method public int size();













  }



























  public class ConcurrentLinkedQueue extends java.util.AbstractQueue implements java.util.Queue java.io.Serializable {















    ctor public ConcurrentLinkedQueue();















    ctor public ConcurrentLinkedQueue(java.util.Collection<? extends E>);










@@ -48519,6 +48548,94 @@ package java.util.concurrent {













    method public static java.util.concurrent.ScheduledExecutorService unconfigurableScheduledExecutorService(java.util.concurrent.ScheduledExecutorService);















  }



























  public class ForkJoinPool extends java.util.concurrent.AbstractExecutorService {













    ctor public ForkJoinPool();













    ctor public ForkJoinPool(int);













    ctor public ForkJoinPool(int, java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory, java.lang.Thread.UncaughtExceptionHandler, boolean);













    method public boolean awaitQuiescence(long, java.util.concurrent.TimeUnit);













    method public boolean awaitTermination(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException;













    method protected int drainTasksTo(java.util.Collection<? super java.util.concurrent.ForkJoinTask<?>>);













    method public void execute(java.util.concurrent.ForkJoinTask<?>);













    method public void execute(java.lang.Runnable);













    method public int getActiveThreadCount();













    method public boolean getAsyncMode();













    method public java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory getFactory();













    method public int getParallelism();













    method public int getPoolSize();













    method public int getQueuedSubmissionCount();













    method public long getQueuedTaskCount();













    method public int getRunningThreadCount();













    method public long getStealCount();













    method public java.lang.Thread.UncaughtExceptionHandler getUncaughtExceptionHandler();













    method public boolean hasQueuedSubmissions();













    method public T invoke(java.util.concurrent.ForkJoinTask<T>);













    method public boolean isQuiescent();













    method public boolean isShutdown();













    method public boolean isTerminated();













    method public boolean isTerminating();













    method public static void managedBlock(java.util.concurrent.ForkJoinPool.ManagedBlocker) throws java.lang.InterruptedException;













    method protected java.util.concurrent.ForkJoinTask<?> pollSubmission();













    method public void shutdown();













    method public java.util.List<java.lang.Runnable> shutdownNow();













    method public java.util.concurrent.ForkJoinTask<T> submit(java.util.concurrent.ForkJoinTask<T>);













    field public static final java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory;













  }

























  public static abstract interface ForkJoinPool.ForkJoinWorkerThreadFactory {













    method public abstract java.util.concurrent.ForkJoinWorkerThread newThread(java.util.concurrent.ForkJoinPool);













  }

























  public static abstract interface ForkJoinPool.ManagedBlocker {













    method public abstract boolean block() throws java.lang.InterruptedException;













    method public abstract boolean isReleasable();













  }

























  public abstract class ForkJoinTask implements java.util.concurrent.Future java.io.Serializable {













    ctor public ForkJoinTask();













    method public static java.util.concurrent.ForkJoinTask<?> adapt(java.lang.Runnable);













    method public static java.util.concurrent.ForkJoinTask<T> adapt(java.lang.Runnable, T);













    method public static java.util.concurrent.ForkJoinTask<T> adapt(java.util.concurrent.Callable<? extends T>);













    method public boolean cancel(boolean);













    method public void complete(V);













    method public void completeExceptionally(java.lang.Throwable);













    method protected abstract boolean exec();













    method public final java.util.concurrent.ForkJoinTask<V> fork();













    method public final V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException;













    method public final V get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException;













    method public final java.lang.Throwable getException();













    method public static java.util.concurrent.ForkJoinPool getPool();













    method public static int getQueuedTaskCount();













    method public abstract V getRawResult();













    method public static int getSurplusQueuedTaskCount();













    method public static void helpQuiesce();













    method public static boolean inForkJoinPool();













    method public final V invoke();













    method public static void invokeAll(java.util.concurrent.ForkJoinTask<?>, java.util.concurrent.ForkJoinTask<?>);













    method public static void invokeAll(java.util.concurrent.ForkJoinTask<?>...);













    method public static java.util.Collection<T> invokeAll(java.util.Collection<T>);













    method public final boolean isCancelled();













    method public final boolean isCompletedAbnormally();













    method public final boolean isCompletedNormally();













    method public final boolean isDone();













    method public final V join();













    method protected static java.util.concurrent.ForkJoinTask<?> peekNextLocalTask();













    method protected static java.util.concurrent.ForkJoinTask<?> pollNextLocalTask();













    method protected static java.util.concurrent.ForkJoinTask<?> pollTask();













    method public final void quietlyInvoke();













    method public final void quietlyJoin();













    method public void reinitialize();













    method protected abstract void setRawResult(V);













    method public boolean tryUnfork();













  }

























  public class ForkJoinWorkerThread extends java.lang.Thread {













    ctor protected ForkJoinWorkerThread(java.util.concurrent.ForkJoinPool);













    method public java.util.concurrent.ForkJoinPool getPool();













    method public int getPoolIndex();













    method protected void onStart();













    method protected void onTermination(java.lang.Throwable);













  }



























  public abstract interface Future {















    method public abstract boolean cancel(boolean);















    method public abstract V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException;










@@ -48603,6 +48720,52 @@ package java.util.concurrent {













    method public E take() throws java.lang.InterruptedException;















  }



























  public class LinkedTransferQueue extends java.util.AbstractQueue implements java.io.Serializable java.util.concurrent.TransferQueue {













    ctor public LinkedTransferQueue();













    ctor public LinkedTransferQueue(java.util.Collection<? extends E>);













    method public int drainTo(java.util.Collection<? super E>);













    method public int drainTo(java.util.Collection<? super E>, int);













    method public int getWaitingConsumerCount();













    method public boolean hasWaitingConsumer();













    method public java.util.Iterator<E> iterator();













    method public boolean offer(E, long, java.util.concurrent.TimeUnit);













    method public boolean offer(E);













    method public E peek();













    method public E poll(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException;













    method public E poll();













    method public void put(E);













    method public int remainingCapacity();













    method public int size();













    method public E take() throws java.lang.InterruptedException;













    method public void transfer(E) throws java.lang.InterruptedException;













    method public boolean tryTransfer(E);













    method public boolean tryTransfer(E, long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException;













  }

























  public class Phaser {













    ctor public Phaser();













    ctor public Phaser(int);













    ctor public Phaser(java.util.concurrent.Phaser);













    ctor public Phaser(java.util.concurrent.Phaser, int);













    method public int arrive();













    method public int arriveAndAwaitAdvance();













    method public int arriveAndDeregister();













    method public int awaitAdvance(int);













    method public int awaitAdvanceInterruptibly(int) throws java.lang.InterruptedException;













    method public int awaitAdvanceInterruptibly(int, long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException, java.util.concurrent.TimeoutException;













    method public int bulkRegister(int);













    method public void forceTermination();













    method public int getArrivedParties();













    method public java.util.concurrent.Phaser getParent();













    method public final int getPhase();













    method public int getRegisteredParties();













    method public java.util.concurrent.Phaser getRoot();













    method public int getUnarrivedParties();













    method public boolean isTerminated();













    method protected boolean onAdvance(int, int);













    method public int register();













  }



























  public class PriorityBlockingQueue extends java.util.AbstractQueue implements java.util.concurrent.BlockingQueue java.io.Serializable {















    ctor public PriorityBlockingQueue();















    ctor public PriorityBlockingQueue(int);









@@ -48623,6 +48786,22 @@ package java.util.concurrent {













    method public E take() throws java.lang.InterruptedException;















  }



























  public abstract class RecursiveAction extends java.util.concurrent.ForkJoinTask {













    ctor public RecursiveAction();













    method protected abstract void compute();













    method protected final boolean exec();













    method public final java.lang.Void getRawResult();













    method protected final void setRawResult(java.lang.Void);













  }

























  public abstract class RecursiveTask extends java.util.concurrent.ForkJoinTask {













    ctor public RecursiveTask();













    method protected abstract V compute();













    method protected final boolean exec();













    method public final V getRawResult();













    method protected final void setRawResult(V);













  }



























  public class RejectedExecutionException extends java.lang.RuntimeException {















    ctor public RejectedExecutionException();















    ctor public RejectedExecutionException(java.lang.String);










@@ -48661,12 +48840,14 @@ package java.util.concurrent {













    method protected java.util.concurrent.RunnableScheduledFuture<V> decorateTask(java.util.concurrent.Callable<V>, java.util.concurrent.RunnableScheduledFuture<V>);















    method public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy();















    method public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy();













    method public boolean getRemoveOnCancelPolicy();















    method public java.util.concurrent.ScheduledFuture<?> schedule(java.lang.Runnable, long, java.util.concurrent.TimeUnit);















    method public java.util.concurrent.ScheduledFuture<V> schedule(java.util.concurrent.Callable<V>, long, java.util.concurrent.TimeUnit);















    method public java.util.concurrent.ScheduledFuture<?> scheduleAtFixedRate(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit);















    method public java.util.concurrent.ScheduledFuture<?> scheduleWithFixedDelay(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit);















    method public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean);















    method public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean);













    method public void setRemoveOnCancelPolicy(boolean);















  }





























  public class Semaphore implements java.io.Serializable {










@@ -48712,6 +48893,15 @@ package java.util.concurrent {













    method public abstract java.lang.Thread newThread(java.lang.Runnable);















  }



























  public class ThreadLocalRandom extends java.util.Random {













    method public static java.util.concurrent.ThreadLocalRandom current();













    method public double nextDouble(double);













    method public double nextDouble(double, double);













    method public int nextInt(int, int);













    method public long nextLong(long);













    method public long nextLong(long, long);













  }



























  public class ThreadPoolExecutor extends java.util.concurrent.AbstractExecutorService {















    ctor public ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue<java.lang.Runnable>);















    ctor public ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue<java.lang.Runnable>, java.util.concurrent.ThreadFactory);










@@ -48799,6 +48989,14 @@ package java.util.concurrent {













    ctor public TimeoutException(java.lang.String);















  }



























  public abstract interface TransferQueue implements java.util.concurrent.BlockingQueue {













    method public abstract int getWaitingConsumerCount();













    method public abstract boolean hasWaitingConsumer();













    method public abstract void transfer(E) throws java.lang.InterruptedException;













    method public abstract boolean tryTransfer(E);













    method public abstract boolean tryTransfer(E, long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException;













  }



























}





























package java.util.concurrent.atomic {










@@ -49008,6 +49206,7 @@ package java.util.concurrent.locks {













    method public final int getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject);















    method public final java.util.Collection<java.lang.Thread> getWaitingThreads(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject);















    method public final boolean hasContended();













    method public final boolean hasQueuedPredecessors();















    method public final boolean hasQueuedThreads();















    method public final boolean hasWaiters(java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject);















    method protected boolean isHeldExclusively();










@@ -49054,6 +49253,7 @@ package java.util.concurrent.locks {













    method public final int getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject);















    method public final java.util.Collection<java.lang.Thread> getWaitingThreads(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject);















    method public final boolean hasContended();













    method public final boolean hasQueuedPredecessors();















    method public final boolean hasQueuedThreads();















    method public final boolean hasWaiters(java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject);















    method protected boolean isHeldExclusively();