Màn hình đăng nhập hiển thị progressdialog và cho phép thay đổi hướng màn hình

Question

Xin chào, tôi đang cố triển khai màn hình đăng nhập hiển thị hộp thoại tiến trình và cho phép điện thoại xoay.

Tôi muốn hỏi cách tốt nhất để làm điều đó (IntentService, AsyncTask, Dịch vụ) và cho phép điện thoại xoay vòng là gì?

Tôi đã đọc rất nhiều câu trả lời cho biết những điều khác nhau bằng cách sử dụng một đoạn trống với AsyncTask, v.v.

Answer 1

Bạn đã thử cách này chưa?

<activity 
    android:name=".MainActivity" 
    android:configChanges="orientation|screenSize"> 
</activity> 

Cách này hoạt động sẽ không được tạo lại. nhưng bạn có thể phát hiện hướng màn hình bằng cách sử dụng

Answer 2

Thử thêm thuộc tính này android:configChanges="orientation" vào phần tử Hoạt động của bạn trong tệp AndroidManifest.xml. hiển thị ProgressDialog trong phương thức onPreExecute của đối tượng AsyncTask và hủy ProgressDialog trong phương thức onPostExecute. Phương thức doInBackground đang chạy Khi thay đổi hướng.

Answer 3

Bạn có thể làm một cái gì đó như thế trong manifest để cho phép quay:

<application 
     android:allowBackup="true" 
     android:configChanges="orientation|keyboardHidden|screenSize" 
     android:icon="@mipmap/ic_launcher" 
     android:label="@string/app_name" 
     android:theme="@style/AppTheme"> 
     <activity 
      android:name=".activities.MainActivity" 
      android:configChanges="orientation|keyboardHidden|screenSize" 
      android:label="@string/app_name"/> 

Sau đó, bạn có thể nắm bắt được luân chuyển với snipet này bên trong hoạt động của bạn:

@Override 
    public void onConfigurationChanged(Configuration newConfig) { 
     super.onConfigurationChanged(newConfig); 
     Log.v(this.getClass().getName(), "onConfigurationChanged()"); 
    } 

Để làm một AsyncTask với hộp thoại tiến bộ , snipet này sẽ cung cấp cho bạn một ligth:

private ProgressDialog pDialog; 

private class MyAsync extends AsyncTask<String, Void, String> { 
    Activity context; 

    public MyAsync (Activity context) { 
     this.context = context; 
    } 

    @Override 
    protected void onPreExecute(){ 
     super.onPreExecute(); 
     pdia = new ProgressDialog(context); 
     pdia.setMessage("Loading..."); 
     pdia.show();  
    } 
    @Override 
    protected String doInBackground(String... urls) { 
     ... 
     //do your login scheme 
     ... 
     //context.methods() 
     return "ok"; 
    } 
    @Override 
    protected void onPostExecute(String result) { 
     pDialog.dismiss(); 
     if(result!=null && result.equals("ok")){ 
      //login was successfully done 
     } else { 
      //login has failed 
     } 
    } 
} 

Và để sử dụng asynctas này k bạn shoud gọi:

new MyAsync(this).execute(null, null , null); 

Bằng cách này this là hoạt động/phân đoạn của bạn.

Answer 4

Tham khảo http://www.androiddesignpatterns.com/2013/04/retaining-objects-across-config-changes.html để có câu trả lời chi tiết.

Về cơ bản, bạn có thể sử dụng phân đoạn với setRetainInstance được đặt thành true bên trong LoginActivity của bạn để nó không bị hủy khi hoạt động được tạo lại trong khi thay đổi hướng.

Sample Code:

public class AsyncFragment extends Fragment { 

    private LoginTask mTask; 
    private AsyncTaskListener mListener; 
    private static final String TAG = "AsyncFragment"; 
    private boolean isTaskRunning = false; 
    private ProgressDialog mProgressDialog; 
    FrameLayout mLayout; 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setRetainInstance(true); 
     mTask = new LoginTask(); 
     mTask.execute(); 
    } 

    @Nullable 
    @Override 
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { 
     mLayout = new FrameLayout(getActivity()); 
     mLayout.setLayoutParams(new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)); 
     if(isTaskRunning) { 
      mProgressDialog = new ProgressDialog(getActivity()); 
      mProgressDialog.show(); 
     } 
     return mLayout; 
    } 

    @Override 
    public void onDestroyView() { 
     if(mProgressDialog != null && mProgressDialog.isShowing()) { 
      mProgressDialog.dismiss(); 
      mProgressDialog = null; 
     } 
     super.onDestroyView(); 
    } 

    @Override 
    public void onAttach(Context context) { 
     super.onAttach(context); 
     try { 
      mListener = (AsyncTaskListener) context; 
     } catch (ClassCastException e) { 
      Log.d(TAG, "Class not instance of AsyncTaskListener"); 
     } 
    } 

    @Override 
    public void onDetach() { 
     mListener = null; 
     super.onDetach(); 
    } 

    private class LoginTask extends AsyncTask<Void,Integer,Void> { 

     @Override 
     protected Void doInBackground(Void... params) { 
      if(mListener != null) { 
       mListener.onBackground(); 
      } 
      SystemClock.sleep(10000); 
      return null; 
     } 

     @Override 
     protected void onPreExecute() { 
      isTaskRunning = true; 
      mProgressDialog = new ProgressDialog(getActivity()); 
      mProgressDialog.show(); 
      if(mListener != null) { 
       mListener.onPreExecute(); 
      } 
      super.onPreExecute(); 
     } 

     @Override 
     protected void onPostExecute(Void aVoid) { 
      super.onPostExecute(aVoid); 
      if(mListener != null) { 
       mListener.onPostExecute(); 
      } 
      isTaskRunning = false; 
      if(mProgressDialog != null && mProgressDialog.isShowing()) { 
       mProgressDialog.dismiss(); 
       mProgressDialog = null; 
      } 
     } 

     @Override 
     protected void onProgressUpdate(Integer... values) { 
      super.onProgressUpdate(values); 
      if(mListener != null) { 
       mListener.onProgressUpdate(values[0]); 
      } 
     } 

     @Override 
     protected void onCancelled() { 
      super.onCancelled(); 
      if(mListener != null) { 
       mListener.onCancelled(); 
      } 
     } 
    } 

    //Listener to notify for async task callbacks 
    public interface AsyncTaskListener{ 
     void onPreExecute(); 
     void onPostExecute(); 
     void onCancelled(); 
     void onBackground(); 
     void onProgressUpdate(int progress); 
    } 
} 

LoginActivity

public class MainActivity extends AppCompatActivity implements AsyncFragment.AsyncTaskListener{ 

    private static final String FRAGMENT_TAG = "asyncFragment"; 
    private static final String TAG = "MainActivity"; 

    private AsyncFragment mAsyncFragment; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     FragmentManager fm = getSupportFragmentManager(); 
     mAsyncFragment = (AsyncFragment) fm.findFragmentByTag(FRAGMENT_TAG); 
     if (mAsyncFragment == null) { //fragment was retained during orientation change 
      mAsyncFragment = new AsyncFragment(); 
      fm.beginTransaction().add(mAsyncFragment, FRAGMENT_TAG).commit(); 
     } 

    } 

    @Override 
    public void onPreExecute() { 
     Log.d(TAG, "onPreExecute: "); 
    } 

    @Override 
    public void onPostExecute() { 
     Log.d(TAG, "onPostExecute: "); 
    } 

    @Override 
    public void onCancelled() { 
     Log.d(TAG, "onCancelled: ");  
    } 

    @Override 
    public void onBackground() { 
     Log.d(TAG, "onBackground: "); 
    } 

    @Override 
    public void onProgressUpdate(int progress) { 
     Log.d(TAG, "onProgressUpdate: "); 
    }