प्रगति पर प्रगति और AsyncTaskLoader को लागू करना

Habr पर एक अच्छा लेख पहले ही प्रकाशित हो चुका है जो ProgressDialog और AsyncTask के संयुक्त उपयोग का वर्णन करता है, यहाँ मैं वर्णन करूँगा कि समान कार्यक्षमता कैसे प्राप्त करें लेकिन टुकड़ों पर, अधिक सटीक रूप से DialogFragment और AsyncTaskLader का उपयोग करके।

तो लक्ष्य:

• प्रोग्रेसडिओलॉग को प्रदर्शित करें जब एक लंबा ऑपरेशन करते हैं, जिसमें से संदेश पाठ कार्य की प्रगति के बारे में सूचित कर सकता है;
• अनुप्रयोग द्वारा अभिविन्यास बदलने के लिए सही समर्थन।

कार्यान्वयन
1. हम एसिंक्रोनस प्रक्रिया से संदेश को AbstractTaskLoader अमूर्त वर्ग, AsyncTaskLoader के उत्तराधिकारी से भेज देंगे:

public abstract class AbstractTaskLoader extends AsyncTaskLoader<Object> { //type of the published values public static int MSGCODE_PROGRESS = 1; public static int MSGCODE_MESSAGE = 2; private Handler handler; protected AbstractTaskLoader(Context context) { super(context); } protected void setHandler(Handler handler){ this.handler = handler; } /** * Helper to publish string value * @param value */ protected void publishMessage(String value){ if(handler!=null){ Bundle data = new Bundle(); data.putString("message", value); /* Creating a message */ Message msg = new Message(); msg.setData(data); msg.what = MSGCODE_MESSAGE; /* Sending the message */ handler.sendMessage(msg); } } … 

इसके अलावा, हमारा वर्ग जो कुछ लंबा ऑपरेशन करता है, पहले से ही इस अमूर्त वर्ग से विरासत में मिला है और कार्य करने की प्रक्रिया के बारे में सूचित कर सकता है:

 @Override public Object loadInBackground() { … publishMessage(result); … } 

2. अगला कदम स्क्रीन ओरिएंटेशन को बदलते समय हमारे लोडर के सही शुरुआत / पुनः आरंभ के लिए एक संदेश प्रदर्शित करने वाला प्रोग्रेसडायलॉग का कार्यान्वयन और जिम्मेदार है। कक्षा में लोडर और संवाद के लिए कॉलबैक हैंडलर भी शामिल हैं:

 public abstract class AbstractTaskProgressDialogFragment extends DialogFragment implements LoaderCallbacks<Object>, OnCancelListener { private ProgressDialog progressDialog; private final AbstractTaskLoader loader; protected abstract void onLoadComplete(Object data); protected abstract void onCancelLoad(); protected AbstractTaskProgressDialogFragment(AbstractTaskLoader loader,String message){ loader.setHandler(handler); this.loader = loader; Bundle args = new Bundle(); args.putString("message", message); setArguments(args); } @Override public ProgressDialog onCreateDialog(Bundle savedInstanceState) { String message = getArguments().getString("message"); progressDialog = new ProgressDialog(getActivity()); progressDialog.setMessage(message); progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); progressDialog.setOnCancelListener(this); progressDialog.show(); return progressDialog; } private final Handler handler = new Handler() { public void handleMessage(Message msg) { if(msg.what == AbstractTaskLoader.MSGCODE_MESSAGE){ String message = AbstractTaskLoader.getMessageValue(msg); if(message!=null){ //update progress bar message if(progressDialog!=null){ progressDialog.setMessage(message); } } } } }; ... 

वर्ग को भी सार बना दिया जाता है, हालांकि, यह आवश्यक नहीं है, कम से कम बाध्यकारी को लागू करने के लिए विकल्पों में से एक है। केवल काम के परिणाम महत्वपूर्ण हैं:
onLoadComplete (ऑब्जेक्ट डेटा);
onCancelLoad ();
और उत्तराधिकारी में इन विधियों का कार्यान्वयन (मैंने इंटरफ़ेस के माध्यम से किया था, नीचे देखें)।

यहां, लोडर को कंस्ट्रक्टर को पास किया जाता है, जिसे निष्पादित किया जाएगा और परीक्षण संदेश स्टार्टअप पर तुरंत प्रदर्शित होगा। हैंडलर का उपयोग प्रगति के बारे में लोडर से सूचना संदेश भेजने के लिए किया जाता है। OnCreateDialog में, हमारा संवाद बनाएं और प्रदर्शित करें।

अगला, हमें यह इंगित करने की आवश्यकता है कि स्क्रीन ओरिएंटेशन बदलते समय, यह टुकड़ा अपनी स्थिति को बरकरार रखता है। यह setRainainInstance (ट्रू) विधि का उपयोग करके किया जाता है, इस मामले में onDestroy तब नहीं बुलाया जाएगा जब स्क्रीन ओरिएंटेशन को बदल दिया जाए, और डायलॉग बंद नहीं होगा।

 @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); setRetainInstance(true); // Prepare the loader. Either re-connect with an existing one, // or start a new one. getLoaderManager().initLoader(0, loader.getArguments(), this); } 

हम onActivityCreated विधि को फिर से परिभाषित करते हैं, जिसमें हम अपने लोडर को पहली बार शुरू करते हैं या मौजूदा एक से जोड़ते हैं (जब स्क्रीन ओरिएंटेशन बदलते हैं)।

एक छोटा विषयांतर:
SetRetainInstance पद्धति डायलॉगफ्रेग्मेंट के लिए " संगतता-लाइब्रेरी " के साथ सही तरीके से काम नहीं करती है, अर्थात ऑनस्ट्रेस्ट विधि को अभी भी कहा जाता है, हालांकि यह नहीं होना चाहिए। लेकिन एक समाधान है, हमारे संवाद में हम जोड़ते हैं:

 @Override public void onDestroyView() { if (getDialog() != null && getRetainInstance()) getDialog().setOnDismissListener(null); super.onDestroyView(); } 

यहाँ विवरण।

लोडर स्टार्टअप और शटडाउन प्रसंस्करण:

 @Override public Loader<Object> onCreateLoader(int id, Bundle args) { loader.forceLoad(); return loader; } @Override public void onLoadFinished(Loader<Object> loader, Object data) { onLoadComplete(data); ((AbstractTaskLoader) loader).setHandler(null); hideDialog(); } 

उपयोगकर्ता रद्द करने की प्रक्रिया - "बैक" बटन दबाकर:

 @Override public void onCancel(DialogInterface dialog) { super.onCancel(dialog); loader.cancelLoad(); //base metod loader.setCanseled(true); //custom flag onCancelLoad(); //do not invoke dismiss for this dialog } 

3. बेस फ्रेम बनाया गया है, अब हम इसका उपयोग करते हैं।

पूरा होने की सूचना के लिए एक इंटरफ़ेस बनाएँ:

 public interface ITaskLoaderListener { void onLoadFinished(Object data); void onCancelLoad(); } 

हम बनाया अमूर्त वर्ग के आधार पर हमारे ProgressDialog के कार्यान्वयन को बनाते हैं:

 public class TaskProgressDialogFragment extends AbstractTaskProgressDialogFragment { private ITaskLoaderListener taskLoaderListener; private final Handler handler = new Handler(); protected TaskProgressDialogFragment(AbstractTaskLoader loader, String message) { super(loader, message); } protected void setTaskLoaderListener(ITaskLoaderListener taskLoaderListener){ this.taskLoaderListener = taskLoaderListener; } @Override protected void onLoadComplete(final Object data) { if(taskLoaderListener!=null){ taskLoaderListener.onLoadFinished(data); } } @Override protected void onCancelLoad() { if (taskLoaderListener != null) { taskLoaderListener.onCancelLoad(); } } ... 

और लोडर को आसानी से बनाने और चलाने के लिए बिल्डर:

 public static class Builder { FragmentActivity fa; AbstractTaskLoader loader; ITaskLoaderListener taskLoaderListener; Boolean cancelable; String progressMsg; public Builder(FragmentActivity fa, AbstractTaskLoader loader, String progressMsg) { this.fa = fa; this.loader = loader; this.progressMsg = progressMsg; } public Builder setTaskLoaderListener( ITaskLoaderListener taskLoaderListener) { this.taskLoaderListener = taskLoaderListener; return this; } public Builder setCancelable(Boolean cancelable) { this.cancelable = cancelable; return this; } public void show() { String TAG_FRAGMENT = UUID.randomUUID().toString(); // remove prev if exists FragmentManager fm = fa.getSupportFragmentManager(); FragmentTransaction ft = fm.beginTransaction(); Fragment prev = fm.findFragmentByTag(TAG_FRAGMENT); if (prev != null) { ft.remove(prev); } // create dlg fragment TaskProgressDialogFragment fragment = new TaskProgressDialogFragment( loader, progressMsg); fragment.setTaskLoaderListener(taskLoaderListener); fragment.setCancelable(cancelable); Bundle args = new Bundle(); args.putString("message", progressMsg); fragment.setArguments(args); // show the dialog. fragment.show(ft, TAG_FRAGMENT); } } 

4. अंत में, यह हमारा लोडर है। उदाहरण के लिए, यह सिर्फ ProgreesDialog-e में संदेश परीक्षण को हर पल अपडेट करता है:

 public class SampleTask extends AbstractTaskLoader { @Override public Object loadInBackground() { String result = ""; for(int i=0; i<10;i++){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } result = "Wait: " + String.valueOf(i); publishMessage(result); if(isCanselled()){ break; } Log.d(TAG, result); } return result; } 

सुविधाजनक शुरुआत के लिए एक स्थिर विधि जोड़ें:

 public static void execute(FragmentActivity fa, ITaskLoaderListener taskLoaderListener) { SampleTask loader = new SampleTask(fa); new TaskProgressDialogFragment.Builder(fa, loader, "Wait...") .setCancelable(true) .setTaskLoaderListener(taskLoaderListener) .show(); } 

5. चुनौती

 public class SampleActivity extends FragmentActivity implements ITaskLoaderListener{ … SampleTask.execute(this, this); @Override public void onCancelLoad() { Log.d(TAG, "task canceled"); } @Override public void onLoadFinished(Object data) { if(data!=null && data instanceof String){ Log.d(TAG, "task result: " + data); } } 

उदाहरण के स्रोत कोड को डाउनलोड करें , रचनात्मक आलोचना और टिप्पणियों का स्वागत है।

सूत्रों का कहना है:
1. एवेलिना व्राबी ब्लॉग, लेख 'एंड्रॉइड फ्रेगमेंट्स, सेविंग स्टेट एंड स्क्रीन रोटेशन'
2. ढेर अतिप्रवाह