인스턴스 상태를 저장하는 방법이나 화면 회전 중에 파괴되는 내 활동을 처리하는 방법에 대해 많이 읽었습니다.
많은 가능성이있는 것 같지만 AsyncTask의 결과를 검색하는 데 가장 적합한 방법을 찾지 못했습니다.
나는 단순히 다시 시작 isFinishing()되고 활동 의 메소드를 호출하는 AsyncTasks가 있으며 활동이 완료되면 아무것도 업데이트하지 않습니다.
문제는 실패하거나 성공할 수있는 웹 서비스에 대한 요청을 수행하는 하나의 작업이 있고 작업을 다시 시작하면 사용자에게 재정적 손실이 발생한다는 것입니다.
이 문제를 어떻게 해결 하시겠습니까? 가능한 솔루션의 장단점은 무엇입니까?
답변:
내 첫 번째 제안은 화면 회전 (기본 동작)에서 실제로 활동을 재설정해야하는지 확인하는 것입니다. 회전에 문제가있을 때마다이 속성을 <activity>AndroidManifest.xml의 내 태그에 추가 했으며 괜찮 았습니다.
android:configChanges="keyboardHidden|orientation"
이상해 보이지만 그것이 당신의 onConfigurationChanged()방법에 전달하는 것은 당신이 하나를 제공하지 않으면 레이아웃을 다시 측정하는 것 외에는 아무것도하지 않습니다. 이는 대부분의 시간 동안 회전을 처리하는 완벽하게 적절한 방법 인 것 같습니다 .
code.google.com/p/shelvesAsyncTask 에서 s 및 방향 변경을 처리하는 방법을 확인할 수 있습니다 . 이를 수행하는 방법에는 여러 가지가 있습니다.이 앱에서 선택한 방법은 현재 실행중인 작업을 취소하고 상태를 저장하고 새 작업 이 생성 될 때 저장된 상태로 새 작업을 시작하는 것입니다. 쉽게 할 수 있고 잘 작동하며 사용자가 앱을 떠날 때 작업을 중지하는 데 도움이됩니다.Activity
당신은 또한 onRetainNonConfigurationInstance()당신 AsyncTask을 새로운 것에 전달할 수 있습니다 Activity( Activity이 방법으로 이전을 유출하지 않도록 조심하십시오 .)
이것은 내가 안드로이드와 관련하여 본 가장 흥미로운 질문입니다 !!! 사실 저는 지난 몇 달 동안 이미 해결책을 찾고있었습니다. 아직 해결되지 않았습니다.
조심하세요.
android:configChanges="keyboardHidden|orientation"
물건으로는 충분하지 않습니다.
AsyncTask가 실행되는 동안 사용자가 전화를받는 경우를 고려하십시오. 요청이 이미 서버에서 처리 중이므로 AsyncTask가 응답을 기다리고 있습니다. 이 순간에는 전화 앱이 포 그라운드로 들어 왔기 때문에 앱이 백그라운드로 전환됩니다. OS는 백그라운드에 있기 때문에 활동을 종료 할 수 있습니다.
Android에서 제공하는 Singleton에서 현재 AsyncTask에 대한 참조를 항상 유지하지 않는 이유는 무엇입니까?
태스크가 시작될 때마다 PreExecute 또는 빌더에서 다음을 정의합니다.
((Application) getApplication()).setCurrentTask(asyncTask);
완료 될 때마다 null로 설정합니다.
이렇게하면 항상 특정 논리에 적합한 onCreate 또는 onResume과 같은 작업을 수행 할 수있는 참조가 있습니다.
this.asyncTaskReference = ((Application) getApplication()).getCurrentTask();
null이면 현재 실행중인 항목이 없음을 알 수 있습니다!
:-)
Application인스턴스에는 자체 수명주기가 있습니다. OS에 의해 종료 될 수도 있으므로이 솔루션은 재현하기 어려운 버그를 유발할 수 있습니다.
가장 적절한 방법은 조각을 사용하여 회전 동안 비동기 작업의 인스턴스를 유지하는 것입니다.
다음은이 기술을 앱에 쉽게 통합 할 수있는 매우 간단한 예제에 대한 링크입니다.
Android : 구성 변경이있는 백그라운드 처리 / 비동기 작업
백그라운드 프로세스 중에 비동기 작동 상태를 유지하려면 조각의 도움을받을 수 있습니다.
다음 단계를 참조하십시오.
1 단계 : 헤더없는 조각을 만들고 백그라운드 작업을 말하고 그 안에있는 개인 비동기 작업 클래스를 추가합니다.
2 단계 (선택적 단계) : 활동 위에 로딩 커서를 놓으려면 아래 코드를 사용하십시오.
3 단계 : 기본 활동에서 1 단계에서 정의한 BackgroundTaskCallbacks 인터페이스를 구현합니다.
class BackgroundTask extends Fragment {
public BackgroundTask() {
}
// Add a static interface
static interface BackgroundTaskCallbacks {
void onPreExecute();
void onCancelled();
void onPostExecute();
void doInBackground();
}
private BackgroundTaskCallbacks callbacks;
private PerformAsyncOpeation asyncOperation;
private boolean isRunning;
private final String TAG = BackgroundTask.class.getSimpleName();
/**
* Start the async operation.
*/
public void start() {
Log.d(TAG, "********* BACKGROUND TASK START OPERATION ENTER *********");
if (!isRunning) {
asyncOperation = new PerformAsyncOpeation();
asyncOperation.execute();
isRunning = true;
}
Log.d(TAG, "********* BACKGROUND TASK START OPERATION EXIT *********");
}
/**
* Cancel the background task.
*/
public void cancel() {
Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION ENTER *********");
if (isRunning) {
asyncOperation.cancel(false);
asyncOperation = null;
isRunning = false;
}
Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION EXIT *********");
}
/**
* Returns the current state of the background task.
*/
public boolean isRunning() {
return isRunning;
}
/**
* Android passes us a reference to the newly created Activity by calling
* this method after each configuration change.
*/
public void onAttach(Activity activity) {
Log.d(TAG, "********* BACKGROUND TASK ON ATTACH ENTER *********");
super.onAttach(activity);
if (!(activity instanceof BackgroundTaskCallbacks)) {
throw new IllegalStateException(
"Activity must implement the LoginCallbacks interface.");
}
// Hold a reference to the parent Activity so we can report back the
// task's
// current progress and results.
callbacks = (BackgroundTaskCallbacks) activity;
Log.d(TAG, "********* BACKGROUND TASK ON ATTACH EXIT *********");
}
public void onCreate(Bundle savedInstanceState) {
Log.d(TAG, "********* BACKGROUND TASK ON CREATE ENTER *********");
super.onCreate(savedInstanceState);
// Retain this fragment across configuration changes.
setRetainInstance(true);
Log.d(TAG, "********* BACKGROUND TASK ON CREATE EXIT *********");
}
public void onDetach() {
super.onDetach();
callbacks = null;
}
private class PerformAsyncOpeation extends AsyncTask<Void, Void, Void> {
protected void onPreExecute() {
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE ENTER *********");
if (callbacks != null) {
callbacks.onPreExecute();
}
isRunning = true;
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE EXIT *********");
}
protected Void doInBackground(Void... params) {
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND ENTER *********");
if (callbacks != null) {
callbacks.doInBackground();
}
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND EXIT *********");
return null;
}
protected void onCancelled() {
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL ENTER *********");
if (callbacks != null) {
callbacks.onCancelled();
}
isRunning = false;
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL EXIT *********");
}
protected void onPostExecute(Void ignore) {
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE ENTER *********");
if (callbacks != null) {
callbacks.onPostExecute();
}
isRunning = false;
Log.d(TAG,
"********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE EXIT *********");
}
}
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
setRetainInstance(true);
}
public void onStart() {
super.onStart();
}
public void onResume() {
super.onResume();
}
public void onPause() {
super.onPause();
}
public void onStop() {
super.onStop();
}
public class ProgressIndicator extends Dialog {
public ProgressIndicator(Context context, int theme) {
super(context, theme);
}
private ProgressBar progressBar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.progress_indicator);
this.setCancelable(false);
progressBar = (ProgressBar) findViewById(R.id.progressBar);
progressBar.getIndeterminateDrawable().setColorFilter(R.color.DarkBlue, android.graphics.PorterDuff.Mode.SCREEN);
}
@Override
public void show() {
super.show();
}
@Override
public void dismiss() {
super.dismiss();
}
@Override
public void cancel() {
super.cancel();
}
public class MyActivity extends FragmentActivity implements BackgroundTaskCallbacks,{
private static final String KEY_CURRENT_PROGRESS = "current_progress";
ProgressIndicator progressIndicator = null;
private final static String TAG = MyActivity.class.getSimpleName();
private BackgroundTask task = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(//"set your layout here");
initialize your views and widget here .............
FragmentManager fm = getSupportFragmentManager();
task = (BackgroundTask) fm.findFragmentByTag("login");
// If the Fragment is non-null, then it is currently being
// retained across a configuration change.
if (task == null) {
task = new BackgroundTask();
fm.beginTransaction().add(task, "login").commit();
}
// Restore saved state
if (savedInstanceState != null) {
Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON CREATE :: "
+ task.isRunning());
if (task.isRunning()) {
progressIndicator = new ProgressIndicator(this,
R.style.TransparentDialog);
if (progressIndicator != null) {
progressIndicator.show();
}
}
}
}
@Override
protected void onPause() {
// TODO Auto-generated method stub
super.onPause();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
// save the current state of your operation here by saying this
super.onSaveInstanceState(outState);
Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON SAVE INSTANCE :: "
+ task.isRunning());
outState.putBoolean(KEY_CURRENT_PROGRESS, task.isRunning());
if (progressIndicator != null) {
progressIndicator.dismiss();
progressIndicator.cancel();
}
progressIndicator = null;
}
private void performOperation() {
if (!task.isRunning() && progressIndicator == null) {
progressIndicator = new ProgressIndicator(this,
R.style.TransparentDialog);
progressIndicator.show();
}
if (task.isRunning()) {
task.cancel();
} else {
task.start();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (progressIndicator != null) {
progressIndicator.dismiss();
progressIndicator.cancel();
}
progressIndicator = null;
}
@Override
public void onPreExecute() {
Log.i(TAG, "CALLING ON PRE EXECUTE");
}
@Override
public void onCancelled() {
Log.i(TAG, "CALLING ON CANCELLED");
if (progressIndicator != null) {
progressIndicator.dismiss();
progressIndicator.cancel();
}
public void onPostExecute() {
Log.i(TAG, "CALLING ON POST EXECUTE");
if (progressIndicator != null) {
progressIndicator.dismiss();
progressIndicator.cancel();
progressIndicator = null;
}
}
@Override
public void doInBackground() {
// put your code here for background operation
}
}
고려해야 할 한 가지는 AsyncTask의 결과를 작업을 시작한 활동에만 사용할 수 있는지 여부입니다. 그렇다면 Romain Guy의 대답 이 가장 좋습니다. 이 응용 프로그램의 다른 활동에 사용할 수 있어야합니다 경우에 onPostExecute당신은 사용할 수 있습니다 LocalBroadcastManager.
LocalBroadcastManager.getInstance(getContext()).sendBroadcast(new Intent("finished"));
또한 활동이 일시 중지 된 동안 브로드 캐스트가 전송 될 때 활동이 상황을 올바르게 처리하는지 확인해야합니다.
이 게시물을보십시오 . 이 게시물에는 AsyncTask가 장기 실행 작업을 수행하고 하나의 샘플 애플리케이션에서 화면 회전이 모두 발생할 때 메모리 누수가 포함됩니다. 샘플 앱은 Source forge 에서 사용할 수 있습니다.
내 솔루션.
제 경우에는 동일한 컨텍스트를 가진 AsyncTasks 체인이 있습니다. 활동은 첫 번째 활동에만 액세스했습니다. 실행중인 작업을 취소하려면 다음을 수행했습니다.
public final class TaskLoader {
private static AsyncTask task;
private TaskLoader() {
throw new UnsupportedOperationException();
}
public static void setTask(AsyncTask task) {
TaskLoader.task = task;
}
public static void cancel() {
TaskLoader.task.cancel(true);
}
}
작업 doInBackground():
protected Void doInBackground(Params... params) {
TaskLoader.setTask(this);
....
}
활동 onStop()또는 onPause():
protected void onStop() {
super.onStop();
TaskLoader.cancel();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
final AddTask task = mAddTask;
if (task != null && task.getStatus() != UserTask.Status.FINISHED) {
final String bookId = task.getBookId();
task.cancel(true);
if (bookId != null) {
outState.putBoolean(STATE_ADD_IN_PROGRESS, true);
outState.putString(STATE_ADD_BOOK, bookId);
}
mAddTask = null;
}
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
if (savedInstanceState.getBoolean(STATE_ADD_IN_PROGRESS)) {
final String id = savedInstanceState.getString(STATE_ADD_BOOK);
if (!BooksManager.bookExists(getContentResolver(), id)) {
mAddTask = (AddTask) new AddTask().execute(id);
}
}
}
android : configChanges = "keyboardHidden | orientation | screenSize"를 추가 할 수도 있습니다.
당신의 매니페스트 예제에 도움이되기를 바랍니다.
<application
android:name=".AppController"
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:configChanges="keyboardHidden|orientation|screenSize"
android:theme="@style/AppTheme">
setRetainInstance(true)찾을 수도 있습니다 .