app/src/syncbase2/java/io/v/todos/persistence/syncbase/SyncbasePersistence.java - release.projects.todos - Git at Google

 // Copyright 2016 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package io.v.todos.persistence.syncbase;

 import android.app.Activity;
 import android.app.FragmentManager;
 import android.app.FragmentTransaction;
 import android.content.Context;
 import android.os.Bundle;
 import android.support.annotation.CallSuper;
 import android.support.annotation.Nullable;
 import android.util.Log;

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;

 import io.v.syncbase.Collection;
 import io.v.syncbase.Database;
 import io.v.syncbase.Syncbase;
 import io.v.syncbase.Id;

 import io.v.syncbase.Syncgroup;
 import io.v.syncbase.SyncgroupInvite;
 import io.v.syncbase.WatchChange;
 import io.v.syncbase.exception.SyncbaseException;
 import io.v.todos.model.ListMetadata;
 import io.v.todos.model.ListSpec;
 import io.v.todos.model.Task;
 import io.v.todos.model.TaskSpec;
 import io.v.todos.persistence.ListEventListener;
 import io.v.todos.persistence.Persistence;
 import io.v.todos.persistence.TodoListListener;
 import io.v.todos.sharing.NeighborhoodFragment;
 import io.v.todos.sharing.ShareListDialogFragment;

 public abstract class SyncbasePersistence implements Persistence {
     protected static final String SHOW_DONE_KEY = "showDoneKey";
     protected static final String TODO_LIST_KEY = "todoListKey";
     protected static final String TODO_LIST_COLLECTION_PREFIX = "list";
     protected static final String TAG = "High-Level Syncbase";

     protected static boolean sInitialized = false;

     protected static final Map<Id, ListSpec> sListSpecMap = new HashMap<>();
     protected static final Map<Id, ListMetadataTracker> sListMetadataTrackerMap = new HashMap<>();
     protected static final Map<Id, Map<String, TaskSpec>> sTasksByListMap = new HashMap<>();
     protected static boolean sShowDone = true;

     protected static Database sDb;

     private static final Object sSyncbaseMutex = new Object();
     private static TodoListListener sTodoListListener;
     private static Id sTodoListExpectedId;
     private static ListEventListener<ListMetadata> sMainListener;

     SyncbasePersistence(final Activity activity, Bundle savedInstanceState) {
         Log.d(TAG, "Trying to start Syncbase Persistence...");
         /**
          * Initializes Syncbase Server
          * Starts up a watch stream to watch all the data with methods to access/modify the data.
          * This watch stream will also allow us to "watch" who has been shared to, if we desire.
          * Starts up an invite handler to automatically accept invitations.
          */
         synchronized (sSyncbaseMutex) {
             if (!sInitialized) {
                 Log.d(TAG, "Initializing Syncbase Persistence...");

                 Syncbase.Options opts = new Syncbase.Options();
                 opts.rootDir = activity.getFilesDir().getAbsolutePath();
                 opts.disableSyncgroupPublishing = true;
                 try {
                     Syncbase.init(opts);
                 } catch (SyncbaseException e) {
                     Log.e(TAG, "Failed to initialize", e);
                     return;
                 }

                 final Object initializeMutex = new Object();

                 Log.d(TAG, "Logging the user in!");
                 if (!Syncbase.isLoggedIn()) {
                     Syncbase.loginAndroid(activity, new Syncbase.LoginCallback() {
                         @Override
                         public void onSuccess() {
                             Log.d(TAG, "Successfully logged in!");
                             try {
                                 sDb = Syncbase.database();
                             } catch (SyncbaseException e) {
                                 Log.e(TAG, "Failed to create database", e);
                                 callNotify();
                                 return;
                             }
                             continueSetup();
                             sInitialized = true;
                             Log.d(TAG, "Successfully initialized!");
                             callNotify();
                         }

                         @Override
                         public void onError(Throwable e) {
                             Log.e(TAG, "Failed to login. :(", e);
                             callNotify();
                         }

                         private void callNotify() {
                             synchronized (initializeMutex) {
                                 initializeMutex.notify();
                             }
                         }
                     });
                 }

                 Log.d(TAG, "Let's wait until we are logged in...");
                 synchronized (initializeMutex) {
                     try {
                         initializeMutex.wait();
                     } catch (InterruptedException e) {
                         Log.e(TAG, "could not wait for initialization to finish", e);
                     }
                 }

                 if (sInitialized) {
                     Log.d(TAG, "Syncbase Persistence initialization complete!");
                 } else {
                     Log.d(TAG, "Syncbase Persistence initialization FAILED!");
                     return;
                 }
             }
         }

         // Prepare the share presence menu fragment.
         FragmentManager mgr = activity.getFragmentManager();
         if (savedInstanceState == null) {
             FragmentTransaction t = mgr.beginTransaction();
             addFeatureFragments(mgr, activity, t);
             t.commit();
         } else {
             addFeatureFragments(mgr, activity, null);
         }
     }

     /**
      * Hook to insert or rebind fragments.
      *
      * @param manager
      * @param transaction the fragment transaction to use to add fragments, or null if fragments are
      *                    being restored by the system.
      */
     @CallSuper
     protected void addFeatureFragments(FragmentManager manager, Context context,
                                        @Nullable FragmentTransaction transaction) {
         if (transaction != null) {
             NeighborhoodFragment fragment = new NeighborhoodFragment();
             fragment.initSharePresence(context);
             transaction.add(fragment, NeighborhoodFragment.FRAGMENT_TAG);
         }
     }

     private void continueSetup() {
         Log.d(TAG, "Watching everything");
         // Watch everything.
         // TODO(alexfandrianto): This can be simplified if we watch specific collections and the
         // entrance/exit of collections. https://v.io/i/1376
         sDb.addWatchChangeHandler(new Database.WatchChangeHandler() {
             @Override
             public void onInitialState(final Iterator<WatchChange> values) {
                 while (values.hasNext()) {
                     handlePutChange(values.next());
                 }
             }

             @Override
             public void onChangeBatch(final Iterator<WatchChange> changes) {
                 while (changes.hasNext()) {
                     WatchChange change = changes.next();
                     if (change.getChangeType() == WatchChange.ChangeType.DELETE) {
                         handleDeleteChange(change);
                     } else {
                         handlePutChange(change);
                     }
                 }
             }

             // TODO(alexfandrianto): This will fire listeners despite the WatchChange's potentially
             // being within a batch. Over-firing the listeners isn't ideal, but the app should be
             // okay.
             private void handlePutChange(WatchChange value) {
                 Log.d(TAG, "Handling put change " + value.getRowKey());
                 Log.d(TAG, "From collection: " + value.getCollectionId());
                 Log.d(TAG, "With entity type: " + value.getEntityType());
                 if (value.getEntityType() != WatchChange.EntityType.ROW) {
                     // TODO(alexfandrianto): I can't deal with non-row entities yet. Skip.
                     return;
                 }
                 Log.d(TAG, "With row...: " + value.getRowKey());
                 final Id collectionId = value.getCollectionId();

                 if (collectionId.getName().equals(Syncbase.USERDATA_NAME)) {
                     if (value.getRowKey().equals(SHOW_DONE_KEY)) {
                         try {
                             sShowDone = value.getValue(Boolean.class);
                             Log.d(TAG, "Got a show done" + sShowDone);

                             // Inform the relevant listener.
                             if (sTodoListListener != null) {
                                 sTodoListListener.onUpdateShowDone(sShowDone);
                             }
                         } catch (SyncbaseException e) {
                             Log.e(TAG, "Failed to decode watch change as Boolean", e);
                         }
                     }
                     return; // Show done updated. Nothing left to do.
                 }

                 // If we are here, we must be modifying a todo list collection.
                 // Initialize the task spec map, if necessary.
                 if (sTasksByListMap.get(collectionId) == null) {
                     sTasksByListMap.put(collectionId, new HashMap<String, TaskSpec>());
                 }

                 if (value.getRowKey().equals(TODO_LIST_KEY)) {
                     try {
                         final ListSpec listSpec = value.getValue(ListSpec.class);
                         Log.d(TAG, "Got a list" + listSpec.toString());
                         sListSpecMap.put(collectionId, listSpec);

                         final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
                         tracker.setSpec(listSpec);

                         // Inform the relevant listeners.
                         if (sMainListener != null) {
                             tracker.fireListener(sMainListener);
                         }
                         if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
                             sTodoListListener.onUpdate(listSpec);
                         }
                     } catch (SyncbaseException e) {
                         Log.e(TAG, "Failed to decode watch change value as ListSpec", e);
                     }
                 } else {
                     Map<String, TaskSpec> taskData = sTasksByListMap.get(collectionId);
                     final String rowKey = value.getRowKey();
                     try {
                         final TaskSpec newSpec = value.getValue(TaskSpec.class);
                         Log.d(TAG, "Got a task" + newSpec.toString());
                         final TaskSpec oldSpec = taskData.put(rowKey, newSpec);

                         final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
                         tracker.adjustTask(rowKey, newSpec.getDone());

                         // Inform the relevant listeners.
                         if (sMainListener != null) {
                             tracker.fireListener(sMainListener);
                         }
                         if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
                             if (oldSpec == null) {
                                 sTodoListListener.onItemAdd(new Task(rowKey, newSpec));
                             } else {
                                 sTodoListListener.onItemUpdate(new Task(rowKey, newSpec));
                             }
                         }
                     } catch (SyncbaseException e) {
                         Log.e(TAG, "Failed to decode watch change value as TaskSpec", e);
                     }
                 }
             }

             // TODO(alexfandrianto): This will fire listeners despite the WatchChange's potentially
             // being within a batch. Over-firing the listeners isn't ideal, but the app should be
             // okay.
             private void handleDeleteChange(WatchChange value) {
                 Log.d(TAG, "Handling delete change " + value.getRowKey());
                 Log.d(TAG, "From collection: " + value.getCollectionId());
                 Log.d(TAG, "With entity type: " + value.getEntityType());
                 if (value.getEntityType() != WatchChange.EntityType.ROW ||
                         value.getCollectionId().getName().equals(Syncbase.USERDATA_NAME)) {
                     // TODO(alexfandrianto): I can't deal with non-row entities, and we don't need
                     // to watch deletes from userdata.
                     return;
                 }
                 Log.d(TAG, "With row...: " + value.getRowKey());

                 final Id collectionId = value.getCollectionId();
                 final String oldKey = value.getRowKey();
                 if (oldKey.equals(TODO_LIST_KEY)) {
                     sListSpecMap.remove(collectionId);
                     sListMetadataTrackerMap.remove(collectionId);

                     // TODO(alexfandrianto): Potentially destroy the collection too?
                     // Inform the relevant listeners.
                     if (sMainListener != null) {
                         sMainListener.onItemDelete(collectionId.encode());
                     }
                     if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
                         sTodoListListener.onDelete();
                     }
                 } else {
                     Map<String, TaskSpec> tasks = sTasksByListMap.get(collectionId);
                     if (tasks != null) {
                         tasks.remove(oldKey);

                         final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
                         tracker.removeTask(oldKey);

                         // Inform the relevant listeners.
                         if (sMainListener != null) {
                             tracker.fireListener(sMainListener);
                         }
                         if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
                             sTodoListListener.onItemDelete(oldKey);
                         }
                     }
                 }
             }

             @Override
             public void onError(Throwable e) {
                 Log.w(TAG, "error during watch", e);
             }
         }, new Database.AddWatchChangeHandlerOptions());

         Log.d(TAG, "Accepting all invitations");

         // Automatically accept invitations.
         sDb.addSyncgroupInviteHandler(new Database.SyncgroupInviteHandler() {
             @Override
             public void onInvite(SyncgroupInvite invite) {
                 sDb.acceptSyncgroupInvite(invite, new Database.AcceptSyncgroupInviteCallback() {
                     @Override
                     public void onSuccess(Syncgroup sg) {
                         Log.d(TAG, "Successfully joined syncgroup: " + sg.getId().toString());
                     }

                     @Override
                     public void onFailure(Throwable e) {
                         Log.w(TAG, "Failed to accept invitation", e);
                     }
                 });
             }

             @Override
             public void onError(Throwable e) {
                 Log.w(TAG, "error while handling invitations", e);
             }
         }, new Database.AddSyncgroupInviteHandlerOptions());

         // And do a background scan for peers near me.
         ShareListDialogFragment.initScan();
     }

     public static boolean isInitialized() {
         return sInitialized;
     }

     @Override
     public abstract void close();

     @Override
     public String debugDetails() {
         return null;
     }

     protected void setMainListener(ListEventListener<ListMetadata> listener) {
         sMainListener = listener;
     }
     protected void removeMainListener() {
         sMainListener = null;
     }

     protected void setTodoListListener(TodoListListener listener, Id expectedId) {
         sTodoListListener = listener;
         sTodoListExpectedId = expectedId;
     }
     protected void removeTodoListListener() {
         sTodoListListener = null;
     }

     private ListMetadataTracker getListMetadataTrackerSafe(Id listId) {
         ListMetadataTracker tracker = sListMetadataTrackerMap.get(listId);
         if (tracker == null) {
             tracker = new ListMetadataTracker(listId);
             sListMetadataTrackerMap.put(listId, tracker);
         }
         return tracker;
     }

     class ListMetadataTracker {
         private final Id collectionId;
         private ListSpec spec;
         private int numCompleted = 0;
         private Map<String, Boolean> taskCompletion = new HashMap<>();
         private boolean hasFired;

         ListMetadataTracker(Id collectionId) {
             this.collectionId = collectionId;
         }

         ListMetadata computeListMetadata() {
             if (spec == null) {
                 return null;
             }
             return new ListMetadata(collectionId.encode(), spec, numCompleted,
                     taskCompletion.size());
         }

         void setSpec(ListSpec newSpec) {
             spec = newSpec;
         }

         void adjustTask(String taskKey, boolean done) {
             Boolean oldDone = taskCompletion.put(taskKey, done);
             if ((oldDone == null || !oldDone) && done) {
                 numCompleted++;
             } else if (oldDone != null && oldDone && !done) {
                 numCompleted--;
             }
         }

         void removeTask(String taskKey) {
             Boolean oldDone = taskCompletion.remove(taskKey);
             if (oldDone != null && oldDone) {
                 numCompleted--;
             }
         }

         void fireListener(ListEventListener<ListMetadata> listener) {
             ListMetadata metadata = computeListMetadata();
             if (metadata == null) {
                 return; // cannot fire yet
             }
             if (!hasFired) {
                 hasFired = true;
                 listener.onItemAdd(computeListMetadata());
             } else {
                 listener.onItemUpdate(computeListMetadata());
             }
         }
     }
 }
	// Copyright 2016 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package io.v.todos.persistence.syncbase;

	import android.app.Activity;
	import android.app.FragmentManager;
	import android.app.FragmentTransaction;
	import android.content.Context;
	import android.os.Bundle;
	import android.support.annotation.CallSuper;
	import android.support.annotation.Nullable;
	import android.util.Log;

	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.Map;

	import io.v.syncbase.Collection;
	import io.v.syncbase.Database;
	import io.v.syncbase.Syncbase;
	import io.v.syncbase.Id;

	import io.v.syncbase.Syncgroup;
	import io.v.syncbase.SyncgroupInvite;
	import io.v.syncbase.WatchChange;
	import io.v.syncbase.exception.SyncbaseException;
	import io.v.todos.model.ListMetadata;
	import io.v.todos.model.ListSpec;
	import io.v.todos.model.Task;
	import io.v.todos.model.TaskSpec;
	import io.v.todos.persistence.ListEventListener;
	import io.v.todos.persistence.Persistence;
	import io.v.todos.persistence.TodoListListener;
	import io.v.todos.sharing.NeighborhoodFragment;
	import io.v.todos.sharing.ShareListDialogFragment;

	public abstract class SyncbasePersistence implements Persistence {
	protected static final String SHOW_DONE_KEY = "showDoneKey";
	protected static final String TODO_LIST_KEY = "todoListKey";
	protected static final String TODO_LIST_COLLECTION_PREFIX = "list";
	protected static final String TAG = "High-Level Syncbase";

	protected static boolean sInitialized = false;

	protected static final Map<Id, ListSpec> sListSpecMap = new HashMap<>();
	protected static final Map<Id, ListMetadataTracker> sListMetadataTrackerMap = new HashMap<>();
	protected static final Map<Id, Map<String, TaskSpec>> sTasksByListMap = new HashMap<>();
	protected static boolean sShowDone = true;

	protected static Database sDb;

	private static final Object sSyncbaseMutex = new Object();
	private static TodoListListener sTodoListListener;
	private static Id sTodoListExpectedId;
	private static ListEventListener<ListMetadata> sMainListener;

	SyncbasePersistence(final Activity activity, Bundle savedInstanceState) {
	Log.d(TAG, "Trying to start Syncbase Persistence...");
	/**
	* Initializes Syncbase Server
	* Starts up a watch stream to watch all the data with methods to access/modify the data.
	* This watch stream will also allow us to "watch" who has been shared to, if we desire.
	* Starts up an invite handler to automatically accept invitations.
	*/
	synchronized (sSyncbaseMutex) {
	if (!sInitialized) {
	Log.d(TAG, "Initializing Syncbase Persistence...");

	Syncbase.Options opts = new Syncbase.Options();
	opts.rootDir = activity.getFilesDir().getAbsolutePath();
	opts.disableSyncgroupPublishing = true;
	try {
	Syncbase.init(opts);
	} catch (SyncbaseException e) {
	Log.e(TAG, "Failed to initialize", e);
	return;
	}

	final Object initializeMutex = new Object();

	Log.d(TAG, "Logging the user in!");
	if (!Syncbase.isLoggedIn()) {
	Syncbase.loginAndroid(activity, new Syncbase.LoginCallback() {
	@Override
	public void onSuccess() {
	Log.d(TAG, "Successfully logged in!");
	try {
	sDb = Syncbase.database();
	} catch (SyncbaseException e) {
	Log.e(TAG, "Failed to create database", e);
	callNotify();
	return;
	}
	continueSetup();
	sInitialized = true;
	Log.d(TAG, "Successfully initialized!");
	callNotify();
	}

	@Override
	public void onError(Throwable e) {
	Log.e(TAG, "Failed to login. :(", e);
	callNotify();
	}

	private void callNotify() {
	synchronized (initializeMutex) {
	initializeMutex.notify();
	}
	}
	});
	}

	Log.d(TAG, "Let's wait until we are logged in...");
	synchronized (initializeMutex) {
	try {
	initializeMutex.wait();
	} catch (InterruptedException e) {
	Log.e(TAG, "could not wait for initialization to finish", e);
	}
	}

	if (sInitialized) {
	Log.d(TAG, "Syncbase Persistence initialization complete!");
	} else {
	Log.d(TAG, "Syncbase Persistence initialization FAILED!");
	return;
	}
	}
	}

	// Prepare the share presence menu fragment.
	FragmentManager mgr = activity.getFragmentManager();
	if (savedInstanceState == null) {
	FragmentTransaction t = mgr.beginTransaction();
	addFeatureFragments(mgr, activity, t);
	t.commit();
	} else {
	addFeatureFragments(mgr, activity, null);
	}
	}

	/**
	* Hook to insert or rebind fragments.
	*
	* @param manager
	* @param transaction the fragment transaction to use to add fragments, or null if fragments are
	* being restored by the system.
	*/
	@CallSuper
	protected void addFeatureFragments(FragmentManager manager, Context context,
	@Nullable FragmentTransaction transaction) {
	if (transaction != null) {
	NeighborhoodFragment fragment = new NeighborhoodFragment();
	fragment.initSharePresence(context);
	transaction.add(fragment, NeighborhoodFragment.FRAGMENT_TAG);
	}
	}

	private void continueSetup() {
	Log.d(TAG, "Watching everything");
	// Watch everything.
	// TODO(alexfandrianto): This can be simplified if we watch specific collections and the
	// entrance/exit of collections. https://v.io/i/1376
	sDb.addWatchChangeHandler(new Database.WatchChangeHandler() {
	@Override
	public void onInitialState(final Iterator<WatchChange> values) {
	while (values.hasNext()) {
	handlePutChange(values.next());
	}
	}

	@Override
	public void onChangeBatch(final Iterator<WatchChange> changes) {
	while (changes.hasNext()) {
	WatchChange change = changes.next();
	if (change.getChangeType() == WatchChange.ChangeType.DELETE) {
	handleDeleteChange(change);
	} else {
	handlePutChange(change);
	}
	}
	}

	// TODO(alexfandrianto): This will fire listeners despite the WatchChange's potentially
	// being within a batch. Over-firing the listeners isn't ideal, but the app should be
	// okay.
	private void handlePutChange(WatchChange value) {
	Log.d(TAG, "Handling put change " + value.getRowKey());
	Log.d(TAG, "From collection: " + value.getCollectionId());
	Log.d(TAG, "With entity type: " + value.getEntityType());
	if (value.getEntityType() != WatchChange.EntityType.ROW) {
	// TODO(alexfandrianto): I can't deal with non-row entities yet. Skip.
	return;
	}
	Log.d(TAG, "With row...: " + value.getRowKey());
	final Id collectionId = value.getCollectionId();

	if (collectionId.getName().equals(Syncbase.USERDATA_NAME)) {
	if (value.getRowKey().equals(SHOW_DONE_KEY)) {
	try {
	sShowDone = value.getValue(Boolean.class);
	Log.d(TAG, "Got a show done" + sShowDone);

	// Inform the relevant listener.
	if (sTodoListListener != null) {
	sTodoListListener.onUpdateShowDone(sShowDone);
	}
	} catch (SyncbaseException e) {
	Log.e(TAG, "Failed to decode watch change as Boolean", e);
	}
	}
	return; // Show done updated. Nothing left to do.
	}

	// If we are here, we must be modifying a todo list collection.
	// Initialize the task spec map, if necessary.
	if (sTasksByListMap.get(collectionId) == null) {
	sTasksByListMap.put(collectionId, new HashMap<String, TaskSpec>());
	}

	if (value.getRowKey().equals(TODO_LIST_KEY)) {
	try {
	final ListSpec listSpec = value.getValue(ListSpec.class);
	Log.d(TAG, "Got a list" + listSpec.toString());
	sListSpecMap.put(collectionId, listSpec);

	final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
	tracker.setSpec(listSpec);

	// Inform the relevant listeners.
	if (sMainListener != null) {
	tracker.fireListener(sMainListener);
	}
	if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
	sTodoListListener.onUpdate(listSpec);
	}
	} catch (SyncbaseException e) {
	Log.e(TAG, "Failed to decode watch change value as ListSpec", e);
	}
	} else {
	Map<String, TaskSpec> taskData = sTasksByListMap.get(collectionId);
	final String rowKey = value.getRowKey();
	try {
	final TaskSpec newSpec = value.getValue(TaskSpec.class);
	Log.d(TAG, "Got a task" + newSpec.toString());
	final TaskSpec oldSpec = taskData.put(rowKey, newSpec);

	final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
	tracker.adjustTask(rowKey, newSpec.getDone());

	// Inform the relevant listeners.
	if (sMainListener != null) {
	tracker.fireListener(sMainListener);
	}
	if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
	if (oldSpec == null) {
	sTodoListListener.onItemAdd(new Task(rowKey, newSpec));
	} else {
	sTodoListListener.onItemUpdate(new Task(rowKey, newSpec));
	}
	}
	} catch (SyncbaseException e) {
	Log.e(TAG, "Failed to decode watch change value as TaskSpec", e);
	}
	}
	}

	// TODO(alexfandrianto): This will fire listeners despite the WatchChange's potentially
	// being within a batch. Over-firing the listeners isn't ideal, but the app should be
	// okay.
	private void handleDeleteChange(WatchChange value) {
	Log.d(TAG, "Handling delete change " + value.getRowKey());
	Log.d(TAG, "From collection: " + value.getCollectionId());
	Log.d(TAG, "With entity type: " + value.getEntityType());
	if (value.getEntityType() != WatchChange.EntityType.ROW \|\|
	value.getCollectionId().getName().equals(Syncbase.USERDATA_NAME)) {
	// TODO(alexfandrianto): I can't deal with non-row entities, and we don't need
	// to watch deletes from userdata.
	return;
	}
	Log.d(TAG, "With row...: " + value.getRowKey());

	final Id collectionId = value.getCollectionId();
	final String oldKey = value.getRowKey();
	if (oldKey.equals(TODO_LIST_KEY)) {
	sListSpecMap.remove(collectionId);
	sListMetadataTrackerMap.remove(collectionId);

	// TODO(alexfandrianto): Potentially destroy the collection too?
	// Inform the relevant listeners.
	if (sMainListener != null) {
	sMainListener.onItemDelete(collectionId.encode());
	}
	if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
	sTodoListListener.onDelete();
	}
	} else {
	Map<String, TaskSpec> tasks = sTasksByListMap.get(collectionId);
	if (tasks != null) {
	tasks.remove(oldKey);

	final ListMetadataTracker tracker = getListMetadataTrackerSafe(collectionId);
	tracker.removeTask(oldKey);

	// Inform the relevant listeners.
	if (sMainListener != null) {
	tracker.fireListener(sMainListener);
	}
	if (sTodoListListener != null && sTodoListExpectedId.equals(collectionId)) {
	sTodoListListener.onItemDelete(oldKey);
	}
	}
	}
	}

	@Override
	public void onError(Throwable e) {
	Log.w(TAG, "error during watch", e);
	}
	}, new Database.AddWatchChangeHandlerOptions());

	Log.d(TAG, "Accepting all invitations");

	// Automatically accept invitations.
	sDb.addSyncgroupInviteHandler(new Database.SyncgroupInviteHandler() {
	@Override
	public void onInvite(SyncgroupInvite invite) {
	sDb.acceptSyncgroupInvite(invite, new Database.AcceptSyncgroupInviteCallback() {
	@Override
	public void onSuccess(Syncgroup sg) {
	Log.d(TAG, "Successfully joined syncgroup: " + sg.getId().toString());
	}

	@Override
	public void onFailure(Throwable e) {
	Log.w(TAG, "Failed to accept invitation", e);
	}
	});
	}

	@Override
	public void onError(Throwable e) {
	Log.w(TAG, "error while handling invitations", e);
	}
	}, new Database.AddSyncgroupInviteHandlerOptions());

	// And do a background scan for peers near me.
	ShareListDialogFragment.initScan();
	}

	public static boolean isInitialized() {
	return sInitialized;
	}

	@Override
	public abstract void close();

	@Override
	public String debugDetails() {
	return null;
	}

	protected void setMainListener(ListEventListener<ListMetadata> listener) {
	sMainListener = listener;
	}
	protected void removeMainListener() {
	sMainListener = null;
	}

	protected void setTodoListListener(TodoListListener listener, Id expectedId) {
	sTodoListListener = listener;
	sTodoListExpectedId = expectedId;
	}
	protected void removeTodoListListener() {
	sTodoListListener = null;
	}

	private ListMetadataTracker getListMetadataTrackerSafe(Id listId) {
	ListMetadataTracker tracker = sListMetadataTrackerMap.get(listId);
	if (tracker == null) {
	tracker = new ListMetadataTracker(listId);
	sListMetadataTrackerMap.put(listId, tracker);
	}
	return tracker;
	}

	class ListMetadataTracker {
	private final Id collectionId;
	private ListSpec spec;
	private int numCompleted = 0;
	private Map<String, Boolean> taskCompletion = new HashMap<>();
	private boolean hasFired;

	ListMetadataTracker(Id collectionId) {
	this.collectionId = collectionId;
	}

	ListMetadata computeListMetadata() {
	if (spec == null) {
	return null;
	}
	return new ListMetadata(collectionId.encode(), spec, numCompleted,
	taskCompletion.size());
	}

	void setSpec(ListSpec newSpec) {
	spec = newSpec;
	}

	void adjustTask(String taskKey, boolean done) {
	Boolean oldDone = taskCompletion.put(taskKey, done);
	if ((oldDone == null \|\| !oldDone) && done) {
	numCompleted++;
	} else if (oldDone != null && oldDone && !done) {
	numCompleted--;
	}
	}

	void removeTask(String taskKey) {
	Boolean oldDone = taskCompletion.remove(taskKey);
	if (oldDone != null && oldDone) {
	numCompleted--;
	}
	}

	void fireListener(ListEventListener<ListMetadata> listener) {
	ListMetadata metadata = computeListMetadata();
	if (metadata == null) {
	return; // cannot fire yet
	}
	if (!hasFired) {
	hasFired = true;
	listener.onItemAdd(computeListMetadata());
	} else {
	listener.onItemUpdate(computeListMetadata());
	}
	}
	}
	}