Helper class to use the Parse API with Tasks (bolts library)

gistfile1.java

package eu.yesweapp.parse;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import bolts.Task;

import com.parse.DeleteCallback;
import com.parse.FindCallback;
import com.parse.FunctionCallback;
import com.parse.GetCallback;
import com.parse.LogInCallback;
import com.parse.ParseCloud;
import com.parse.ParseException;
import com.parse.ParseFile;
import com.parse.ParseObject;
import com.parse.ParseQuery;
import com.parse.ParseUser;
import com.parse.RefreshCallback;
import com.parse.SaveCallback;

/**
 * Wrapper methods to use the Parse API with Tasks (bolts library)
 * 
 * @author manuel@yesweapp.eu
 * 
 */
public class TaskHelper {

	/**
	 * @see ParseQuery#getFirstInBackground(GetCallback)
	 * @param query
	 * @return
	 */
	public static <T extends ParseObject> Task<T> firstFromLocalDatastoreAsync(ParseQuery<T> query) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		query.fromLocalDatastore();
		query.getFirstInBackground(new GetCallback<T>() {
			@Override
			public void done(T object, ParseException e) {
				if (e == null) {
					task.setResult(object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseQuery#getFirstInBackground(GetCallback)
	 * @param query
	 * @return
	 */
	public static <T extends ParseObject> Task<T> firstAsync(ParseQuery<T> query) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		query.getFirstInBackground(new GetCallback<T>() {
			@Override
			public void done(T object, ParseException e) {
				if (e == null) {
					task.setResult(object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseQuery#findInBackground(FindCallback)
	 * @param query
	 * @return
	 */
	public static <T extends ParseObject> Task<List<T>> findAsync(ParseQuery<T> query) {
		final Task<List<T>>.TaskCompletionSource task = Task.<List<T>> create();
		query.findInBackground(new FindCallback<T>() {
			@Override
			public void done(List<T> objects, ParseException e) {
				if (e == null) {
					task.setResult(objects);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#fetchFromLocalDatastore()
	 * @see ParseObject#fetchFromLocalDatastoreInBackground(GetCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> fetchFromLocalDatastoreAsync(T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.fetchFromLocalDatastoreInBackground(new GetCallback<T>() {
			@Override
			public void done(T object, ParseException e) {
				if (e == null) {
					task.setResult(object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#fetchInBackground(GetCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> fetchAsync(T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.fetchInBackground(new GetCallback<T>() {
			@Override
			public void done(T object, ParseException e) {
				if (e == null) {
					task.setResult(object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#fetchIfNeededInBackground(GetCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> fetchIfNeededAsync(T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.fetchIfNeededInBackground(new GetCallback<T>() {
			@Override
			public void done(T object, ParseException e) {
				if (e == null) {
					task.setResult(object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * 
	 * @param functionName
	 * @param params
	 * @param resultClass
	 *            type of the value returned by the call
	 * @return
	 */
	public static <T> Task<T> callFunctionAsync(String functionName, Map<String, ?> params, Class<T> resultClass) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		ParseCloud.callFunctionInBackground(functionName, params, new FunctionCallback<T>() {
			@Override
			public void done(T result, ParseException e) {
				if (e == null) {
					task.setResult(result);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#refreshInBackground(RefreshCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> refreshAsync(T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.refreshInBackground(new RefreshCallback() {
			@SuppressWarnings("unchecked")
			@Override
			public void done(ParseObject object, ParseException e) {
				if (e == null) {
					task.setResult((T) object);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseUser#logInInBackground(String, String, LogInCallback)
	 * @param username
	 * @param password
	 * @return
	 */
	public static Task<ParseUser> loginAsync(String username, String password) {
		final Task<ParseUser>.TaskCompletionSource task = Task.<ParseUser> create();
		ParseUser.logInInBackground(username, password, new LogInCallback() {
			@Override
			public void done(ParseUser user, ParseException e) {
				if (e == null) {
					task.setResult(user);
				} else {
					task.setError(e);
				}
			}
		});

		return task.getTask();
	}

	/**
	 * @see ParseObject#pinInBackground(SaveCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> pinAsync(final T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.pinInBackground(new SaveCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(obj);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#pinAllInBackground(List, SaveCallback)
	 * @param list
	 * @return A Task with the same list as passed as parameter
	 */
	public static <T extends ParseObject> Task<List<T>> pinAllAsync(final List<T> list) {
		return pinAllAsync(null, list);
	}

	/**
	 * @see ParseObject#pinAllInBackground(String, List, SaveCallback)
	 * @param pinTag
	 *            can be null
	 * @param list
	 * @return A Task with the same list as passed as parameter
	 */
	public static <T extends ParseObject> Task<List<T>> pinAllAsync(String pinTag, final List<T> list) {
		final Task<List<T>>.TaskCompletionSource task = Task.<List<T>> create();

		List<ParseObject> l = new ArrayList<ParseObject>();
		l.addAll(list);

		SaveCallback saveCallback = new SaveCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(list);
				} else {
					task.setError(e);
				}
			}
		};

		if (pinTag == null) {
			ParseObject.pinAllInBackground(l, saveCallback);
		} else {
			ParseObject.pinAllInBackground(pinTag, l, saveCallback);
		}
		return task.getTask();
	}

	/**
	 * @see ParseObject#saveInBackground(SaveCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> saveAsync(final T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.saveInBackground(new SaveCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(obj);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseFile#saveInBackground(SaveCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseFile> Task<T> saveAsync(final T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.saveInBackground(new SaveCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(obj);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#saveEventually(SaveCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> saveEventuallyAsync(final T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.saveEventually(new SaveCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(obj);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#unpinAllInBackground(String, DeleteCallback)
	 * @param pinTag
	 * @return
	 */
	public static Task<Void> unpinAsync(final String pinTag) {
		final Task<Void>.TaskCompletionSource task = Task.<Void> create();
		ParseObject.unpinAllInBackground(pinTag, new DeleteCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(null);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#unpinAllInBackground(List, DeleteCallback)
	 * @param list
	 * @return
	 */
	public static <T extends ParseObject> Task<T> unpinAsync(final List<ParseObject> list) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		ParseObject.unpinAllInBackground(list, new DeleteCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(null);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}

	/**
	 * @see ParseObject#unpinInBackground(DeleteCallback)
	 * @param obj
	 * @return
	 */
	public static <T extends ParseObject> Task<T> unpinAsync(final T obj) {
		final Task<T>.TaskCompletionSource task = Task.<T> create();
		obj.unpinInBackground(new DeleteCallback() {
			@Override
			public void done(ParseException e) {
				if (e == null) {
					task.setResult(null);
				} else {
					task.setError(e);
				}
			}
		});
		return task.getTask();
	}
}