Propoid util

Propoid-util offers convenience working with services and content.

Asynchronous tasks and their observers

TaskService offers an easy management of asynchronous tasks and their observers:

    public class FooService extends TaskService<FooObserver> {

      // must be public
      public class BarTask extends Task {
        private int current;
        private int max;

        // must be public, argument is optional
        public class BarTask(Intent intent) {
          max = intent.getIntExtra("max", 10);
        }

        // asynchronously executed
        protected void onExecute() {
          while (current < max) {
            // expensive calculation
            Thread.sleep(1000);

            current++;

            // initiate publish
            publish();
          }
        }

        // publish on main thread
        protected void onPublish(FooObserver observer) {
           observer.onBar(current);
        }
      }
    }

To let your activity observe tasks you just have to create a subclass of TaskObserver and subscribe it in onStart():

    FooObserver observer = new FooObserver() {
      // called on main thread
      public void onBar(int current) {
        mProgress.setProgress(current);
      } 
    };

    public void onCreate() {
      super.onCreate();

      observer.subscribe(context, FooService.class);
    }

A task can be started similar to starting a service. The utility method 'createIntent(Context,Class)' creates a suitable intent to let TaskService instantiate the correct task instance:

    Intent intent = FooService.createIntent(this, BarTask.class)
    intent.putExtra("max", 10);
    startService(intent);

Don't forget to unsubscribe the observer in onDestroy():

    public void onDestroy() {
      observer.unsubscribe()

      super.onDestroy();
    }

By default all Tasks are executed in parallel. But you can easily let your tasks include others:

    private class BarTask extends Task {
      public boolean includes(Task other) {
        if (other instanceof BarTask) {
           // skip redundant task
           return true;
        } else if (other instanceof BazTask) {
          // must be delayed until this task has finished
          delay(other);
          return true;
        }

        // unrelated, let it be scheduled in parallel
        return false; 
      }
    }

Preferences

Preference allows convenient typed access to a preference:

    Preference<Boolean> myBoolean = Preference.getBoolean(context, R.string.my_boolean);
    Preference<Integer> myInteger = Preference.getInteger(context, R.string.my_integer);

Thanks to the keys being declares in your strings.xml we have a build-time safe identification of preferences:

   <string name="my_boolean">my_boolean</string>
   <string name="my_integer">my_integer</string>

Most of the time (but not necessarily) you want the user to be able to change the preference:

    <CheckBoxPreference
        android:key="@string/my_boolean"
        android:title="@string/my_boolean_title"
        android:summary="@string/my_boolean_summary"
        android:defaultValue="true"
    />
    <EditTextPreference
        android:key="@string/my_integer"
        android:title="@string/my_integer_title"
        android:summary="@string/my_integer_summary"
        android:numeric="integer"
        android:defaultValue="10"
    />

Note that in the latter case - an EditTextPreference with numeric input - any entered String will automatically be converted to the requested type when accessed via Preference.