applied new loader infrastructure to all loading code

2026-10-17 01:31:01 +00:00 · 2013-07-29 18:15:29 +02:00
1 parent f8e34aeffe
commit b798e4a3b0
@@ -8,19 +8,24 @@ public abstract class DataManager implements ReadonlyDataManager {

    public static ReadonlyDataManager create(Context context) {
        if (AppConstants.IS_DATA_OFFLINE) {
-            return new OfflineDataManager(InMemoryDataStore.INSTANCE);
+            return new OfflineDataManager(context, InMemoryDataStore.INSTANCE);
        }
        return new OnlineDataManager(context, InMemoryDataStore.INSTANCE);
    }

+    protected Context context;
    protected DataStore dataStore;

-    public DataManager(DataStore dataStore) {
+    public DataManager(Context context, DataStore dataStore) {
        this.dataStore = dataStore;
    }

    public DataStore getDataStore() {
        return dataStore;
    }
+    
+    public Context getContext() {
+        return context;
+    }

 }
@@ -7,6 +7,10 @@ import java.util.Collection;
 import java.util.Date;
 import java.util.List;
 import java.util.UUID;
+import java.util.concurrent.Callable;
+
+import android.app.LoaderManager.LoaderCallbacks;
+import android.content.Context;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseArea;
@@ -31,6 +35,8 @@ import com.sap.sailing.domain.racelog.RaceLogEventFactory;
 import com.sap.sailing.domain.racelog.impl.RaceLogEventFactoryImpl;
 import com.sap.sailing.domain.racelog.impl.RaceLogImpl;
 import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
+import com.sap.sailing.racecommittee.app.data.loaders.DataLoaderResult;
+import com.sap.sailing.racecommittee.app.data.loaders.ImmediateDataLoaderCallbacks;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;
 import com.sap.sailing.racecommittee.app.domain.impl.ManagedRaceIdentifierImpl;
 import com.sap.sailing.racecommittee.app.domain.impl.ManagedRaceImpl;
@@ -39,8 +45,8 @@ public class OfflineDataManager extends DataManager {

    private static boolean isInitialized = false;

-    public OfflineDataManager(DataStore dataStore) {
-        super(dataStore);
+    public OfflineDataManager(Context context, DataStore dataStore) {
+        super(context, dataStore);

        if (!isInitialized) {
            isInitialized = true;
@@ -143,34 +149,71 @@ public class OfflineDataManager extends DataManager {
        dataStore.addMark(m2);
        dataStore.addMark(m3);
    }
-
-    public void loadEvents(LoadClient<Collection<EventBase>> client) {
-        client.onLoadSucceded(dataStore.getEvents());
-    }
-
-    public void loadCourseAreas(Serializable parentEventId,
-            LoadClient<Collection<CourseArea>> client) {
-        client.onLoadSucceded(dataStore.getCourseAreas(dataStore.getEvent(parentEventId)));
-    }
-
-    public void loadRaces(Serializable courseAreaId,
-            LoadClient<Collection<ManagedRace>> client) {
-        client.onLoadSucceded(dataStore.getRaces());
+    
+    @Override
+    public LoaderCallbacks<DataLoaderResult<Collection<EventBase>>> getEventsLoader(
+            LoadClient<Collection<EventBase>> callback) {
+        return new ImmediateDataLoaderCallbacks<Collection<EventBase>>(callback, new Callable<Collection<EventBase>>() {
+            @Override
+            public Collection<EventBase> call() throws Exception {
+                return dataStore.getEvents();
+            }
+        });
    }

    @Override
-    public void loadMarks(ManagedRace managedRace, LoadClient<Collection<Mark>> client) {
-        client.onLoadSucceded(dataStore.getMarks());
+    public LoaderCallbacks<DataLoaderResult<Collection<CourseArea>>> getCourseAreasLoader(final Serializable parentEventId,
+            LoadClient<Collection<CourseArea>> callback) {
+        return new ImmediateDataLoaderCallbacks<Collection<CourseArea>>(callback, new Callable<Collection<CourseArea>>() {
+            @Override
+            public Collection<CourseArea> call() throws Exception {
+                return dataStore.getCourseAreas(dataStore.getEvent(parentEventId));
+            }
+        });
    }

    @Override
-    public void loadCourse(ManagedRace managedRace, LoadClient<CourseBase> client) {
-        client.onLoadSucceded(managedRace.getCourseOnServer());
+    public LoaderCallbacks<DataLoaderResult<Collection<ManagedRace>>> getRacesLoader(Serializable courseAreaId,
+            LoadClient<Collection<ManagedRace>> callback) {
+        return new ImmediateDataLoaderCallbacks<Collection<ManagedRace>>(callback, new Callable<Collection<ManagedRace>>() {
+            @Override
+            public Collection<ManagedRace> call() throws Exception {
+                return dataStore.getRaces();
+            }
+        });
    }

    @Override
-    public void loadCompetitors(ManagedRace managedRace, LoadClient<Collection<Competitor>> client) {
-        client.onLoadSucceded((Collection<Competitor>) managedRace.getCompetitors());
+    public LoaderCallbacks<DataLoaderResult<Collection<Mark>>> getMarksLoader(ManagedRace managedRace,
+            LoadClient<Collection<Mark>> callback) {
+        return new ImmediateDataLoaderCallbacks<Collection<Mark>>(callback, new Callable<Collection<Mark>>() {
+            @Override
+            public Collection<Mark> call() throws Exception {
+                return dataStore.getMarks();
+            }
+        });
+    }
+
+    @Override
+    public LoaderCallbacks<DataLoaderResult<CourseBase>> getCourseLoader(final ManagedRace managedRace,
+            LoadClient<CourseBase> callback) {
+        return new ImmediateDataLoaderCallbacks<CourseBase>(callback, new Callable<CourseBase>() {
+            @Override
+            public CourseBase call() throws Exception {
+                return managedRace.getCourseOnServer();
+            }
+        });
+    }
+
+    @Override
+    public LoaderCallbacks<DataLoaderResult<Collection<Competitor>>> getCompetitorsLoader(final ManagedRace managedRace,
+            LoadClient<Collection<Competitor>> callback) {
+        return new ImmediateDataLoaderCallbacks<Collection<Competitor>>(callback, new Callable<Collection<Competitor>>() {
+            @Override
+            public Collection<Competitor> call() throws Exception {
+                return managedRace.getCompetitors();
+            }
+        });
    }

 }
@@ -1,8 +1,6 @@
 package com.sap.sailing.racecommittee.app.data;

-import java.io.IOException;
 import java.io.Serializable;
-import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URLEncoder;
 import java.util.Collection;
@@ -28,10 +26,10 @@ import com.sap.sailing.racecommittee.app.data.handlers.DataHandler;
 import com.sap.sailing.racecommittee.app.data.handlers.EventsDataHandler;
 import com.sap.sailing.racecommittee.app.data.handlers.ManagedRacesDataHandler;
 import com.sap.sailing.racecommittee.app.data.handlers.MarksDataHandler;
-import com.sap.sailing.racecommittee.app.data.loaders.DataLoader;
 import com.sap.sailing.racecommittee.app.data.loaders.DataLoaderCallbacks;
+import com.sap.sailing.racecommittee.app.data.loaders.DataLoaderCallbacks.LoaderCreator;
 import com.sap.sailing.racecommittee.app.data.loaders.DataLoaderResult;
-import com.sap.sailing.racecommittee.app.data.loaders.ImmediateDataLoader;
+import com.sap.sailing.racecommittee.app.data.loaders.ImmediateDataLoaderCallbacks;
 import com.sap.sailing.racecommittee.app.data.loaders.OnlineDataLoader;
 import com.sap.sailing.racecommittee.app.data.parsers.CompetitorsDataParser;
 import com.sap.sailing.racecommittee.app.data.parsers.CourseDataParser;
@@ -69,24 +67,8 @@ import com.sap.sailing.server.gateway.deserialization.racelog.impl.RaceLogEventD
 public class OnlineDataManager extends DataManager {
    private static final String TAG = OnlineDataManager.class.getName();

-    private Context context;
-
    OnlineDataManager(Context context, DataStore dataStore) {
-        super(dataStore);
-        this.context = context;
-    }
-
-    public Context getContext() {
-        return context;
-    }
-
-    @Override
-    public void loadEvents(LoadClient<Collection<EventBase>> client) {
-        if (dataStore.getEvents().isEmpty()) {
-            reloadEvents(client);
-        } else {
-            client.onLoadSucceded(dataStore.getEvents());
-        }
+        super(context, dataStore);
    }

    public void addEvents(Collection<EventBase> events) {
@@ -95,38 +77,42 @@ public class OnlineDataManager extends DataManager {
        }
    }

-    //@Override
+    public void addRaces(Collection<ManagedRace> data) {
+        for (ManagedRace race : data) {
+            dataStore.addRace(race);
+        }
+    }
+
+    public void addMarks(Collection<Mark> marks) {
+        for (Mark mark : marks) {
+            dataStore.addMark(mark);
+        }
+    }
+
+    @Override
    public LoaderCallbacks<DataLoaderResult<Collection<EventBase>>> getEventsLoader(
            LoadClient<Collection<EventBase>> callback) {
-        return new DataLoaderCallbacks<Collection<EventBase>>(callback) {
-
+        return new DataLoaderCallbacks<Collection<EventBase>>(callback, new LoaderCreator<Collection<EventBase>>() {
            @Override
-            protected Loader<DataLoaderResult<Collection<EventBase>>> createLoader(int id, Bundle args)
-                    throws Exception {
+            public Loader<DataLoaderResult<Collection<EventBase>>> create(int id, Bundle args) throws Exception {
                SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
                DataParser<Collection<EventBase>> parser = new EventsDataParser(new EventBaseJsonDeserializer(
                        new VenueJsonDeserializer(new CourseAreaJsonDeserializer(domainFactory))));
                DataHandler<Collection<EventBase>> handler = new EventsDataHandler(OnlineDataManager.this);
-                
+
                ExLog.i(TAG, "getEventsLoader created new loader...");

                return new OnlineDataLoader<Collection<EventBase>>(context, URI.create(AppPreferences
                        .getServerBaseURL(context) + "/sailingserver/events"), parser, handler);
            }
-
-        };
+        });
    }

-    //@Override
+    @Override
    public LoaderCallbacks<DataLoaderResult<Collection<CourseArea>>> getCourseAreasLoader(
            final Serializable parentEventId, LoadClient<Collection<CourseArea>> callback) {
-        return new DataLoaderCallbacks<Collection<CourseArea>>(callback) {
-
-            @Override
-            protected Loader<DataLoaderResult<Collection<CourseArea>>> createLoader(int id, Bundle args)
-                    throws Exception {
-                return new ImmediateDataLoader<Collection<CourseArea>>(context, new Callable<Collection<CourseArea>>() {
-
+        return new ImmediateDataLoaderCallbacks<Collection<CourseArea>>(callback,
+                new Callable<Collection<CourseArea>>() {
                    @Override
                    public Collection<CourseArea> call() throws Exception {
                        if (dataStore.hasEvent(parentEventId)) {
@@ -138,161 +124,107 @@ public class OnlineDataManager extends DataManager {
                        }
                    }
                });
+    }
+
+    @Override
+    public LoaderCallbacks<DataLoaderResult<Collection<ManagedRace>>> getRacesLoader(final Serializable courseAreaId,
+            LoadClient<Collection<ManagedRace>> callback) {
+        return new DataLoaderCallbacks<Collection<ManagedRace>>(callback, new LoaderCreator<Collection<ManagedRace>>() {
+            @Override
+            public Loader<DataLoaderResult<Collection<ManagedRace>>> create(int id, Bundle args) throws Exception {
+                SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
+                JsonDeserializer<BoatClass> boatClassDeserializer = new BoatClassJsonDeserializer(domainFactory);
+                DataParser<Collection<ManagedRace>> parser = new ManagedRacesDataParser(context,
+                        new RaceGroupDeserializer(boatClassDeserializer, new SeriesWithRowsDeserializer(
+                                new RaceRowDeserializer(new FleetDeserializer(new ColorDeserializer()),
+                                        new RaceCellDeserializer(new RaceLogDeserializer(
+                                                RaceLogEventDeserializer.create(domainFactory)))))));
+                DataHandler<Collection<ManagedRace>> handler = new ManagedRacesDataHandler(OnlineDataManager.this);
+
+                return new OnlineDataLoader<Collection<ManagedRace>>(context, URI.create(AppPreferences
+                        .getServerBaseURL(context)
+                        + "/sailingserver/rc/racegroups?courseArea="
+                        + courseAreaId.toString()), parser, handler);
            }
-        };
-    }
-
-    protected void reloadEvents(LoadClient<Collection<EventBase>> client) {
-        SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
-        DataParser<Collection<EventBase>> parser = new EventsDataParser(new EventBaseJsonDeserializer(
-                new VenueJsonDeserializer(new CourseAreaJsonDeserializer(domainFactory))));
-        DataHandler<Collection<EventBase>> handler = null;// new EventsDataHandler(this, client);
-
-        try {
-            new DataLoader<Collection<EventBase>>(context, URI.create(AppPreferences.getServerBaseURL(context)
-                    + "/sailingserver/events"), parser, handler).forceLoad();
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+        });
    }

    @Override
-    public void loadCourseAreas(final Serializable parentEventId, final LoadClient<Collection<CourseArea>> client) {
+    public LoaderCallbacks<DataLoaderResult<Collection<Mark>>> getMarksLoader(final ManagedRace managedRace,
+            LoadClient<Collection<Mark>> callback) {
+        return new DataLoaderCallbacks<Collection<Mark>>(callback, new LoaderCreator<Collection<Mark>>() {
+            @Override
+            public Loader<DataLoaderResult<Collection<Mark>>> create(int id, Bundle args) throws Exception {
+                SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
+                JsonDeserializer<Mark> markDeserializer = new MarkDeserializer(domainFactory);
+                DataParser<Collection<Mark>> parser = new MarksDataParser(markDeserializer);
+                DataHandler<Collection<Mark>> handler = new MarksDataHandler(OnlineDataManager.this);

-        if (dataStore.hasEvent(parentEventId)) {
-            EventBase event = dataStore.getEvent(parentEventId);
-            client.onLoadSucceded(dataStore.getCourseAreas(event));
-        } else {
-            reloadEvents(new LoadClient<Collection<EventBase>>() {
-                public void onLoadSucceded(Collection<EventBase> data) {
-                    if (dataStore.hasEvent(parentEventId)) {
-                        EventBase event = dataStore.getEvent(parentEventId);
-                        client.onLoadSucceded(dataStore.getCourseAreas(event));
-                    } else {
-                        client.onLoadFailed(new DataLoadingException(String.format(
-                                "There was no event object found for id %s.", parentEventId)));
-                    }
-                }
+                ManagedRaceIdentifier identifier = managedRace.getIdentifier();

-                public void onLoadFailed(Exception reason) {
-                    client.onLoadFailed(new DataLoadingException(
-                            String.format(
-                                    "There was no event object found for id %s. While reloading the events an error occured: %s",
-                                    parentEventId, reason), reason));
-                }
-            });
-        }
-    }
+                String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
+                String raceColumnName = URLEncoder.encode(identifier.getRaceName());
+                String fleetName = URLEncoder.encode(identifier.getFleet().getName());

-    public void addRaces(Collection<ManagedRace> data) {
-        for (ManagedRace race : data) {
-            dataStore.addRace(race);
-        }
+                return new OnlineDataLoader<Collection<Mark>>(context, URI.create(AppPreferences
+                        .getServerBaseURL(context)
+                        + "/sailingserver/rc/marks?leaderboard="
+                        + raceGroupName
+                        + "&raceColumn=" + raceColumnName + "&fleet=" + fleetName), parser, handler);
+            }
+        });
    }

    @Override
-    public void loadRaces(Serializable courseAreaId, LoadClient<Collection<ManagedRace>> client) {
-        if (!dataStore.hasCourseArea(courseAreaId)) {
-            client.onLoadFailed(new DataLoadingException(String.format("No course area found with id %s", courseAreaId)));
-            return;
-        }
-        SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
-        JsonDeserializer<BoatClass> boatClassDeserializer = new BoatClassJsonDeserializer(domainFactory);
-        DataParser<Collection<ManagedRace>> parser = new ManagedRacesDataParser(context, new RaceGroupDeserializer(
-                boatClassDeserializer, new SeriesWithRowsDeserializer(new RaceRowDeserializer(new FleetDeserializer(
-                        new ColorDeserializer()), new RaceCellDeserializer(new RaceLogDeserializer(
-                        RaceLogEventDeserializer.create(domainFactory)))))));
-        DataHandler<Collection<ManagedRace>> handler = new ManagedRacesDataHandler(this, client);
-        try {
-            new DataLoader<Collection<ManagedRace>>(context, URI.create(AppPreferences.getServerBaseURL(context)
-                    + "/sailingserver/rc/racegroups?courseArea=" + courseAreaId.toString()), parser, handler)
-                    .forceLoad();
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
+    public LoaderCallbacks<DataLoaderResult<CourseBase>> getCourseLoader(final ManagedRace managedRace,
+            LoadClient<CourseBase> callback) {
+        return new DataLoaderCallbacks<CourseBase>(callback, new LoaderCreator<CourseBase>() {
+            @Override
+            public Loader<DataLoaderResult<CourseBase>> create(int id, Bundle args) throws Exception {
+                SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
+                JsonDeserializer<CourseBase> courseBaseDeserializer = new CourseDataDeserializer(
+                        new WaypointDeserializer(new ControlPointDeserializer(new MarkDeserializer(domainFactory),
+                                new GateDeserializer(domainFactory, new MarkDeserializer(domainFactory)))));
+                DataParser<CourseBase> parser = new CourseDataParser(courseBaseDeserializer);
+                DataHandler<CourseBase> handler = new CourseDataHandler(OnlineDataManager.this, managedRace);

-    public void addMarks(Collection<Mark> marks) {
-        for (Mark mark : marks) {
-            dataStore.addMark(mark);
-        }
+                ManagedRaceIdentifier identifier = managedRace.getIdentifier();
+
+                String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
+                String raceColumnName = URLEncoder.encode(identifier.getRaceName());
+                String fleetName = URLEncoder.encode(identifier.getFleet().getName());
+
+                return new OnlineDataLoader<CourseBase>(context, URI.create(AppPreferences.getServerBaseURL(context)
+                        + "/sailingserver/rc/currentcourse?leaderboard=" + raceGroupName + "&raceColumn="
+                        + raceColumnName + "&fleet=" + fleetName), parser, handler);
+            }
+        });
    }

    @Override
-    public void loadMarks(ManagedRace managedRace, LoadClient<Collection<Mark>> client) {
-        SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
-        JsonDeserializer<Mark> markDeserializer = new MarkDeserializer(domainFactory);
-        DataParser<Collection<Mark>> parser = new MarksDataParser(markDeserializer);
-        DataHandler<Collection<Mark>> handler = new MarksDataHandler(this, client);
+    public LoaderCallbacks<DataLoaderResult<Collection<Competitor>>> getCompetitorsLoader(
+            final ManagedRace managedRace, LoadClient<Collection<Competitor>> callback) {
+        return new DataLoaderCallbacks<Collection<Competitor>>(callback, new LoaderCreator<Collection<Competitor>>() {
+            @Override
+            public Loader<DataLoaderResult<Collection<Competitor>>> create(int id, Bundle args) throws Exception {
+                SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
+                JsonDeserializer<Competitor> competitorDeserializer = new CompetitorDeserializer(domainFactory);
+                DataParser<Collection<Competitor>> parser = new CompetitorsDataParser(competitorDeserializer);
+                DataHandler<Collection<Competitor>> handler = new CompetitorsDataHandler(OnlineDataManager.this,
+                        managedRace);

-        ManagedRaceIdentifier identifier = managedRace.getIdentifier();
+                ManagedRaceIdentifier identifier = managedRace.getIdentifier();

-        String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
-        String raceColumnName = URLEncoder.encode(identifier.getRaceName());
-        String fleetName = URLEncoder.encode(identifier.getFleet().getName());
+                String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
+                String raceColumnName = URLEncoder.encode(identifier.getRaceName());
+                String fleetName = URLEncoder.encode(identifier.getFleet().getName());

-        try {
-            new DataLoader<Collection<Mark>>(context, URI.create(AppPreferences.getServerBaseURL(context)
-                    + "/sailingserver/rc/marks?leaderboard=" + raceGroupName + "&raceColumn=" + raceColumnName
-                    + "&fleet=" + fleetName), parser, handler).forceLoad();
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public void loadCourse(ManagedRace managedRace, LoadClient<CourseBase> client) {
-        SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
-        JsonDeserializer<CourseBase> courseBaseDeserializer = new CourseDataDeserializer(new WaypointDeserializer(
-                new ControlPointDeserializer(new MarkDeserializer(domainFactory), new GateDeserializer(domainFactory,
-                        new MarkDeserializer(domainFactory)))));
-        DataParser<CourseBase> parser = new CourseDataParser(courseBaseDeserializer);
-        DataHandler<CourseBase> handler = new CourseDataHandler(this, client, managedRace);
-
-        ManagedRaceIdentifier identifier = managedRace.getIdentifier();
-
-        String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
-        String raceColumnName = URLEncoder.encode(identifier.getRaceName());
-        String fleetName = URLEncoder.encode(identifier.getFleet().getName());
-
-        try {
-            new DataLoader<CourseBase>(context, URI.create(AppPreferences.getServerBaseURL(context)
-                    + "/sailingserver/rc/currentcourse?leaderboard=" + raceGroupName + "&raceColumn=" + raceColumnName
-                    + "&fleet=" + fleetName), parser, handler).forceLoad();
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public void loadCompetitors(ManagedRace managedRace, LoadClient<Collection<Competitor>> client) {
-        SharedDomainFactory domainFactory = DomainFactoryImpl.INSTANCE;
-        JsonDeserializer<Competitor> competitorDeserializer = new CompetitorDeserializer(domainFactory);
-        DataParser<Collection<Competitor>> parser = new CompetitorsDataParser(competitorDeserializer);
-        DataHandler<Collection<Competitor>> handler = new CompetitorsDataHandler(this, client, managedRace);
-
-        ManagedRaceIdentifier identifier = managedRace.getIdentifier();
-
-        String raceGroupName = URLEncoder.encode(identifier.getRaceGroup().getName());
-        String raceColumnName = URLEncoder.encode(identifier.getRaceName());
-        String fleetName = URLEncoder.encode(identifier.getFleet().getName());
-
-        try {
-            new DataLoader<Collection<Competitor>>(context, URI.create(AppPreferences.getServerBaseURL(context)
-                    + "/sailingserver/rc/competitors?leaderboard=" + raceGroupName + "&raceColumn=" + raceColumnName
-                    + "&fleet=" + fleetName), parser, handler).forceLoad();
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+                return new OnlineDataLoader<Collection<Competitor>>(context, URI.create(AppPreferences
+                        .getServerBaseURL(context)
+                        + "/sailingserver/rc/competitors?leaderboard="
+                        + raceGroupName
+                        + "&raceColumn=" + raceColumnName + "&fleet=" + fleetName), parser, handler);
+            }
+        });
    }
 }
@@ -3,27 +3,36 @@ package com.sap.sailing.racecommittee.app.data;
 import java.io.Serializable;
 import java.util.Collection;

+import android.app.LoaderManager.LoaderCallbacks;
+
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.CourseArea;
 import com.sap.sailing.domain.base.CourseBase;
 import com.sap.sailing.domain.base.EventBase;
 import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
+import com.sap.sailing.racecommittee.app.data.loaders.DataLoaderResult;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;

 public interface ReadonlyDataManager {

    public DataStore getDataStore();

-    public void loadEvents(LoadClient<Collection<EventBase>> client);
-
-    public void loadCourseAreas(Serializable parentEventId, LoadClient<Collection<CourseArea>> client);
-
-    public void loadRaces(Serializable courseAreaId, LoadClient<Collection<ManagedRace>> client);
-
-    public void loadMarks(ManagedRace managedRace, LoadClient<Collection<Mark>> client);
+    public LoaderCallbacks<DataLoaderResult<Collection<EventBase>>> getEventsLoader(
+            LoadClient<Collection<EventBase>> callback);
    
-    public void loadCourse(ManagedRace managedRace, LoadClient<CourseBase> client);
+    public LoaderCallbacks<DataLoaderResult<Collection<CourseArea>>> getCourseAreasLoader(
+            Serializable parentEventId, LoadClient<Collection<CourseArea>> callback);
    
-    public void loadCompetitors(ManagedRace managedRace, LoadClient<Collection<Competitor>> client);
+    public LoaderCallbacks<DataLoaderResult<Collection<ManagedRace>>> getRacesLoader(
+            Serializable courseAreaId, LoadClient<Collection<ManagedRace>> callback);
+    
+    public LoaderCallbacks<DataLoaderResult<Collection<Mark>>> getMarksLoader(
+            ManagedRace managedRace, LoadClient<Collection<Mark>> callback);
+    
+    public LoaderCallbacks<DataLoaderResult<CourseBase>> getCourseLoader(
+            ManagedRace managedRace, LoadClient<CourseBase> callback);
+    
+    public LoaderCallbacks<DataLoaderResult<Collection<Competitor>>> getCompetitorsLoader(
+            ManagedRace managedRace, LoadClient<Collection<Competitor>> callback);
 }
@@ -4,21 +4,19 @@ import java.util.Collection;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.racecommittee.app.data.OnlineDataManager;
-import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;

 public class CompetitorsDataHandler extends DataHandler<Collection<Competitor>> {
    
    private ManagedRace race;

-    public CompetitorsDataHandler(OnlineDataManager manager, LoadClient<Collection<Competitor>> client, ManagedRace managedRace) {
+    public CompetitorsDataHandler(OnlineDataManager manager, ManagedRace managedRace) {
        super(manager);
        race = managedRace;
    }

    @Override
    public void onResult(Collection<Competitor> data) {
-        //super.onSuccess(data);
        race.setCompetitors(data);
    }

@@ -2,21 +2,19 @@ package com.sap.sailing.racecommittee.app.data.handlers;

 import com.sap.sailing.domain.base.CourseBase;
 import com.sap.sailing.racecommittee.app.data.OnlineDataManager;
-import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;

 public class CourseDataHandler extends DataHandler<CourseBase> {
    
    private ManagedRace race;

-    public CourseDataHandler(OnlineDataManager manager, LoadClient<CourseBase> client, ManagedRace managedRace) {
+    public CourseDataHandler(OnlineDataManager manager, ManagedRace managedRace) {
        super(manager);
        race = managedRace;
    }

    @Override
    public void onResult(CourseBase data) {
-        //super.onSuccess(data);
        race.setCourseOnServer(data);
    }

@@ -3,18 +3,16 @@ package com.sap.sailing.racecommittee.app.data.handlers;
 import java.util.Collection;

 import com.sap.sailing.racecommittee.app.data.OnlineDataManager;
-import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
 import com.sap.sailing.racecommittee.app.domain.ManagedRace;

 public class ManagedRacesDataHandler extends DataHandler<Collection<ManagedRace>> {

-    public ManagedRacesDataHandler(OnlineDataManager manager, LoadClient<Collection<ManagedRace>> client) {
+    public ManagedRacesDataHandler(OnlineDataManager manager) {
        super(manager);
    }

    @Override
    public void onResult(Collection<ManagedRace> data) {
-        //super.onSuccess(data);
        manager.addRaces(data);
    }

@@ -4,17 +4,15 @@ import java.util.Collection;

 import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.racecommittee.app.data.OnlineDataManager;
-import com.sap.sailing.racecommittee.app.data.clients.LoadClient;

 public class MarksDataHandler extends DataHandler<Collection<Mark>> {

-    public MarksDataHandler(OnlineDataManager manager, LoadClient<Collection<Mark>> client) {
+    public MarksDataHandler(OnlineDataManager manager) {
        super(manager);
    }

    @Override
    public void onResult(Collection<Mark> data) {
-        //super.onSuccess(data);
        manager.addMarks(data);
    }

@@ -74,13 +74,4 @@ public class DataLoader<T> extends AsyncTaskLoader<T> {
        }
    }

-    /*@Override
-    public void deliverResult(T data) {
-        if (data == null) {
-            dataHandler.onFailed(lastException);
-        } else {
-            dataHandler.onLoaded(data);
-        }
-    }*/
-
 }
@@ -8,21 +8,25 @@ import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
 import com.sap.sailing.racecommittee.app.logging.ExLog;


-public abstract class DataLoaderCallbacks<T> implements LoaderCallbacks<DataLoaderResult<T>> {
+public class DataLoaderCallbacks<T> implements LoaderCallbacks<DataLoaderResult<T>> {
    private static String TAG = DataLoaderCallbacks.class.getName();
    
-    private LoadClient<T> clientCallback;
-
-    public DataLoaderCallbacks(LoadClient<T> clientCallback) {
-        this.clientCallback = clientCallback;
+    public interface LoaderCreator<T> {
+        Loader<DataLoaderResult<T>> create(int id, Bundle args) throws Exception;
    }
    
-    protected abstract Loader<DataLoaderResult<T>> createLoader(int id, Bundle args) throws Exception;
+    private LoadClient<T> clientCallback;
+    private LoaderCreator<T> loaderCreator;
+
+    public DataLoaderCallbacks(LoadClient<T> clientCallback, LoaderCreator<T> loaderCreator) {
+        this.clientCallback = clientCallback;
+        this.loaderCreator = loaderCreator;
+    }

    @Override
    public Loader<DataLoaderResult<T>> onCreateLoader(int id, Bundle args) {
        try {
-            return createLoader(id, args);
+            return loaderCreator.create(id, args);
        } catch (Exception e) {
            ExLog.e(TAG, String.format("Exception while trying to create loader:\n%s", e.toString()));
        }
@@ -0,0 +1,19 @@
+package com.sap.sailing.racecommittee.app.data.loaders;
+
+import java.util.concurrent.Callable;
+
+import android.content.Loader;
+import android.os.Bundle;
+
+import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
+
+public class ImmediateDataLoaderCallbacks<T> extends DataLoaderCallbacks<T> {
+    public ImmediateDataLoaderCallbacks(LoadClient<T> clientCallback, final Callable<T> loadingFunc) {
+        super(clientCallback, new LoaderCreator<T>() {
+            @Override
+            public Loader<DataLoaderResult<T>> create(int id, Bundle args) throws Exception {
+                return new ImmediateDataLoader<T>(null, loadingFunc);
+            }
+        });
+    }
+}
@@ -35,7 +35,7 @@ import com.sap.sailing.racecommittee.app.ui.fragments.raceinfo.RaceInfoListener;
 public class RacingActivity extends SessionActivity implements RaceInfoListener {
    // private final static String TAG = RacingActivity.class.getName();
    private final static String ListFragmentTag = RacingActivity.class.getName() + ".ManagedRaceListFragment";
-    
+
    private static final String TAG = RacingActivity.class.getName();

    private class FilterModeSelectionBinder implements OnNavigationListener {
@@ -106,7 +106,7 @@ public class RacingActivity extends SessionActivity implements RaceInfoListener
            loadRaces(courseArea);
        }
    }
-    
+
    @Override
    public void onBackPressed() {
        logoutSession();
@@ -159,15 +159,16 @@ public class RacingActivity extends SessionActivity implements RaceInfoListener
        setProgressBarIndeterminateVisibility(true);

        ExLog.i(TAG, "Issuing loading of managed races from data manager");
-        dataManager.loadRaces(courseArea.getId(), new LoadClient<Collection<ManagedRace>>() {
-            public void onLoadSucceded(Collection<ManagedRace> data) {
-                onLoadRacesSucceded(courseArea, data);
-            }
+        getLoaderManager().restartLoader(0, null,
+                dataManager.getRacesLoader(courseArea.getId(), new LoadClient<Collection<ManagedRace>>() {
+                    public void onLoadSucceded(Collection<ManagedRace> data) {
+                        onLoadRacesSucceded(courseArea, data);
+                    }

-            public void onLoadFailed(Exception reason) {
-                onLoadRacesFailed(courseArea, reason);
-            }
-        });
+                    public void onLoadFailed(Exception reason) {
+                        onLoadRacesFailed(courseArea, reason);
+                    }
+                }));
    }

    private void onLoadRacesSucceded(CourseArea courseArea, Collection<ManagedRace> data) {
@@ -198,9 +199,9 @@ public class RacingActivity extends SessionActivity implements RaceInfoListener

    private void showLoadFailedDialog(final CourseArea courseArea, String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
-        builder.setMessage(
-                String.format(getString(R.string.generic_load_failure), message))
-                .setTitle(getString(R.string.loading_failure)).setIcon(R.drawable.ic_dialog_alert_holo_light).setCancelable(true)
+        builder.setMessage(String.format(getString(R.string.generic_load_failure), message))
+                .setTitle(getString(R.string.loading_failure)).setIcon(R.drawable.ic_dialog_alert_holo_light)
+                .setCancelable(true)
                .setPositiveButton(getString(R.string.retry), new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {
                        loadRaces(courseArea);
@@ -47,7 +47,7 @@ import com.sap.sailing.racecommittee.app.ui.comparators.NaturalNamedComparator;
 import com.sap.sailing.racecommittee.app.utils.ESSMarkImageHelper;

 public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
-    //private final static String TAG = ESSCourseDesignDialogFragment.class.getName();
+    // private final static String TAG = ESSCourseDesignDialogFragment.class.getName();

    private List<Mark> aMarkList;
    private MarkGridAdapter gridAdapter;
@@ -57,15 +57,15 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
    private CourseElementListAdapter previousCourseElementAdapter;
    private DragSortListView newCourseListView;
    private ListView previousCourseListView;
-    
+
    private DragSortController dragSortController;
-    
+
    private Button publishButton;
    private Button unpublishButton;
    private Button takePreviousButton;
-    
+
    private ReadonlyDataManager dataManager;
-    
+
    private int dragStartMode = DragSortController.ON_DRAG;
    private boolean removeEnabled = true;
    private int removeMode = DragSortController.FLING_REMOVE;
@@ -83,15 +83,17 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
        getDialog().setTitle(getActivity().getText(R.string.course_design_dialog_title));

        dataManager = DataManager.create(getActivity());
-        
-        aMarkList  = new ArrayList<Mark>();
+
+        aMarkList = new ArrayList<Mark>();
        courseElements = new ArrayList<CourseListDataElement>();
        previousCourseElements = new ArrayList<CourseListDataElement>();

        gridAdapter = new MarkGridAdapter(getActivity(), aMarkList, ESSMarkImageHelper.getInstance());
-        courseElementAdapter = new DraggableCourseElementListAdapter(getActivity(), courseElements, ESSMarkImageHelper.getInstance());
-        previousCourseElementAdapter = new CourseElementListAdapter(getActivity(), previousCourseElements, ESSMarkImageHelper.getInstance());
-        
+        courseElementAdapter = new DraggableCourseElementListAdapter(getActivity(), courseElements,
+                ESSMarkImageHelper.getInstance());
+        previousCourseElementAdapter = new CourseElementListAdapter(getActivity(), previousCourseElements,
+                ESSMarkImageHelper.getInstance());
+
        loadMarks();
        loadCourseOnServer();

@@ -107,7 +109,7 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
            }

        });
-        
+
        newCourseListView = (DragSortListView) getView().findViewById(R.id.listViewNewCourse);
        newCourseListView.setAdapter(courseElementAdapter);
        newCourseListView.setDropListener(new DragSortListView.DropListener() {
@@ -121,16 +123,16 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
                }
            }
        });
-        
+
        newCourseListView.setRemoveListener(new DragSortListView.RemoveListener() {
-            
+
            @Override
            public void remove(int toBeRemoved) {
                CourseListDataElement item = courseElementAdapter.getItem(toBeRemoved);
                courseElementAdapter.remove(item);
            }
        });
-        
+
        newCourseListView.setOnItemLongClickListener(new OnItemLongClickListener() {

            @Override
@@ -140,7 +142,7 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
                return true;
            }
        });
-        
+
        dragSortController = buildDragSortController(newCourseListView);
        newCourseListView.setFloatViewManager(dragSortController);
        newCourseListView.setOnTouchListener(dragSortController);
@@ -163,14 +165,12 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
                    } else {
                        copyPreviousToNewCourseDesign();
                    }
-                }
-                else {
+                } else {
                    Toast.makeText(getActivity(), "No course available to copy", Toast.LENGTH_LONG).show();
                }
            }
        });

-
        publishButton = (Button) getView().findViewById(R.id.publishCourseDesignButton);
        publishButton.setOnClickListener(new OnClickListener() {

@@ -180,13 +180,19 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
                    sendCourseDataAndDismiss(courseData);
                } catch (IllegalStateException ex) {
                    if (ex.getMessage().equals("Gate has no right buoy")) {
-                        Toast.makeText(getActivity(), "A right buoy is missing for a gate. Please select the right buoy.", Toast.LENGTH_LONG).show();
+                        Toast.makeText(getActivity(),
+                                "A right buoy is missing for a gate. Please select the right buoy.", Toast.LENGTH_LONG)
+                                .show();
                    } else if (ex.getMessage().equals("Each waypoints needs a passing side")) {
-                        Toast.makeText(getActivity(), "A waypoint has no passing side. Please select the passing side by clicking long on the waypoint.", Toast.LENGTH_LONG).show();
+                        Toast.makeText(
+                                getActivity(),
+                                "A waypoint has no passing side. Please select the passing side by clicking long on the waypoint.",
+                                Toast.LENGTH_LONG).show();
                    }
-                    
+
                } catch (IllegalArgumentException ex) {
-                    Toast.makeText(getActivity(), "The course design has to have at least one waypoint.", Toast.LENGTH_LONG).show();
+                    Toast.makeText(getActivity(), "The course design has to have at least one waypoint.",
+                            Toast.LENGTH_LONG).show();
                }
            }

@@ -204,7 +210,7 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
        });

    }
-    
+
    /**
     * Creates a DragSortController and thereby defines the behaviour of the drag sort list
     */
@@ -219,15 +225,15 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
        controller.setBackgroundColor(getActivity().getResources().getColor(R.color.welter_medium_blue));
        return controller;
    }
-    
+
    @Override
    public void onResume() {
        super.onResume();
        onLoadMarksSucceeded(dataManager.getDataStore().getMarks());
    }
-    
+
    private void loadCourseOnServer() {
-        dataManager.loadCourse(getRace(), new LoadClient<CourseBase>() {
+        getLoaderManager().restartLoader(0, null, dataManager.getCourseLoader(getRace(), new LoadClient<CourseBase>() {

            @Override
            public void onLoadFailed(Exception reason) {
@@ -236,37 +242,38 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {

            @Override
            public void onLoadSucceded(CourseBase data) {
-                /*if (Util.size(data.getWaypoints()) > 0) {
-                    fillPreviousCourseElementsInList(data);
-                } else*/ {
+                /*
+                 * if (Util.size(data.getWaypoints()) > 0) { fillPreviousCourseElementsInList(data); } else
+                 */{
                    fillPreviousCourseElementsWithLastPublishedCourseDesign();
                }
-                
+
            }
-            
-        });
+
+        }));
    }
-    
+
    private void fillPreviousCourseElementsWithLastPublishedCourseDesign() {
        CourseBase lastPublishedCourseDesign = InMemoryDataStore.INSTANCE.getLastPublishedCourseDesign();
-        if(lastPublishedCourseDesign != null) {
+        if (lastPublishedCourseDesign != null) {
            fillPreviousCourseElementsInList(lastPublishedCourseDesign);
        }
    }

    private void loadMarks() {
-        dataManager.loadMarks(getRace(), new LoadClient<Collection<Mark>>() {
+        getLoaderManager().restartLoader(1, null,
+                dataManager.getMarksLoader(getRace(), new LoadClient<Collection<Mark>>() {

-            @Override
-            public void onLoadFailed(Exception reason) {
-            }
+                    @Override
+                    public void onLoadFailed(Exception reason) {
+                    }

-            @Override
-            public void onLoadSucceded(Collection<Mark> data) {
-                onLoadMarksSucceeded(data);
-            }
-            
-        });
+                    @Override
+                    public void onLoadSucceded(Collection<Mark> data) {
+                        onLoadMarksSucceeded(data);
+                    }
+
+                }));
    }

    protected void onLoadMarksSucceeded(Collection<Mark> data) {
@@ -295,10 +302,10 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {

        for (Waypoint waypoint : courseData.getWaypoints()) {
            ControlPoint controlPoint = waypoint.getControlPoint();
-            
+
            if (controlPoint instanceof Mark) {
                CourseListDataElement element = new CourseListDataElement();
-                element.setLeftMark((Mark)controlPoint);
+                element.setLeftMark((Mark) controlPoint);
                element.setRoundingDirection(getRoundingDirection(waypoint.getPassingSide()));
                elementList.add(element);
            } else if (controlPoint instanceof Gate) {
@@ -327,24 +334,28 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
    }

    protected CourseBase convertCourseElementsToACourseData() throws IllegalStateException, IllegalArgumentException {
-        //TODO find a proper name for the highly flexible ESS courses to be shown on the regatta overview page
+        // TODO find a proper name for the highly flexible ESS courses to be shown on the regatta overview page
        CourseBase design = new CourseDataImpl("Course template");
        List<Waypoint> waypoints = new ArrayList<Waypoint>();

        for (CourseListDataElement courseElement : courseElements) {
-            if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate) && courseElement.getRightMark() != null) {
-                String gateName = "Gate " + courseElement.getLeftMark().getName() + " / " + courseElement.getRightMark().getName();
+            if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate)
+                    && courseElement.getRightMark() != null) {
+                String gateName = "Gate " + courseElement.getLeftMark().getName() + " / "
+                        + courseElement.getRightMark().getName();
                Gate gate = new GateImpl(courseElement.getLeftMark(), courseElement.getRightMark(), gateName);
                Waypoint waypoint = new WaypointImpl(gate);
-                
+
                waypoints.add(waypoint);
-            } else if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate) && courseElement.getRightMark() == null) {
+            } else if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate)
+                    && courseElement.getRightMark() == null) {
                throw new IllegalStateException("Gate has no right buoy");
            } else if (courseElement.getRoundingDirection().equals(RoundingDirection.None)) {
                throw new IllegalStateException("Each waypoints needs a passing side");
            } else {
-                Waypoint waypoint = new WaypointImpl(courseElement.getLeftMark(), getNauticalSide(courseElement.getRoundingDirection()));
-                
+                Waypoint waypoint = new WaypointImpl(courseElement.getLeftMark(),
+                        getNauticalSide(courseElement.getRoundingDirection()));
+
                waypoints.add(waypoint);
            }

@@ -365,19 +376,19 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
        NauticalSide side = null;
        if (roundingDirection.name().equalsIgnoreCase(NauticalSide.PORT.name())) {
            side = NauticalSide.PORT;
-        } else if (roundingDirection.name().equalsIgnoreCase(NauticalSide.STARBOARD.name())){
+        } else if (roundingDirection.name().equalsIgnoreCase(NauticalSide.STARBOARD.name())) {
            side = NauticalSide.STARBOARD;
        }
        return side;
    }
-    
+
    private RoundingDirection getRoundingDirection(NauticalSide passingSide) {
        RoundingDirection direction = null;
        if (passingSide == null) {
            direction = RoundingDirection.None;
        } else if (passingSide.name().equalsIgnoreCase(RoundingDirection.Port.name())) {
            direction = RoundingDirection.Port;
-        } else if (passingSide.name().equalsIgnoreCase(RoundingDirection.Starboard.name())){
+        } else if (passingSide.name().equalsIgnoreCase(RoundingDirection.Starboard.name())) {
            direction = RoundingDirection.Starboard;
        } else {
            direction = RoundingDirection.Gate;
@@ -400,18 +411,18 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {

            @Override
            public void onClick(DialogInterface dialog, int which) {
-                //do nothing
+                // do nothing
            }
        });
        builder.create();
        builder.show();
    }
-    
+
    protected void copyPreviousToNewCourseDesign() {
        courseElements.clear();
        courseElements.addAll(previousCourseElements);
        courseElementAdapter.notifyDataSetChanged();
-}
+    }

    protected void onMarkClickedOnGrid(Mark mark) {
        if (courseElements.isEmpty()) {
@@ -426,10 +437,11 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
            }
        }
    }
-    
+
    private CourseListDataElement getFirstGateCourseElementWithoutRightMark() {
        for (CourseListDataElement courseElement : courseElements) {
-            if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate) && courseElement.getRightMark() == null) {
+            if (courseElement.getRoundingDirection().equals(RoundingDirection.Gate)
+                    && courseElement.getRightMark() == null) {
                return courseElement;
            }
        }
@@ -448,14 +460,14 @@ public class ESSCourseDesignDialogFragment extends RaceDialogFragment {
            directions.add(direction.name());
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
-        builder.setTitle(R.string.pick_a_rounding_direction)
-        .setItems(R.array.rounding_directions, new DialogInterface.OnClickListener() {
-            public void onClick(DialogInterface dialog, int position) {
-                String[] directions = getActivity().getResources().getStringArray(R.array.rounding_directions);
-                RoundingDirection pickedDirection = RoundingDirection.valueOf(directions[position]);
-                onRoundingDirectionPicked(courseElement, pickedDirection);
-            }
-        });
+        builder.setTitle(R.string.pick_a_rounding_direction).setItems(R.array.rounding_directions,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int position) {
+                        String[] directions = getActivity().getResources().getStringArray(R.array.rounding_directions);
+                        RoundingDirection pickedDirection = RoundingDirection.valueOf(directions[position]);
+                        onRoundingDirectionPicked(courseElement, pickedDirection);
+                    }
+                });
        builder.create();
        builder.show();
    }
@@ -29,6 +29,7 @@ import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.racecommittee.app.R;
 import com.sap.sailing.racecommittee.app.data.OnlineDataManager;
+import com.sap.sailing.racecommittee.app.data.ReadonlyDataManager;
 import com.sap.sailing.racecommittee.app.data.clients.LoadClient;
 import com.sap.sailing.racecommittee.app.domain.impl.DomainFactoryImpl;
 import com.sap.sailing.racecommittee.app.logging.ExLog;
@@ -167,20 +168,21 @@ public class PositioningFragment extends RaceDialogFragment {
    }

    private void loadCompetitors() {
+        ReadonlyDataManager dataManager = OnlineDataManager.create(getActivity());
+        getLoaderManager().restartLoader(0, null,
+                dataManager.getCompetitorsLoader(getRace(), new LoadClient<Collection<Competitor>>() {

-        OnlineDataManager.create(getActivity()).loadCompetitors(getRace(), new LoadClient<Collection<Competitor>>() {
+                    @Override
+                    public void onLoadFailed(Exception reason) {
+                        onLoadCompetitorsSucceeded(getRace().getCompetitors());
+                    }

-            @Override
-            public void onLoadFailed(Exception reason) {
-                onLoadCompetitorsSucceeded(getRace().getCompetitors());
-            }
+                    @Override
+                    public void onLoadSucceded(Collection<Competitor> data) {
+                        onLoadCompetitorsSucceeded(data);
+                    }

-            @Override
-            public void onLoadSucceded(Collection<Competitor> data) {
-                onLoadCompetitorsSucceeded(data);
-            }
-
-        });
+                }));
    }

    protected void onLoadCompetitorsSucceeded(Collection<Competitor> data) {