Android 已弃用 Tasks.call - 替换

Question

在我的 android 应用程序中，我可以选择将数据库备份到 Google Drive。为此，我正在使用 DriveServiceHelper 类，但我刚刚注意到，在 Android 11 中，Task.call 已被弃用。

      public Task<FileList> queryFiles() {
    return Tasks.call(mExecutor, () ->
            mDriveService.files().list().setSpaces("drive").execute());
}

然后我从我的 BackupActivity 调用 queryFiles 从 backup 方法：

  public void backup(View v) {
        driveServiceHelper.queryFiles()
                .addOnSuccessListener(fileList -> {
                  // another code
                })
                .addOnFailureListener(e -> showMsgSnack(getString(R.string.uploaderror)));

我没有找到任何解决方案来避免该类的完全返工。

我尝试了什么：

我尝试用 runnable 替换，也可以调用，但它不起作用，因为预期返回的是 Task，而不是 Filelist。

我也尝试使用TaskCompletionSource:

public Task<FileList> queryFiles(int delay) throws IOException, ExecutionException, InterruptedException {

    new Thread(
            new Runnable() {

                @Override
                public void run() {
                    TaskCompletionSource<FileList> taskCompletionSource = new TaskCompletionSource<>();

                    FileList result = null;
                    try {
                        result = mDriveService.files().list().setSpaces("drive").execute();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    FileList finalResult = result;
                    new Handler().postDelayed(() -> taskCompletionSource.setResult(finalResult), delay);

                    return taskCompletionSource.getTask();
                }
            }).start();
    
}

但返回不是来自 void 类型的方法。

Answer 1

我的意思是这样的：

 public Task<FileList> queryFiles(int delay) throws IOException {
        Task<FileList> retVal;
        final FutureValue<Task<FileList>> future = new FutureValue<>();

        // now run this bit in a runnable
        /*
        TaskCompletionSource<FileList> taskCompletionSource = new TaskCompletionSource<>();
    
        FileList result = mDriveService.files().list().setSpaces("drive").execute();
        new Handler().postDelayed(() -> taskCompletionSource.setResult(result), delay);
    
        return taskCompletionSource.getTask();
        */

        new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                            TaskCompletionSource<FileList> taskCompletionSource = new TaskCompletionSource<>();
    
                            FileList result = mDriveService.files().list().setSpaces("drive").execute();
                            new Handler().postDelayed(() -> taskCompletionSource.setResult(result), delay);
    
                            // and we replace the return statement with something else
                            // return taskCompletionSource.getTask();
                            future.set(taskCompletionSource.getTask());
                   }
        }).start();

       // And block (wait) for future to finish so we can return it, deadlocking the main thread...

//      return future.get();

      //FIXME do either this
//      retVal = future.get();

      // For bonus points, we'll do a timed wait instead -- OR THIS
        try {
            retVal = future.get(30, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            future.cancel(true);
            Log.d(LOG_TAG, "Exception "+e+" happened!", e);
        } catch (InterruptedException | ExecutionException e) {
            Log.d(LOG_TAG, "Exception "+e+" happened!", e);
        }

    return retVal;
}

这应该会让你走上解决问题的道路。

但是，如果使用 Task<> 的唯一原因是您可以向这些方法添加成功/失败侦听器 - 我强烈建议您想出更好的方法，实际运行在后台线程而不是您的线程上'重新召唤他们。

FutureValue 类：

/**
 * Implementation of {@link Future}, allowing waiting for value to be set (from another thread).
 * Use {@link #set(Object)} to set value, {@link #get()} or {@link #get(long, TimeUnit)} to retrieve
 * value.
 * TODO: tests
 *
 * @param <T> type of awaited value
 */
public class FutureValue<T> implements Future<T> {
    private static final String LOGTAG = "FutureValue";
    private static final long NANOS_IN_MILLI = TimeUnit.MILLISECONDS.toNanos(1);

    private volatile T value;
    private volatile boolean isDone = false;
    private volatile boolean isCanceled = false;

    /**
     * Sets value awaited by this future.
     *
     * @param value value
     */
    public synchronized void set(T value) {
        this.value = value;
        isDone = true;
        notifyAll();
    }

    /** {@inheritDoc} */
    @Override
    public synchronized boolean cancel(boolean mayInterruptIfRunning) {
        isCanceled = true;
        notifyAll();
        return !isDone;
    }

    /** {@inheritDoc} */
    @Override
    public boolean isCancelled() {
        return isCanceled;
    }

    /** {@inheritDoc} */
    @Override
    public boolean isDone() {
        return isDone;
    }

    /** {@inheritDoc} */
    @Override
    public synchronized T get() {
        while (!isDone) {
            if (isCanceled) {
                return value;
            }
            try {
                wait();
            } catch (InterruptedException ignored) {
                Log.w(LOGTAG, "We're just gonna ignore this exception: " + ignored, ignored);
            }
        }

        return value;
    }

    /** {@inheritDoc} */
    @Override
    public synchronized T get(long timeout, @NonNull TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {

        final long targetTime = System.nanoTime() + unit.toNanos(timeout);

        while (!isDone && !isCanceled) {
            try {
                final long waitTimeNanos = targetTime - System.nanoTime();
                if (waitTimeNanos <= 0) {
                    throw new TimeoutException();
                }
                wait(waitTimeNanos / NANOS_IN_MILLI, (int) (waitTimeNanos % NANOS_IN_MILLI));
            } catch (InterruptedException ignored) {
                Log.w(LOGTAG, "We're just gonna ignore this exception: " + ignored, ignored);
            }
        }

        return value;
    }

}

Answer 2

好的，经过数小时的测试，我尝试了这个解决方案，现在这似乎有效：（使用 executorService，并且在 Handler 中需要一个 Looper。）

public Task<FileList> queryFiles() {
    final TaskCompletionSource<FileList> tcs = new TaskCompletionSource<FileList>();
    ExecutorService service = Executors.newFixedThreadPool(1);

    service.execute(
            new Runnable() {
                @Override
                public void run() {

                    FileList result = null;
                    try {
                        result = mDriveService.files().list().setSpaces("drive").execute();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    FileList finalResult = result;
                    new Handler(Looper.getMainLooper()).postDelayed(() -> tcs.setResult(finalResult), 1000);

                }
            });

    return tcs.getTask();

    }