Android Pro Recipes
3 likes1,485 views
The document discusses various Android application development concepts, focusing on app lifecycle management, AsyncTask implementation, and frameworks like Otto and Dagger. It provides examples of creating and managing background tasks, handling UI updates, and using dependency injection. The emphasis is on managing tasks effectively while preserving application performance and user experience.
Android Pro Recipes
- 1. Android Pro Recipes Gabriel Dogaru gdogaru@gmail.com Iasi-JUG, December 11, 2013
- 2. Topics ¡ñ App Lifecycle ¡ñ AsyncTask problems ¡ñ Some frameworks ¡ð Otto ¡ð Tape ¡ð Dagger
- 3. Credits ¡ñ Android App Anatomy - Eric Burke ¡ñ Concurrency in Android - G. Blake Meike ¡ñ infoq.com
- 4. Where it all starts - lifecyle Install Uninstall App runs forever
- 5. Process 1 ¡¡. App runs forever Pn
- 7. Activity
- 10. RIP ¡ñ ¡ñ ¡ñ Fragment Fragment Activity Terminates application process Managed by oom_adj RIP Static Variables Activity Process 1 Activity ¡¡. App runs forever Pn
- 12. RIP ¡ñ Garbage collection Fragment Fragment Activity Activity Process 1 Activity ¡¡. App runs forever Pn
- 15. Why Care?
- 16. What about that background task? AsyncTask ¡ñ enables proper and easy use of the UI thread. ¡ñ should ideally be used for short operations (a few seconds at the most.)
- 17. AsyncTask private class SomeTask extends AsyncTask<URL, Integer, Long> { protected Long doInBackground(URL... urls) { //do some stuff return result; } protected void onProgressUpdate(Integer... progress) { //update progress if needed } protected void onPreExecute(Long result) { //before } protected void onPostExecute(Long result) { //after } }
- 20. Some AsyncTask public static class BgTask extends AsyncTask<String, Void, String> { private final Activity act; public BgTask(Activity act) { this.act = act; } @Override protected String doInBackground(String... args) { // ¡ doesn't matter what goes here... } @Override protected void onPostExecute(String args) { act.onTaskComplete(args) } }
- 21. Some AsyncTask 2 public void initButton(Button button) { button.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { new AsyncTask<Void, Void, Void>() { @Override protected Void doInBackground(Void... args) { // ¡ doesn't matter what goes here... } @Override protected void onPostExecute(String args) { onTaskComplete(args) } } .execute(); } }); }
- 22. What to do? ¡ñ Weak Reference ¡ñ Persistent ¡ñ Cancellable ¡ñ Independent
- 23. Weak Reference ¡ñ Just make all references to the Activity weak
- 24. Weak Reference ¡ñ Just make all references to the Activity weak DON¡¯T
- 25. Persistent AsyncTask ¡ñ Best effort completion ¡ñ Hold a reference to the task in static or Application ¡ñ Manage references to Activities (onPause, onResume) ¡ñ Preserving ¡°single delivery¡± AsyncTask semantics requires some fancy state management
- 26. Persistent AsyncTask public class SafeHeavyweightAsyncTaskActivity extends Activity implements HeavywightSafeTask.CompletionHandler{ static HeavywightSafeTask task; @Override public void onTaskComplete(String result) { task = null; ((TextView) findViewById(R.id.display)).setText(result); } @Override protected void onResume() { super.onResume(); if (null != task) { task.registerCompletionHdlr(this); }} @Override protected void onPause() { super.onStop(); if (null != task) { task.registerCompletionHdlr(null); }} }
- 27. Persistent AsyncTask public final class HeavywightSafeTask extends AsyncTask<String, Void, String> { public static interface CompletionHandler { void onTaskComplete(String result); } private enum State { EXECUTING, FINISHED, NOTIFIED; } private State state = State.EXECUTING; private CompletionHandler handler; private String result; public void registerCompletionHdlr(HeavywightSafeTask.CompletionHandler hdlr) { handler = hdlr; notifyHdlr(); } @Override protected String doInBackground(String... params) { // . . . } @Override protected void onPostExecute(String res) { result = res; state = State.FINISHED; notifyHdlr(); } // . . .
- 28. Persistent AsyncTask // . . . private void notifyHdlr() { if (null == handler) { return; } switch (state) { case EXECUTING: break; case FINISHED: state = State.NOTIFIED; handler.onTaskComplete(result); break; case NOTIFIED: throw new IllegalStateException( "Attempt to register after notification"); } } }
- 29. Cancellable ¡ñ Addresses tasks that can be abandoned ¡ñ Implement onCancel ¡ñ Call it from onPause
- 30. Cancellable AsyncTask public class SafeLightweightAsyncTaskActivity extends Activity implements LightweightSafeTask.CompletionHandler { LightweightSafeTask task; // . . . /** * @see android.app.Activity#onPause() */ @Override protected void onPause() { super.onPause(); if (null != task) { task.cancel(true); task = null; } } // . . .
- 31. Independent ¡ñ Use AsyncTask to submit tasks to a data layer ¡°If you respect users, persist tasksto disk.¡± - Jesse Wilson
- 32. Tape is a collection of queue-related classes for Android and Java by Square, Inc.
- 34. How to update the ui? background task Activity Activity Activity Process 1 ¡¡. App runs forever Pn
- 35. How to update the ui? background task Activity Activity Activity Process 1 ¡¡. App runs forever Pn
- 36. Events !!!!! LocalBroadcastManager ¡ñ standard Android way ¡ñ we all read about it
- 37. Publish Intent intent = new Intent(BroadcastIds.LOCATION_UPDATED_ACTION); intent.putExtra(BroadcastIds.CURRENT_LOCATION_KEY ,getCurrentLocation()); LocalBroadcastManager.getInstance( getActivity()).sendBroadcast(intent);
- 38. Subscribing // MyActivity BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive( Context context, Intent intent) { Location location = (Location) intent.getParcelableExtra( BroadcastIds.CURRENT_LOCATION_KEY); showLocation(location); } }; //¡.
- 39. Subscribe ¡. IntentFilter locationFilter = new IntentFilter( BroadcastIds.LOCATION_UPDATED_ACTION); @Override public void onResume() { super.onResume(); LocalBroadcastManager.getInstance(getActivity()) .registerReceiver(receiver, locationFilter); } @Override public void onPause() { super.onPause(); LocalBroadcastManager.getInstance(getActivity()) .unregisterReceiver(receiver); }
- 40. Really?
- 42. Registration public class BaseFragment extends Fragment { @Inject Bus bus; @Override public void onResume() { super.onResume(); bus.register(this); } @Override public void onPause() { super.onPause(); bus.unregister(this); } }
- 43. Subscribing @Subscribe public void onLocationUpdated(Location l) { showLocation(l); }
- 44. Publishing bus.post(getCurrentLocation()); //the first time @Produce public UserImage produceUserImage() { return cachedUserImage; }
- 46. Otto API Summary ¡ñ ¡ñ ¡ñ ¡ñ ¡ñ register(), unregister(), post() @Subscribe, @Produce Thread confinement Compile time errors Easy to test!
- 47. Dependency Injection to the Rescue Dagger ¡ñ compile time injection ¡ñ based on Google Guice
- 48. @Inject import javax.inject.Inject; // JSR-330 public class PublishFragment extends BaseFragment { @Inject Bus bus; @Inject LocationManager locationManager; ¡ }
- 49. Constructor Injection public class AccountUpdater { private final Bus bus; private final AccountService accounts; @Inject public AccountUpdater(Bus bus, AccountService accounts) { this.bus = bus; this.accounts = accounts; } }
- 50. Module @Module(entryPoints = { MainActivity.class }) public static class ExampleModule { Context appContext; public ExampleModule(Context appContext) { this.appContext = appContext; } @Provides @Singleton Bus provideBus() { return new Bus(); } }}
- 51. Integration 2 public class ExampleApp extends Application { private ObjectGraph objectGraph; @Override public void onCreate() { super.onCreate(); objectGraph = ObjectGraph.create(new ExampleModule(this)); } public ObjectGraph objectGraph() { return objectGraph; } public <T> T get(Class<T> clazz) { return objectGraph.get(clazz); }
- 52. Integration 3 public class MainActivity extends Activity { @Inject Bus bus; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ((ExampleApp) getApplication()).objectGraph().inject(this); } }
- 53. Conclusions ¡ñ Managing the lifecycle can be tricky ¡ñ Always think of the corner cases ¡ñ Find the right tool to do the job and make your life easier ¡ñ Event architecture can help
- 54. Further studdy Tape ¡ú square.github.com/tape/ Otto ¡ú square.github.com/otto/ Dagger ¡ú square.github.com/dagger