95cd85ad38
Also, reveal the illusion that we're restoring state in Files and Downloads.
Also, define a "PairedTask" class that guards calls to task methods
with checks against isDestroyed. This also let us make all of the tasks
static, so we get much narrower scope and tasks can even be moved to
their own files.
Change-Id: I6a9e8706e1ab1d1f43301e73dd9858a115a6baaf
78 lines
2.2 KiB
Java
78 lines
2.2 KiB
Java
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.documentsui;
|
|
|
|
import android.app.Activity;
|
|
import android.os.AsyncTask;
|
|
|
|
/**
|
|
* An {@link AsyncTask} that guards work with checks that a paired {@link Activity}
|
|
* is still alive. Instances of this class make no progress.
|
|
*
|
|
* <p>Use this type of task for greater safety when executing tasks that might complete
|
|
* after an Activity is destroyed.
|
|
*
|
|
* <p>Also useful as tasks can be static, limiting scope, but still have access to
|
|
* the owning class (by way the A template and the mActivity field).
|
|
*
|
|
* @template Owner Activity type.
|
|
* @template Input input type
|
|
* @template Output output type
|
|
*/
|
|
abstract class PairedTask<Owner extends Activity, Input, Output>
|
|
extends AsyncTask<Input, Void, Output> {
|
|
|
|
protected final Owner mOwner;
|
|
|
|
public PairedTask(Owner owner) {
|
|
mOwner = owner;
|
|
}
|
|
|
|
/** Called prior to run being executed. Analogous to {@link AsyncTask#onPreExecute} */
|
|
void prepare() {}
|
|
|
|
/** Analogous to {@link AsyncTask#doInBackground} */
|
|
abstract Output run(Input... input);
|
|
|
|
/** Analogous to {@link AsyncTask#onPostExecute} */
|
|
abstract void finish(Output output);
|
|
|
|
@Override
|
|
final protected void onPreExecute() {
|
|
if (mOwner.isDestroyed()) {
|
|
return;
|
|
}
|
|
prepare();
|
|
}
|
|
|
|
@Override
|
|
final protected Output doInBackground(Input... input) {
|
|
if (mOwner.isDestroyed()) {
|
|
return null;
|
|
}
|
|
return run(input);
|
|
}
|
|
|
|
@Override
|
|
final protected void onPostExecute(Output result) {
|
|
if (mOwner.isDestroyed()) {
|
|
return;
|
|
}
|
|
finish(result);
|
|
}
|
|
}
|