+A CountCallback is used to run code after a ParseQuery is used to count objects matching
+ a query in a background thread.
+
+ The easiest way to use a GetCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the count is complete.
+ The done function will be run in the UI thread, while the count happens in a
+ background thread. This ensures that the UI does not freeze while the fetch happens.
+
+ For example, this sample code counts objects of class "MyClass". It calls a
+ different function depending on whether the count succeeded or not.
+
+A DeleteCallback is used to run code after saving a ParseObject in a background thread.
+
+ The easiest way to use a DeleteCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the delete is complete.
+ The done function will be run in the UI thread, while the delete happens in a
+ background thread. This ensures that the UI does not freeze while the delete happens.
+
+ For example, this sample code deletes the object myObject and calls a different
+ function depending on whether the save succeeded or not.
+
+A FindCallback is used to run code after a ParseQuery is used to fetch a list of
+ ParseObjects in a background thread.
+
+ The easiest way to use a FindCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the fetch is complete.
+ The done function will be run in the UI thread, while the fetch happens in a
+ background thread. This ensures that the UI does not freeze while the fetch happens.
+
+ For example, this sample code fetches all objects of class "MyClass". It calls a
+ different function depending on whether the fetch succeeded or not.
+
+ The easiest way to use a FunctionCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the cloud function is
+ complete. The done function will be run in the UI thread, while the fetch happens in
+ a background thread. This ensures that the UI does not freeze while the fetch happens.
+
+ For example, this sample code calls a cloud function "MyFunction" with
+ params and calls a different function depending on whether the function succeeded.
+
+A GetCallback is used to run code after a ParseQuery is used to fetch a
+ ParseObject in a background thread.
+
+ The easiest way to use a GetCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the fetch is complete.
+ The done function will be run in the UI thread, while the fetch happens in a
+ background thread. This ensures that the UI does not freeze while the fetch happens.
+
+ For example, this sample code fetches an object of class "MyClass" and id
+ myId. It calls a different function depending on whether the fetch succeeded or not.
+
+
+
+ ParseQuery<ParseObject> query = ParseQuery.getQuery("MyClass");
+ query.getInBackground(myId, new GetCallback<ParseObject>() {
+ public void done(ParseObject object, ParseException e) {
+ if (e == null) {
+ objectWasRetrievedSuccessfully(object);
+ } else {
+ objectRetrievalFailed();
+ }
+ }
+ });
+
+A GetDataCallback is used to run code after a ParseFile fetches its data on a background
+ thread.
+
+ The easiest way to use a GetDataCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the fetch is complete.
+ The done function will be run in the UI thread, while the fetch happens in a
+ background thread. This ensures that the UI does not freeze while the fetch happens.
+
+A LocationCallback is used to run code after a Location has been fetched by some
+ LocationProvider.
+
+ The easiest way to use a LocationCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the location has been
+ fetched. The done function will be run in the UI thread, while the location check
+ happens in a background thread. This ensures that the UI does not freeze while the fetch happens.
+
+ For example, this sample code defines a timeout for fetching the user's current location, and
+ provides a callback. Within the callback, the success and failure cases are handled differently.
+
+
+
+ ParseGeoPoint.getCurrentLocationAsync(1000, new LocationCallback() {
+ public void done(ParseGeoPoint geoPoint, ParseException e) {
+ if (e == null) {
+ // do something with your new ParseGeoPoint
+ } else {
+ // handle your error
+ e.printStackTrace();
+ }
+ }
+ });
+
+A LogInCallback is used to run code after logging in a user.
+
+ The easiest way to use a LogInCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the login is complete.
+ The done function will be run in the UI thread, while the login happens in a
+ background thread. This ensures that the UI does not freeze while the save happens.
+
+ For example, this sample code logs in a user and calls a different function depending on whether
+ the login succeeded or not.
+
+
+
+ ParseUser.logInInBackground("username", "password", new LogInCallback() {
+ public void done(ParseUser user, ParseException e) {
+ if (e == null && user != null) {
+ loginSuccessful();
+ } else if (user == null) {
+ usernameOrPasswordIsInvalid();
+ } else {
+ somethingWentWrong();
+ }
+ }
+ });
+
Authenticates this client as belonging to your application. This must be called before your
+ application can use the Parse library. The recommended way is to put a call to
+ Parse.initialize in each of your onCreate methods. An example:
+
+
context - The active Context for your application.
applicationId - The application id provided in the Parse dashboard.
clientKey - The client key provided in the Parse dashboard.
+
+
+
+
+
+setLogLevel
+
+public static void setLogLevel(int logLevel)
+
+
Sets the level of logging to display, where each level includes all those below it. The default
+ level is Parse.LOG_LEVEL_ERROR. Please ensure this is set to Parse.LOG_LEVEL_ERROR
+ or Parse.LOG_LEVEL_NONE before deploying your app to ensure no sensitive information is
+ logged. The levels are:
+
+A ParseACL is used to control which users can access or modify a particular object. Each
+ ParseObject can have its own ParseACL. You can grant read and write permissions
+ separately to specific users, to groups of users that belong to roles, or you can grant
+ permissions to "the public" so that, for example, any user could read a particular object but
+ only a particular set of users could write to that object.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Constructor Summary
+
+
+
ParseACL()
+
+
+ Creates an ACL with no permissions granted.
+
+
+
ParseACL(ParseUser owner)
+
+
+ Creates an ACL where only the provided user has access.
+
+
+
+
+
+
+
+
+
+Method Summary
+
+
+
+ boolean
+
getPublicReadAccess()
+
+
+ Get whether the public is allowed to read this object.
+
+
+
+ boolean
+
getPublicWriteAccess()
+
+
+ Set whether the public is allowed to write this object.
+
+
+
+ boolean
+
getReadAccess(ParseUser user)
+
+
+ Get whether the given user id is *explicitly* allowed to read this object.
+
+
+
+ boolean
+
getReadAccess(String userId)
+
+
+ Get whether the given user id is *explicitly* allowed to read this object.
+
+
+
+ boolean
+
getRoleReadAccess(ParseRole role)
+
+
+ Get whether users belonging to the given role are allowed to read this object.
+
+
+
+ boolean
+
getRoleReadAccess(String roleName)
+
+
+ Get whether users belonging to the role with the given roleName are allowed to read this
+ object.
+
+
+
+ boolean
+
getRoleWriteAccess(ParseRole role)
+
+
+ Get whether users belonging to the given role are allowed to write this object.
+
+
+
+ boolean
+
getRoleWriteAccess(String roleName)
+
+
+ Get whether users belonging to the role with the given roleName are allowed to write this
+ object.
+
+
+
+ boolean
+
getWriteAccess(ParseUser user)
+
+
+ Get whether the given user id is *explicitly* allowed to write this object.
+
+
+
+ boolean
+
getWriteAccess(String userId)
+
+
+ Get whether the given user id is *explicitly* allowed to write this object.
+
+
+
+static void
+
setDefaultACL(ParseACL acl,
+ boolean withAccessForCurrentUser)
+
+
+ Sets a default ACL that will be applied to all ParseObjects when they are created.
+
+
+
+ void
+
setPublicReadAccess(boolean allowed)
+
+
+ Set whether the public is allowed to read this object.
+
+
+
+ void
+
setPublicWriteAccess(boolean allowed)
+
+
+ Set whether the public is allowed to write this object.
+
+
+
+ void
+
setReadAccess(ParseUser user,
+ boolean allowed)
+
+
+ Set whether the given user is allowed to read this object.
+
+
+
+ void
+
setReadAccess(String userId,
+ boolean allowed)
+
+
+ Set whether the given user id is allowed to read this object.
+
+
+
+ void
+
setRoleReadAccess(ParseRole role,
+ boolean allowed)
+
+
+ Set whether users belonging to the given role are allowed to read this object.
+
+
+
+ void
+
setRoleReadAccess(String roleName,
+ boolean allowed)
+
+
+ Set whether users belonging to the role with the given roleName are allowed to read this
+ object.
+
+
+
+ void
+
setRoleWriteAccess(ParseRole role,
+ boolean allowed)
+
+
+ Set whether users belonging to the given role are allowed to write this object.
+
+
+
+ void
+
setRoleWriteAccess(String roleName,
+ boolean allowed)
+
+
+ Set whether users belonging to the role with the given roleName are allowed to write this
+ object.
+
+
+
+ void
+
setWriteAccess(ParseUser user,
+ boolean allowed)
+
+
+ Set whether the given user is allowed to write this object.
+
+
+
+ void
+
setWriteAccess(String userId,
+ boolean allowed)
+
+
+ Set whether the given user id is allowed to write this object.
Get whether the given user id is *explicitly* allowed to read this object. Even if this returns
+ false, the user may still be able to access it if getPublicReadAccess returns true or a role
+ that the user belongs to has read access.
+
Get whether the given user id is *explicitly* allowed to write this object. Even if this
+ returns false, the user may still be able to write it if getPublicWriteAccess returns true or a
+ role that the user belongs to has write access.
+
Get whether the given user id is *explicitly* allowed to read this object. Even if this returns
+ false, the user may still be able to access it if getPublicReadAccess returns true or a role
+ that the user belongs to has read access.
+
Get whether the given user id is *explicitly* allowed to write this object. Even if this
+ returns false, the user may still be able to write it if getPublicWriteAccess returns true or a
+ role that the user belongs to has write access.
+
Get whether users belonging to the role with the given roleName are allowed to read this
+ object. Even if this returns false, the role may still be able to read it if a parent
+ role has read access.
+
+
+
Parameters:
roleName - The name of the role.
+
Returns:
true if the role has read access. false otherwise.
Get whether users belonging to the role with the given roleName are allowed to write this
+ object. Even if this returns false, the role may still be able to write it if a parent
+ role has write access.
+
+
+
Parameters:
roleName - The name of the role.
+
Returns:
true if the role has write access. false otherwise.
Get whether users belonging to the given role are allowed to read this object. Even if this
+ returns false, the role may still be able to read it if a parent role has read access.
+ The role must already be saved on the server and its data must have been fetched in order to
+ use this method.
+
+
+
Parameters:
role - The role to check for access.
+
Returns:
true if the role has read access. false otherwise.
Set whether users belonging to the given role are allowed to read this object. The role must
+ already be saved on the server and its data must have been fetched in order to use this method.
+
+
+
Parameters:
role - The role to assign access.
allowed - Whether the given role can read this object.
Get whether users belonging to the given role are allowed to write this object. Even if this
+ returns false, the role may still be able to write it if a parent role has write
+ access. The role must already be saved on the server and its data must have been fetched in
+ order to use this method.
+
+
+
Parameters:
role - The role to check for access.
+
Returns:
true if the role has write access. false otherwise.
Set whether users belonging to the given role are allowed to write this object. The role must
+ already be saved on the server and its data must have been fetched in order to use this method.
+
+
+
Parameters:
role - The role to assign access.
allowed - Whether the given role can write this object.
Sets a default ACL that will be applied to all ParseObjects when they are created.
+
+
+
Parameters:
acl - The ACL to use as a template for all ParseObjects created after setDefaultACL
+ has been called. This value will be copied and used as a template for the creation of
+ new ACLs, so changes to the instance after setDefaultACL() has been called will not be
+ reflected in new ParseObjects.
withAccessForCurrentUser - If true, the ParseACL that is applied to newly-created ParseObjects will
+ provide read and write access to the ParseUser.getCurrentUser() at the time of
+ creation. If false, the provided ACL will be used without modification. If acl is
+ null, this value is ignored.
+The ParseAnalytics class provides an interface to Parse's logging and analytics backend. Methods
+ will return immediately and cache requests (+ timestamps) to be handled "eventually." That is,
+ the request will be sent immediately if possible or the next time a network connection is
+ available otherwise.
+
trackAppOpened(Intent intent)
+
+
+ Tracks this application being launched (and if this happened as the result of the user opening
+ a push notification, this method sends along information to correlate this open with that
+ push).
+
+
+
+static void
+
trackEvent(String name)
+
+
+ Tracks the occurrence of a custom event.
+
+
+
+static void
+
trackEvent(String name,
+ Map<String,String> dimensions)
+
+
+ Tracks the occurrence of a custom event with additional dimensions.
Tracks this application being launched (and if this happened as the result of the user opening
+ a push notification, this method sends along information to correlate this open with that
+ push).
+
+
+
Parameters:
intent - The Intent that started an Activity, if any. Can be null.
Tracks the occurrence of a custom event with additional dimensions. Parse will store a data
+ point at the time of invocation with the given event name. Dimensions will allow segmentation
+ of the occurrences of this custom event.
+
+ To track a user signup along with additional metadata, consider the following:
+
+Provides utility functions for working with Anonymously logged-in users. Anonymous users have
+ some unique characteristics:
+
+
Anonymous users don't need a user name or password.
+
Once logged out, an anonymous user cannot be recovered.
+
When the current user is anonymous, the following methods can be used to switch to a
+ different user or convert the anonymous user into a regular one:
+
+
signUp converts an anonymous user to a standard user with the given username and password.
+ Data associated with the anonymous user is retained.
+
logIn switches users without converting the anonymous user. Data associated with the
+ anonymous user will be lost.
+
Service logIn (e.g. Facebook, Twitter) will attempt to convert the anonymous user into a
+ standard user by linking it to the service. If a user already exists that is linked to the
+ service, it will instead switch to the existing user.
+
Service linking (e.g. Facebook, Twitter) will convert the anonymous user into a standard user
+ by linking it to the service.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Method Summary
+
+
+
+static boolean
+
isLinked(ParseUser user)
+
+
+ Whether the user is logged in anonymously.
+The ParseCloud class defines provides methods for interacting with Parse Cloud Functions. A Cloud
+ Function can be called with ParseCloud.callFunctionInBackground(String, Map, FunctionCallback)
+ using a FunctionCallback. For example, this sample code calls the "validateGame" Cloud
+ Function and calls processResponse if the call succeeded and handleError if it failed.
+
+
+ ParseCloud.callFunctionInBackground("validateGame", parameters, new FunctionCallback
+
+ Using the callback methods is usually preferred because the network operation will not block the
+ calling thread. However, in some cases it may be easier to use the
+ ParseCloud.callFunction(String, Map) call which do block the calling thread. For example, if your
+ application has already spawned a background task to perform work, that background task could use
+ the blocking calls and avoid the code complexity of callbacks.
+
params - The parameters to send to the cloud function. This map can contain anything that could
+ be placed in a ParseObject except for ParseObjects themselves.
+
Returns:
The result of the cloud call. Result may be a @{link Map}< String, ?>,
+ ParseObject, List<?>, or any type that can be set as a field in a
+ ParseObject.
+
params - The parameters to send to the cloud function. This map can contain anything that could
+ be placed in a ParseObject except for ParseObjects themselves.
callback - The callback that will be called when the cloud function has returned.
+A ParseException gets raised whenever a ParseObject issues an invalid request, such as
+ deleting or editing an object that no longer exists on the server, or when there is a network
+ failure preventing communication with the Parse server.
+
Error code indicating that something has gone wrong with the server. If you get this error
+ code, it is Parse's fault. Contact us at https://parse.com/help
+
Error code indicating a missing or invalid classname. Classnames are case-sensitive. They must
+ start with a letter, and a-zA-Z0-9_ are the only valid characters.
+
Error code indicating that badly formed JSON was received upstream. This either indicates you
+ have done something unusual with modifying how things encode to JSON, or the network is failing
+ badly.
+
Error code indicating an invalid channel name. A channel name is either an empty string (the
+ broadcast channel) or contains only a-zA-Z0-9_ characters and starts with a letter.
+
Error code indicating that an invalid filename was used for ParseFile. A valid file name
+ contains only a-zA-Z0-9_. characters and is between 1 and 128 characters.
+
link(ParseUser user,
+ Collection<String> permissions,
+ Activity activity,
+ int activityCode,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
link(ParseUser user,
+ String facebookId,
+ String accessToken,
+ Date expirationDate,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
logIn(String facebookId,
+ String accessToken,
+ Date expirationDate,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Facebook for authentication.
Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user. This method allows you to handle getting access
+ tokens for the user yourself, rather than delegating to the Facebook SDK.
+
+
+
Parameters:
user - The user to link to a Facebook account.
facebookId - The facebook ID of the user being linked.
accessToken - The access token for the user.
expirationDate - The expiration date of the access token.
callback - Callback for notifying when the new authentication data has been saved to the user.
Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user. This method delegates to the Facebook SDK's
+ authenticate() method.
+
+ IMPORTANT: Note that single sign-on authentication will not function correctly if you do
+ not include a call to the finishAuthentication() method in your onActivityResult()
+ function! Please see below for more information.
+
+ From the Facebook SDK documentation:
+
+ Starts either an Activity or a dialog which prompts the user to log in to Facebook and grant
+ the requested permissions to the given application.
+
+ This method will, when possible, use Facebook's single sign-on for Android to obtain an access
+ token. This involves proxying a call through the Facebook for Android stand-alone application,
+ which will handle the authentication flow, and return an OAuth access token for making API
+ calls.
+
+ Because this process will not be available for all users, if single sign-on is not possible,
+ this method will automatically fall back to the OAuth 2.0 User-Agent flow. In this flow, the
+ user credentials are handled by Facebook in an embedded WebView, not by the client application.
+ As such, the dialog makes a network request and renders HTML content rather than a native UI.
+ The access token is retrieved from a redirect to a special URL that the WebView handles.
+
+
+
Parameters:
user - The user to link to a Facebook account.
permissions - A list of permissions to be used when logging in. Many of these constants are defined
+ here: ParseFacebookUtils.Permissions.
activity - The Android activity in which we want to display the authorization dialog.
activityCode - Single sign-on requires an activity result to be called back to the client application
+ -- if you are waiting on other activities to return data, pass a custom activity code
+ here to avoid collisions.
callback - Callback for notifying the calling application when the Facebook authentication has
+ completed, failed, or been canceled.
Logs in a ParseUser using Facebook for authentication. If a user for the given Facebook
+ credentials does not already exist, a new user will be created. This method allows you to
+ handle getting access tokens for the user yourself, rather than delegating to the Facebook SDK.
+
+
+
Parameters:
facebookId - The facebook ID of the user being linked.
accessToken - The access token for the user.
expirationDate - The expiration date of the access token.
callback - Callback for notifying when the new authentication data has been saved to the user.
Logs in a ParseUser using Facebook for authentication. If a user for the given Facebook
+ credentials does not already exist, a new user will be created. This method delegates to the
+ Facebook SDK's authenticate() method.
+
+ IMPORTANT: Note that single sign-on authentication will not function correctly if you do
+ not include a call to the finishAuthentication() method in your onActivityResult()
+ function! Please see below for more information.
+
+ From the Facebook SDK documentation:
+
+ Starts either an Activity or a dialog which prompts the user to log in to Facebook and grant
+ the requested permissions to the given application.
+
+ This method will, when possible, use Facebook's single sign-on for Android to obtain an access
+ token. This involves proxying a call through the Facebook for Android stand-alone application,
+ which will handle the authentication flow, and return an OAuth access token for making API
+ calls.
+
+ Because this process will not be available for all users, if single sign-on is not possible,
+ this method will automatically fall back to the OAuth 2.0 User-Agent flow. In this flow, the
+ user credentials are handled by Facebook in an embedded WebView, not by the client application.
+ As such, the dialog makes a network request and renders HTML content rather than a native UI.
+ The access token is retrieved from a redirect to a special URL that the WebView handles.
+
+
+
Parameters:
permissions - A list of permissions to be used when logging in. Many of these constants are defined
+ here: ParseFacebookUtils.Permissions.
activity - The Android activity in which we want to display the authorization dialog.
activityCode - Single sign-on requires an activity result to be called back to the client application
+ -- if you are waiting on other activities to return data, pass a custom activity code
+ here to avoid collisions.
callback - Callback for notifying the calling application when the Facebook authentication has
+ completed, failed, or been canceled.
Completes authentication after the Facebook app returns an activity result. IMPORTANT:
+ This method must be invoked at the top of the calling activity's onActivityResult() function or
+ Facebook authentication will not function properly!
+
+ If your calling activity does not currently implement onActivityResult(), you must implement it
+ and include a call to this method if you intend to use the
+ ParseFacebookUtils.logIn(Activity, int, LogInCallback) or
+ ParseFacebookUtils.link(ParseUser, Activity, int, SaveCallback) methods in ParseFacebookUtilities
+ . For more information, see http://developer.android.com/reference/android/app/
+ Activity.html#onActivityResult(int, int, android.content.Intent)
+
Creates a new file from a byte array, file name, and content type. Content type will be used
+ instead of auto-detection by file extension.
+
+
+
Parameters:
name - The file's name, ideally with extension. The file name must begin with an alphanumeric
+ character, and consist of alphanumeric characters, periods, spaces, underscores, or
+ dashes.
Creates a new file from a byte array and a name. Giving a name with a proper file extension
+ (e.g. ".png") is ideal because it allows Parse to deduce the content type of the file and set
+ appropriate HTTP headers when it is fetched.
+
+
+
Parameters:
name - The file's name, ideally with extension. The file name must begin with an alphanumeric
+ character, and consist of alphanumeric characters, periods, spaces, underscores, or
+ dashes.
The filename. Before save is called, this is just the filename given by the user (if any).
+ After save is called, that name gets prefixed with a unique identifier.
+
+ParseGeoPoint represents a latitude / longitude point that may be associated with a key in a
+ ParseObject or used as a reference point for geo queries. This allows proximity based queries on
+ the key.
+
+ Only one key in a class may contain a GeoPoint.
+
+ Example:
+ ParseGeoPoint point = new ParseGeoPoint(30.0, -20.0);
+ ParseObject object = new ParseObject("PlaceObject");
+ object.put("location", point);
+ object.save();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Constructor Summary
+
+
+
ParseGeoPoint()
+
+
+ Creates a new default point with latitude and longitude set to 0.0.
+
+
+
ParseGeoPoint(double latitude,
+ double longitude)
+
+
+ Creates a new point with the specified latitude and longitude.
getCurrentLocationInBackground(long timeout,
+ LocationCallback callback)
+
+
+ Fetches the user's current location and returns a new ParseGeoPoint via the provided
+ LocationCallback.
Fetches the user's current location and returns a new ParseGeoPoint via the provided
+ LocationCallback. Defaults to a Location Criteria with no accuracy or power requirements.
+
+
+
Parameters:
timeout - The number of milliseconds to allow before timing out.
callback - callback.done(geoPoint, error) is called when a location is found.
+A specialized ImageView that downloads and displays remote images stored on Parse's
+ servers.
+
+ Given a ParseFile storing an image, a ParseImageView works seamlessly to fetch
+ the file data and display it in the background. See below for an example:
+
+
+ ParseImageView imageView = (ParseImageView) findViewById(android.R.id.icon);
+ // The placeholder will be used before and during the fetch, to be replaced by the fetched image
+ // data.
+ imageView.setPlaceholder(getResources().getDrawable(R.drawable.placeholder));
+ imageView.setParseFile(file);
+ imageView.loadInBackground(new GetDataCallback() {
+ @Override
+ public void done(byte[] data, ParseException e) {
+ Log.i("ParseImageView",
+ "Fetched! Data length: " + data.length + ", or exception: " + e.getMessage());
+ }
+ });
+
+
+
+
+
+
+
+
+
+
+
+
+
+Nested Class Summary
+
+
+
+
+
+
Nested classes/interfaces inherited from class android.widget.ImageView
Sets the placeholder to be used while waiting for an image to be loaded.
+
+
+
Parameters:
placeholder - A Drawable to be displayed while the remote image data is being fetched. This
+ value can be null, and this ImageView will simply be blank while data is
+ fetched.
Kick off downloading of remote image. When the download is finished, the image data will be
+ displayed and the completionCallback will be triggered.
+
+
+
Parameters:
completionCallback - A custom GetDataCallback to be called after the image data is fetched and this
+ ImageView displays the image.
getQuery()
+
+
+ Constructs a query for ParseInstallations.
+
+
+
+ void
+
put(String key,
+ Object value)
+
+
+ Add a key-value pair to this object.
+
+
+
+ void
+
remove(String key)
+
+
+ Removes a key from this object's data if it exists.
+
+
+
+ void
+
saveEventually(SaveCallback callback)
+
+
+ Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
+
+
+
+
+
+
Methods inherited from class com.parse.ParseObject
Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible. Use this when you may not have a solid network connection, and don't
+ need to know when the save completes. If there is some problem with the object such that it
+ can't be saved, it will be silently discarded. Objects saved with this method will be stored
+ locally in an on-disk cache until they can be delivered to Parse. They will be sent immediately
+ if possible. Otherwise, they will be sent the next time a network connection is available.
+ Objects saved this way will persist even after the app is closed, in which case they will be
+ sent the next time the app is opened. If more than 10MB of data is waiting to be sent,
+ subsequent calls to saveEventually or deleteEventually will cause old saves to be silently
+ discarded until the connection can be re-established, and the queued objects can be saved.
+
+The ParseObject is a local representation of data that can be saved and retrieved from the Parse
+ cloud.
+
+ The basic workflow for creating new data is to construct a new ParseObject, use put() to fill it
+ with data, and then use save() to persist to the database.
+
+ The basic workflow for accessing existing data is to use a ParseQuery to specify which
+ existing data to retrieve.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Constructor Summary
+
+
+
+protected
+
ParseObject()
+
+
+ The base class constructor to call in subclasses.
+
+
+
+
+
ParseObject(String theClassName)
+
+
+ Constructs a new ParseObject with no data in it.
+
+
+
+
+
+
+
+
+
+Method Summary
+
+
+
+ void
+
add(String key,
+ Object value)
+
+
+ Atomically adds an object to the end of the array associated with a given key.
+
+
+
+ void
+
addAll(String key,
+ Collection<?> values)
+
+
+ Atomically adds the objects contained in a Collection to the end of the array
+ associated with a given key.
+
+
+
+ void
+
addAllUnique(String key,
+ Collection<?> values)
+
+
+ Atomically adds the objects contained in a Collection to the array associated with a
+ given key, only adding elements which are not already present in the array.
+
+
+
+ void
+
addUnique(String key,
+ Object value)
+
+
+ Atomically adds an object to the array associated with a given key, only if it is not already
+ present in the array.
+
+
+
+ boolean
+
containsKey(String key)
+
+
+ Whether this object has a particular key.
createWithoutData(Class<T> subclass,
+ String objectId)
+
+
+ Creates a reference to an existing ParseObject for use in creating associations between
+ ParseObjects.
createWithoutData(String className,
+ String objectId)
+
+
+ Creates a reference to an existing ParseObject for use in creating associations between
+ ParseObjects.
deleteEventually()
+
+
+ Deletes this object from the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
+
+
+
+ void
+
deleteEventually(DeleteCallback callback)
+
+
+ Deletes this object from the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
+
+
+
+ void
+
deleteInBackground()
+
+
+ Deletes this object on the server in a background thread.
getCreatedAt()
+
+
+ This reports time as the server sees it, so that if you create a ParseObject, then wait a
+ while, and then call save(), the creation time will be the time of the first save() call rather
+ than the time the object was created locally.
getUpdatedAt()
+
+
+ This reports time as the server sees it, so that if you make changes to a ParseObject, then
+ wait a while, and then call save(), the updated time will be the time of the save() call rather
+ than the time the object was changed locally.
+
+
+
+ boolean
+
has(String key)
+
+
+ Whether this object has a particular key.
registerSubclass(Class<? extends ParseObject> subclass)
+
+
+ Registers a custom subclass type with the Parse SDK, enabling strong-typing of those
+ ParseObjects whenever they appear.
+
+
+
+ void
+
remove(String key)
+
+
+ Removes a key from this object's data if it exists.
+
+
+
+ void
+
removeAll(String key,
+ Collection<?> values)
+
+
+ Atomically removes all instances of the objects contained in a Collection from the
+ array associated with a given key.
saveEventually()
+
+
+ Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
+
+
+
+ void
+
saveEventually(SaveCallback callback)
+
+
+ Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
+
+
+
+ void
+
saveInBackground()
+
+
+ Saves this object to the server in a background thread.
Constructs a new ParseObject with no data in it. A ParseObject constructed in this way will not
+ have an objectId and will not persist to the database until save() is called.
+
+ Class names must be alphanumerical plus underscore, and start with a letter. It is recommended
+ to name classes in CamelCaseLikeThis.
+
+
+
Parameters:
theClassName - The className for this ParseObject.
Creates a new ParseObject based upon a class name. If the class name is a special type (e.g.
+ for ParseUser), then the appropriate type of ParseObject is returned.
+
+
+
Parameters:
className - The class of object to create.
+
Returns:
A new ParseObject for the given class name.
+
+
+
+
+
+create
+
+public static <T extends ParseObject> T create(Class<T> subclass)
+
+
Creates a new ParseObject based upon a subclass type. Note that the object will be created
+ based upon the ParseClassName of the given subclass type. For example, calling
+ create(ParseUser.class) may create an instance of a custom subclass of ParseUser.
+
+
+
Parameters:
subclass - The class of object to create.
+
Returns:
A new ParseObject based upon the class name of the given subclass type.
Registers a custom subclass type with the Parse SDK, enabling strong-typing of those
+ ParseObjects whenever they appear. Subclasses must specify the ParseClassName
+ annotation and have a default constructor.
+
Returns a set view of the keys contained in this object. This does not include createdAt,
+ updatedAt, authData, or objectId. It does include things like username and ACL.
+
This reports time as the server sees it, so that if you make changes to a ParseObject, then
+ wait a while, and then call save(), the updated time will be the time of the save() call rather
+ than the time the object was changed locally.
+
+
+
+
Returns:
The last time this object was updated on the server.
This reports time as the server sees it, so that if you create a ParseObject, then wait a
+ while, and then call save(), the creation time will be the time of the first save() call rather
+ than the time the object was created locally.
+
+
+
+
Returns:
The first time this object was saved on the server.
+
+
+
+
+
+isDirty
+
+public boolean isDirty()
+
+
Whether any key-value pair in this object (or its children) has been added/updated/removed
+ and not saved yet.
+
+
+
+
Returns:
Returns whether this object has been altered and not saved yet.
Accessor to the object id. An object id is assigned as soon as an object is saved to the
+ server. The combination of a className and an objectId uniquely identifies an object in your
+ application.
+
Setter for the object id. In general you do not need to use this. However, in some cases this
+ can be convenient. For example, if you are serializing a ParseObject yourself and wish to
+ recreate it, you can use this to recreate the ParseObject exactly.
+
ParseException - Throws an exception if the server is inaccessible.
+
+
+
+
+
+saveInBackground
+
+public final void saveInBackground(SaveCallback callback)
+
+
Saves this object to the server in a background thread. This is preferable to using save(),
+ unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(e) is called when the save completes.
+
+
+
+
+
+saveInBackground
+
+public final void saveInBackground()
+
+
Saves this object to the server in a background thread. Use this when you do not have code to
+ run on completion of the push.
+
+
+
+
+
+
+
+
+saveEventually
+
+public final void saveEventually()
+
+
Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible. Use this when you may not have a solid network connection, and don't
+ need to know when the save completes. If there is some problem with the object such that it
+ can't be saved, it will be silently discarded. Objects saved with this method will be stored
+ locally in an on-disk cache until they can be delivered to Parse. They will be sent immediately
+ if possible. Otherwise, they will be sent the next time a network connection is available.
+ Objects saved this way will persist even after the app is closed, in which case they will be
+ sent the next time the app is opened. If more than 10MB of data is waiting to be sent,
+ subsequent calls to saveEventually or deleteEventually will cause old saves to be silently
+ discarded until the connection can be re-established, and the queued objects can be saved.
+
Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible. Use this when you may not have a solid network connection, and don't
+ need to know when the save completes. If there is some problem with the object such that it
+ can't be saved, it will be silently discarded. Objects saved with this method will be stored
+ locally in an on-disk cache until they can be delivered to Parse. They will be sent immediately
+ if possible. Otherwise, they will be sent the next time a network connection is available.
+ Objects saved this way will persist even after the app is closed, in which case they will be
+ sent the next time the app is opened. If more than 10MB of data is waiting to be sent,
+ subsequent calls to saveEventually or deleteEventually will cause old saves to be silently
+ discarded until the connection can be re-established, and the queued objects can be saved.
+
+
+
Parameters:
callback - - A callback which will be called if the save completes before the app exits.
+
+
+
+
+
+deleteEventually
+
+public final void deleteEventually()
+
+
Deletes this object from the server at some unspecified time in the future, even if Parse is
+ currently inaccessible. Use this when you may not have a solid network connection, and don't
+ need to know when the delete completes. If there is some problem with the object such that it
+ can't be deleted, the request will be silently discarded. Delete requests made with this method
+ will be stored locally in an on-disk cache until they can be transmitted to Parse. They will be
+ sent immediately if possible. Otherwise, they will be sent the next time a network connection
+ is available. Delete instructions saved this way will persist even after the app is closed, in
+ which case they will be sent the next time the app is opened. If more than 10MB of commands are
+ waiting to be sent, subsequent calls to deleteEventually or saveEventually will cause old
+ instructions to be silently discarded until the connection can be re-established, and the
+ queued objects can be saved.
+
+
+
+
+
+
+
+
+deleteEventually
+
+public final void deleteEventually(DeleteCallback callback)
+
+
Deletes this object from the server at some unspecified time in the future, even if Parse is
+ currently inaccessible. Use this when you may not have a solid network connection, and don't
+ need to know when the delete completes. If there is some problem with the object such that it
+ can't be deleted, the request will be silently discarded. Delete requests made with this method
+ will be stored locally in an on-disk cache until they can be transmitted to Parse. They will be
+ sent immediately if possible. Otherwise, they will be sent the next time a network connection
+ is available. Delete instructions saved this way will persist even after the app is closed, in
+ which case they will be sent the next time the app is opened. If more than 10MB of commands are
+ waiting to be sent, subsequent calls to deleteEventually or saveEventually will cause old
+ instructions to be silently discarded until the connection can be re-established, and the
+ queued objects can be saved.
+
+
+
Parameters:
callback - - A callback which will be called if the delete completes before the app exits.
Refreshes this object with the data from the server. Call this whenever you want the state of
+ the object to reflect exactly what is on the server.
+
+
+
+
Throws:
+
ParseException - Throws an exception if the server is inaccessible.
+
+
+
+
+
+refreshInBackground
+
+public final void refreshInBackground(RefreshCallback callback)
+
+
Refreshes this object with the data from the server in a background thread. This is preferable
+ to using refresh(), unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(object, e) is called when the refresh completes.
Fetches this object with the data from the server in a background thread. This is preferable to
+ using fetch(), unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(object, e) is called when the fetch completes.
If this ParseObject has not been fetched (i.e. ParseObject.isDataAvailable() returns false),
+ fetches this object with the data from the server.
+
+
+
+
Returns:
The fetched ParseObject.
+
Throws:
+
ParseException - Throws an exception if the server is inaccessible.
+
+
+
+
+
+fetchIfNeededInBackground
+
+public final <T extends ParseObject> void fetchIfNeededInBackground(GetCallback<T> callback)
+
+
If this ParseObject has not been fetched (i.e. ParseObject.isDataAvailable() returns false),
+ fetches this object with the data from the server in a background thread. This is preferable to
+ using ParseObject.fetchIfNeeded(), unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(object, e) is called when the fetch completes.
Deletes this object on the server. This does not delete or destroy the object locally.
+
+
+
+
Throws:
+
ParseException - Throws an error if the object does not exist or if the internet fails.
+
+
+
+
+
+deleteInBackground
+
+public final void deleteInBackground(DeleteCallback callback)
+
+
Deletes this object on the server in a background thread. This is preferable to using delete(),
+ unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(e) is called when the save completes.
+
+
+
+
+
+deleteInBackground
+
+public final void deleteInBackground()
+
+
Deletes this object on the server in a background thread. Does nothing in particular when the
+ save completes. Use this when you don't care if the delete works.
+
Saves each object in the provided list to the server in a background thread. This is preferable
+ to using saveAll, unless your code is already running from a background thread.
+
+
+
Parameters:
objects - The objects to save.
callback - callback.done(e) is called when the save completes.
Saves each object to the server in a background thread. Does nothing in particular when the
+ save completes. Use this when you don't care if the save works.
+
Atomically adds an object to the array associated with a given key, only if it is not already
+ present in the array. The position of the insert is not guaranteed.
+
Atomically adds the objects contained in a Collection to the array associated with a
+ given key, only adding elements which are not already present in the array. The position of the
+ insert is not guaranteed.
+
Atomically removes all instances of the objects contained in a Collection from the
+ array associated with a given key. To maintain consistency with the Java Collection API, there
+ is no method removing all instances of a single object. Instead, you can call
+ parseObject.removeAll(key, Arrays.asList(value)).
+
Access a ParseFile value. This function will not perform a network request. Unless the
+ ParseFile has been downloaded (e.g. by calling ParseFile.getData()),
+ ParseFile.isDataAvailable() will return false.
+
+
+
Parameters:
key - The key to access the value for.
+
Returns:
Returns null if there is no such key or if it is not a ParseFile.
+The ParsePush is a local representation of data that can be sent as a push notification.
+
+ The typical workflow for sending a push notification from the client is to construct a new
+ ParsePush, use the setter functions to fill it with data, and then use
+ ParsePush.sendInBackground() to send it.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Constructor Summary
+
+
+
ParsePush()
+
+
+ Creates a new push notification.
+
+
+
+
+
+
+
+
+
+Method Summary
+
+
+
+ void
+
clearExpiration()
+
+
+ Clears both expiration values, indicating that the notification should never expire.
+
+
+
+ void
+
send()
+
+
+ Sends this push notification while blocking this thread until the push notification has
+ successfully reached the Parse servers.
A helper method to concisely send a push message to a query. This method is equivalent to
+ ParsePush push = new ParsePush(); push.setMessage(message); push.setQuery(query);
+ push.sendInBackground();
+
+
+
Parameters:
message - The message that will be shown in the notification.
query - A ParseInstallation query which specifies the recipients of a push.
A helper method to concisely send a push message to a query. This method is equivalent to
+ ParsePush push = new ParsePush(); push.setMessage(message); push.setQuery(query);
+ push.sendInBackground(callback);
+
+
+
Parameters:
message - The message that will be shown in the notification.
query - A ParseInstallation query which specifies the recipients of a push.
callback - callback.done(e) is called when the send completes.
A helper method to concisely send a push to a query. This method is equivalent to ParsePush
+ push = new ParsePush(); push.setData(data); push.setQuery(query); push.sendInBackground();
+
+
+
Parameters:
data - The entire data of the push message. See the push guide for more details on the data
+ format.
query - A ParseInstallation query which specifies the recipients of a push.
A helper method to concisely send a push to a query. This method is equivalent to ParsePush
+ push = new ParsePush(); push.setData(data); push.setQuery(query);
+ push.sendInBackground(callback);
+
+
+
Parameters:
data - The entire data of the push message. See the push guide for more details on the data
+ format.
query - A ParseInstallation query which specifies the recipients of a push.
callback - callback.done(e) is called when the send completes.
Sets the channel on which this push notification will be sent. The channel name must start with
+ a letter and contain only letters, numbers, dashes, and underscores. A push can either have
+ channels or a query. Setting this will unset the query.
+
Sets the collection of channels on which this push notification will be sent. Each channel name
+ must start with a letter and contain only letters, numbers, dashes, and underscores. A push can
+ either have channels or a query. Setting this will unset the query.
+
Sets the query for this push for which this push notification will be sent. This query will be
+ executed in the Parse cloud; this push notification will be sent to Installations which this
+ query yields. A push can either have channels or a query. Setting this will unset the channels.
+
+
+
Parameters:
query - A query to which this push should target. This must be a ParseInstallation query.
+
+
+
+
+
+setExpirationTime
+
+public void setExpirationTime(long time)
+
+
Sets a UNIX epoch timestamp at which this notification should expire, in seconds (UTC). This
+ notification will be sent to devices which are either online at the time the notification is
+ sent, or which come online before the expiration time is reached. Because device clocks are not
+ guaranteed to be accurate, most applications should instead use
+ ParsePush.setExpirationTimeInterval(long).
+
Sets the time interval after which this notification should expire, in seconds. This
+ notification will be sent to devices which are either online at the time the notification is
+ sent, or which come online within the given number of seconds of the notification being
+ received by Parse's server. An interval which is less than or equal to zero indicates that the
+ message should only be sent to devices which are currently online.
+
+
+
+
+
+
+
+
+clearExpiration
+
+public void clearExpiration()
+
+
Clears both expiration values, indicating that the notification should never expire.
+
Sets the entire data of the push message. See the push guide for more details on the data
+ format. This will overwrite any data specified in ParsePush.setMessage(String).
+
Sends this push notification while blocking this thread until the push notification has
+ successfully reached the Parse servers. Typically, you should use ParsePush.sendInBackground()
+ instead of this, unless you are managing your own threading.
+
+
+
+
Throws:
+
ParseException - Throws an exception if the server is inaccessible.
Sends this push notification in a background thread. This is preferable to using
+ send(), unless your code is already running from a background thread.
+
+
+
Parameters:
callback - callback.done(e) is called when the send completes.
+
+
+
+
+
+sendInBackground
+
+public void sendInBackground()
+
+
Sends this push notification in a background thread. Use this when you do not have code to run
+ on completion of the push.
+
Returns an array containing the constants of this enum type, in
+the order they are declared. This method may be used to iterate
+over the constants as follows:
+
+for (ParseQuery.CachePolicy c : ParseQuery.CachePolicy.values())
+ System.out.println(c);
+
+
+
+
+
Returns:
an array containing the constants of this enum type, in
+the order they are declared
Returns the enum constant of this type with the specified name.
+The string must match exactly an identifier used to declare an
+enum constant in this type. (Extraneous whitespace characters are
+not permitted.)
+
+
+
Parameters:
name - the name of the enum constant to be returned.
+
+The ParseQuery class defines a query that is used to fetch ParseObjects. The most common use case
+ is finding all objects that match a query through the findInBackground
+ method, using a FindCallback. For example, this sample code fetches all objects of class
+ "MyClass". It calls a different function depending on whether the fetch succeeded or
+ not.
+
+
+
+ A ParseQuery can also be used to retrieve a single object whose id is known, through the
+ getInBackground method, using a GetCallback. For example, this
+ sample code fetches an object of class "MyClass" and id myId. It calls
+ a different function depending on whether the fetch succeeded or not.
+
+
+ ParseQuery<ParseObject> query = ParseQuery.getQuery("MyClass");
+ query.getInBackground(myId, new GetCallback<ParseObject>() {
+ public void done(ParseObject object, ParseException e) {
+ if (e == null) {
+ objectWasRetrievedSuccessfully(object);
+ } else {
+ objectRetrievalFailed();
+ }
+ }
+ }
+
+
+ A ParseQuery can also be used to count the number of objects that match the query without
+ retrieving all of those objects. For example, this sample code counts the number of objects of
+ the class "MyClass".
+
+
+
+ Using the callback methods is usually preferred because the network operation will not block the
+ calling thread. However, in some cases it may be easier to use the find,
+ get or count calls, which do block the calling thread. For example,
+ if your application has already spawned a background task to perform work, that background task
+ could use the blocking calls and avoid the code complexity of callbacks.
+
getFirst()
+
+
+ Retrieves at most one ParseObject that satisfies this query.
+
+
+
+ void
+
getFirstInBackground(GetCallback<T> callback)
+
+
+ Retrieves at most one ParseObject that satisfies this query from the server in a background
+ thread.
+
+
+
+ void
+
getInBackground(String objectId,
+ GetCallback<T> callback)
+
+
+ Constructs a ParseObject whose id is already known by fetching data from the server in a
+ background thread.
whereContainedIn(String key,
+ Collection<? extends Object> values)
+
+
+ Add a constraint to the query that requires a particular key's value to be contained in the
+ provided list of values.
whereContainsAll(String key,
+ Collection<?> values)
+
+
+ Add a constraint to the query that requires a particular key's value match another ParseQuery.
whereDoesNotMatchKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match any value
+ for a key in the results of another ParseQuery.
whereDoesNotMatchQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match another
+ ParseQuery.
whereEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be equal to the
+ provided value.
whereGreaterThan(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be greater than the
+ provided value.
whereGreaterThanOrEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be greater than or
+ equal to the provided value.
whereLessThan(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be less than the
+ provided value.
whereLessThanOrEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be less than or equal
+ to the provided value.
whereMatches(String key,
+ String regex)
+
+
+ Add a regular expression constraint for finding string values that match the provided regular
+ expression.
whereMatchesKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value matches a value for a key
+ in the results of another ParseQuery
whereMatchesQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value match another ParseQuery.
whereNotContainedIn(String key,
+ Collection<? extends Object> values)
+
+
+ Add a constraint to the query that requires a particular key's value not be contained in the
+ provided list of values.
whereNotEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be not equal to the
+ provided value.
whereWithinGeoBox(String key,
+ ParseGeoPoint southwest,
+ ParseGeoPoint northeast)
+
+
+ Add a constraint to the query that requires a particular key's coordinates be contained within
+ a given rectangular geographic bounding box.
whereWithinKilometers(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
whereWithinMiles(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
whereWithinRadians(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
Constructs a query for a ParseObject subclass type. A default query with no further parameters
+ will retrieve all ParseObjects of the provided class.
+
+
+
Parameters:
subclass - The ParseObject subclass type to retrieve.
Creates a new query for the given ParseObject subclass type. A default query with no further
+ parameters will retrieve all ParseObjects of the provided class.
+
+
+
Parameters:
subclass - The ParseObject subclass type to retrieve.
+
Creates a new query for the given class name. A default query with no further parameters will
+ retrieve all ParseObjects of the provided class name.
+
+
+
Parameters:
className - The name of the class to retrieve ParseObjects for.
+
Retrieves at most one ParseObject that satisfies this query. Uses the network and/or the cache,
+ depending on the cache policy. This mutates the ParseQuery.
+
+
+
+
Returns:
A ParseObject obeying the conditions set in this query, or null if none found.
+
Throws:
+
ParseException - Throws a ParseException if no object is found.
Retrieves a list of ParseObjects that satisfy this query from the server in a background
+ thread. This is preferable to using find(), unless your code is already running in a background
+ thread.
+
+
+
Parameters:
callback - callback.done(objectList, e) is called when the find completes.
Retrieves at most one ParseObject that satisfies this query from the server in a background
+ thread. This is preferable to using getFirst(), unless your code is already running in a
+ background thread. This mutates the ParseQuery.
+
+
+
Parameters:
callback - callback.done(object, e) is called when the find completes.
Constructs a ParseObject whose id is already known by fetching data from the server. This
+ mutates the ParseQuery.
+
+
+
Parameters:
objectId - Object id of the ParseObject to fetch.
+
Throws:
+
ParseException - Throws an exception when there is no such object or when the network connection
+ fails.
+
+
+
+
+
+hasCachedResult
+
+public boolean hasCachedResult()
+
+
Returns whether or not this query has a cached result.
+
+
+
+
+
+
+
+
+clearCachedResult
+
+public void clearCachedResult()
+
+
Removes the previously cached result for this query, forcing the next find() to hit the
+ network. If there is no cached result for this query, then this is a no-op.
+
Constructs a ParseObject whose id is already known by fetching data from the server in a
+ background thread. This does not use caching. This is preferable to using the
+ ParseObject(className, objectId) constructor, unless your code is already running in a
+ background thread.
+
+
+
Parameters:
objectId - Object id of the ParseObject to fetch.
callback - callback.done(object, e) will be called when the fetch completes.
Add a constraint to the query that requires a particular key's value match another ParseQuery.
+ This only works on keys whose values are ParseObjects or lists of ParseObjects. Add a
+ constraint to the query that requires a particular key's value to contain every one of the
+ provided list of values.
+
+
+
Parameters:
key - The key to check. This key's value must be an array.
Add a constraint to the query that requires a particular key's value match another ParseQuery.
+ This only works on keys whose values are ParseObjects or lists of ParseObjects.
+
Add a constraint to the query that requires a particular key's value does not match another
+ ParseQuery. This only works on keys whose values are ParseObjects or lists of ParseObjects.
+
+
+
Parameters:
key - The key to check.
query - The query that the value should not match
+
Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given. Radius of earth used is 3958.8 miles.
+
+
+
Parameters:
key - The key that the ParseGeoPoint is stored in.
point - The reference ParseGeoPoint that is used.
maxDistance - Maximum distance (in miles) of results to return.
+
Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given. Radius of earth used is 6371.0 kilometers.
+
+
+
Parameters:
key - The key that the ParseGeoPoint is stored in.
point - The reference ParseGeoPoint that is used.
maxDistance - Maximum distance (in kilometers) of results to return.
+
Add a constraint for finding string values that start with a provided string. This query will
+ use the backend index, so it will be fast even for large datasets.
+
+
+
Parameters:
key - The key that the string to match is stored in.
prefix - The substring that the value must start with.
+
Restrict the fields of returned ParseObjects to only include the provided keys. If this is
+ called multiple times, then all of the keys specified in each of the calls will be included.
+
Also sorts the results in descending order by the given key. The previous sort keys have
+ precedence over this key.
+
+
+
Parameters:
key - The key to order by
+
Returns:
Returns the query so you can chain this call.
+
+
+
+
+
+setLimit
+
+public void setLimit(int newLimit)
+
+
Controls the maximum number of results that are returned. Setting a negative limit denotes
+ retrieval without a limit. The default limit is 100, with a maximum of 1000 results being
+ returned at a time.
+
+
+
Parameters:
newLimit -
+
+
+
+
+
+setTrace
+
+public void setTrace(boolean shouldTrace)
+
+
Turn on performance tracing of finds. If performance tracing is already turned on this does
+ nothing. In general you don't need to call trace.
+
+
+
+
+
+
+
+
+getLimit
+
+public int getLimit()
+
+
Accessor for the limit.
+
+
+
+
+
+
+
+
+setSkip
+
+public void setSkip(int newSkip)
+
+
Controls the number of results to skip before returning any results. This is useful for
+ pagination. Default is to skip zero results.
+
+A ParseQueryAdapter handles the fetching of objects by page, and displaying objects as views in a
+ ListView.
+
+ This class is highly configurable, but also intended to be easy to get started with. See below
+ for an example of using a ParseQueryAdapter inside an Activity's onCreate:
+
+
+ final ParseQueryAdapter adapter = new ParseQueryAdapter(this, "TestObject");
+ adapter.setTextKey("name");
+
+ ListView listView = (ListView) findViewById(R.id.listview);
+ listView.setAdapter(adapter);
+
+
+ Below, an example showing off the level of configuration available with this class:
+
+
+ // Instantiate a QueryFactory to define the ParseQuery to be used for fetching items in this
+ // Adapter.
+ ParseQueryAdapter.QueryFactory<ParseObject> factory =
+ new ParseQueryAdapter.QueryFactory<ParseObject>() {
+ public ParseQuery create() {
+ ParseQuery query = new ParseQuery("Customer");
+ query.whereEqualTo("activated", true);
+ query.orderByDescending("moneySpent");
+ return query;
+ }
+ };
+
+ // Pass the factory into the ParseQueryAdapter's constructor.
+ ParseQueryAdapter<ParseObject> adapter = new ParseQueryAdapter<ParseObject>(this, factory);
+ adapter.setTextKey("name");
+
+ // Perhaps set a callback to be fired upon successful loading of a new set of ParseObjects.
+ adapter.addOnQueryLoadListener(new OnQueryLoadListener<ParseObject>() {
+ public void onLoading() {
+ // Trigger any "loading" UI
+ }
+
+ public void onLoaded(List<ParseObject> objects, ParseException e) {
+ // Execute any post-loading logic, hide "loading" UI
+ }
+ });
+
+ // Attach it to your ListView, as in the example above
+ ListView listView = (ListView) findViewById(R.id.listview);
+ listView.setAdapter(adapter);
+
getNextPageView(View v,
+ ViewGroup parent)
+
+
+ Override this method to customize the "Load Next Page" cell, visible when pagination is turned
+ on and there may be more results to display.
getView(int position,
+ View convertView,
+ ViewGroup parent)
+
+
+ The base class, Adapter, defines a getView method intended to display data at
+ the specified position in the data set.
Constructs a ParseQueryAdapter. Given a ParseObject subclass, this adapter will fetch and
+ display all ParseObjects of the specified class, ordered by creation time.
+
+
+
Parameters:
context - The activity utilizing this adapter.
clazz - The ParseObject subclass type to fetch and display.
Constructs a ParseQueryAdapter. Given a ParseObject subclass, this adapter will fetch and
+ display all ParseObjects of the specified class, ordered by creation time.
+
+
+
Parameters:
context - The activity utilizing this adapter.
className - The name of the Parse class of ParseObjects to display.
Constructs a ParseQueryAdapter. Given a ParseObject subclass, this adapter will fetch and
+ display all ParseObjects of the specified class, ordered by creation time.
+
+
+
Parameters:
context - The activity utilizing this adapter.
clazz - The ParseObject subclass type to fetch and display.
itemViewResource - A resource id that represents the layout for an item in the AdapterView.
+
+
+
+
+ParseQueryAdapter
+
+public ParseQueryAdapter(Context context,
+ String className,
+ int itemViewResource)
+
+
Constructs a ParseQueryAdapter. Given a ParseObject subclass, this adapter will fetch and
+ display all ParseObjects of the specified class, ordered by creation time.
+
+
+
Parameters:
context - The activity utilizing this adapter.
className - The name of the Parse class of ParseObjects to display.
itemViewResource - A resource id that represents the layout for an item in the AdapterView.
Clears the table and loads the first page of objects asynchronously. This method is called
+ automatically when this Adapter is attached to an AdapterView.
+
+ loadObjects() should only need to be called if ParseQueryAdapter.setAutoload(boolean) is set to
+ false.
+
+
+
+
+
+
+
+
+loadNextPage
+
+public void loadNextPage()
+
+
Loads the next page of objects, appends to table, and notifies the UI that the model has
+ changed.
+
+
+
+
+
+
+
+
+getCount
+
+public int getCount()
+
+
Overrides Adapter's ParseQueryAdapter.getCount() method to return the number of cells to
+ display. If pagination is turned on, this count will include an extra +1 count for the
+ pagination cell row.
+
+
+
+
Returns:
The number of cells to be displayed by the ListView.
Override this method to customize each cell given a ParseObject.
+
+ If a view is not provided, a default view will be created based upon
+ android.R.layout.activity_list_item.
+
+ This method expects a TextView with id android.R.id.text1 in your object views.
+ If ParseQueryAdapter.setImageKey(String) was used, this method also expects an ImageView with id
+ android.R.id.icon.
+
+ This method displays the text value specified by the text key (set via
+ ParseQueryAdapter.setTextKey(String)) and an image (described by a ParseFile, under the key set
+ via ParseQueryAdapter.setImageKey(String)) if applicable. If the text key is not set, the value for
+ ParseObject.getObjectId() will be displayed instead.
+
+
+
Parameters:
object - The ParseObject associated with this item.
v - The View associated with this row. This view, if non-null, is being recycled
+ and intended to be used for displaying this item.
parent - The parent that this view will eventually be attached to
+
Returns:
The customized view displaying the ParseObject's information.
Override this method to customize the "Load Next Page" cell, visible when pagination is turned
+ on and there may be more results to display.
+
+ This method expects a TextView with id android.R.id.text1.
+
+
+
Parameters:
v - The view object associated with this row + type (a "Next Page" view, instead of an
+ "Item" view).
parent - The parent that this view will eventually be attached to
+
Returns:
The view object that allows the user to paginate.
+
+
+
+
+
+getView
+
+public final ViewgetView(int position,
+ View convertView,
+ ViewGroup parent)
Sets a placeholder image to be used when fetching data for each item in the AdapterView
+ . Will not be used if ParseQueryAdapter.setImageKey(String) was not used to define which images to
+ display.
+
+
+
Parameters:
placeholder - A Drawable to be displayed while the remote image data is being fetched. This
+ value can be null, and ImageViews in this AdapterView will simply be blank
+ while data is being fetched.
+
+
+
+
+
+setAutoload
+
+public void setAutoload(boolean autoload)
+
+
Enable or disable the automatic loading of results upon attachment to an AdapterView.
+ Defaults to true.
+
+A class that is used to access all of the children of a many-to-many relationship. Each instance
+ of Parse.Relation is associated with a particular parent object and key.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Method Summary
+
+
+
+ void
+
add(T object)
+
+
+ Adds an object to this relation.
+Represents a Role on the Parse server. ParseRoles represent groupings of
+ ParseUsers for the purposes of granting permissions (e.g. specifying a ParseACL
+ for a ParseObject). Roles are specified by their sets of child users and child roles, all
+ of which are granted any permissions that the parent role has.
+
+ Roles must have a name (which cannot be changed after creation of the role), and must specify an
+ ACL.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Constructor Summary
+
+
+
ParseRole(String name)
+
+
+ Constructs a new ParseRole with the given name.
+
+
+
ParseRole(String name,
+ ParseACL acl)
+
+
+ Constructs a new ParseRole with the given name.
Sets the name for a role. This value must be set before the role has been saved to the server,
+ and cannot be set once the role has been saved.
+
+ A role's name can only contain alphanumeric characters, _, -, and spaces.
+
Gets the ParseRelation for the ParseUsers that are direct children of this
+ role. These users are granted any privileges that this role has been granted (e.g. read or
+ write access through ACLs). You can add or remove users from the role through this relation.
+
+
+
+
Returns:
the relation for the users belonging to this role.
Gets the ParseRelation for the ParseRoles that are direct children of this
+ role. These roles' users are granted any privileges that this role has been granted (e.g. read
+ or write access through ACLs). You can add or remove child roles from this role through this
+ relation.
+
+
+
+
Returns:
the relation for the roles belonging to this role.
link(ParseUser user,
+ Context context,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
link(ParseUser user,
+ String twitterId,
+ String screenName,
+ String authToken,
+ String authTokenSecret,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
+
+
+
+static void
+
logIn(Context context,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Twitter for authentication.
+
+
+
+static void
+
logIn(String twitterId,
+ String screenName,
+ String authToken,
+ String authTokenSecret,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Twitter for authentication.
+
+
+
+static void
+
unlink(ParseUser user)
+
+
+ Unlinks a user from a Twitter account.
Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user. A dialog will be shown to the user for Twitter
+ authentication.
+
+
+
Parameters:
user - The user to link to a Twitter account.
context - An Android context from which the login dialog can be launched.
callback - Callback for notifying the calling application when the Twitter authentication has
+ completed, failed, or been canceled.
Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user. This method allows you to handle getting the
+ auth tokens for your users, rather than delegating to the provided dialog log-in.
+
+
+
Parameters:
user - The user to link to a Twitter account.
twitterId - The user's Twitter ID.
screenName - The user's Twitter screen name.
authToken - The auth token for the session.
authTokenSecret - The auth token secret for the session.
callback - Callback for notifying that the authentication data has been saved to the ParseUser.
Logs in a ParseUser using Twitter for authentication. If a user for the given Twitter
+ credentials does not already exist, a new user will be created. This method allows you to
+ handle getting the auth tokens for your users, rather than delegating to the provided dialog
+ log-in.
+
+
+
Parameters:
twitterId - The user's Twitter ID.
screenName - The user's Twitter screen name.
authToken - The auth token for the session.
authTokenSecret - The auth token secret for the session.
callback - Callback for notifying that the authentication data has been saved to the ParseUser.
Logs in a ParseUser using Twitter for authentication. If a user for the given Twitter
+ credentials does not already exist, a new user will be created. A dialog will be shown to the
+ user for Twitter authentication.
+
+
+
Parameters:
context - An Android context from which the login dialog can be launched.
callback - Callback for notifying the calling application when the Twitter authentication has
+ completed, failed, or been canceled.
isAuthenticated()
+
+
+ Whether the ParseUser has been authenticated on this device.
+
+
+
+ boolean
+
isNew()
+
+
+ Indicates whether this ParseUser was created during this session through a call to
+ ParseUser.signUp() or by logging in with a linked service such as Facebook.
Constructs a new ParseUser with no data in it. A ParseUser constructed in this way will not
+ have an objectId and will not persist to the database until ParseUser.signUp() is called.
+
+
+
+
+
+
+
+
+
+Method Detail
+
+
+
+
+isAuthenticated
+
+public boolean isAuthenticated()
+
+
Whether the ParseUser has been authenticated on this device. This will be true if the ParseUser
+ was obtained via a logIn or signUp method. Only an authenticated ParseUser can be saved (with
+ altered attributes) and deleted.
+
Signs up a new user. You should call this instead of ParseObject.save() for new ParseUsers. This
+ will create a new ParseUser on the server, and also persist the session on disk so that you can
+ access the user using ParseUser.getCurrentUser().
+
+ A username and password must be set before calling signUp.
+
Signs up a new user. You should call this instead of ParseObject.save() for new ParseUsers. This
+ will create a new ParseUser on the server, and also persist the session on disk so that you can
+ access the user using ParseUser.getCurrentUser().
+
+ A username and password must be set before calling signUp.
+
+
+ This is preferable to using ParseUser.signUp(), unless your code is already running from a
+ background thread.
+
+
+
Parameters:
callback - callback.done(user, e) is called when the signUp completes.
+
Throws:
+
ParseException - Throws an exception if the server is inaccessible, or if the username has already
+ been taken.
Logs in a user with a username and password. On success, this saves the session to disk, so you
+ can retrieve the currently logged in user using ParseUser.getCurrentUser()
+
Logs in a user with a username and password. On success, this saves the session to disk, so you
+ can retrieve the currently logged in user using ParseUser.getCurrentUser()
+
Authorize a user with a session token. On success, this saves the session to disk, so you
+ can retrieve the currently logged in user using ParseUser.getCurrentUser()
+
Authorize a user with a session token. On success, this saves the session to disk, so you
+ can retrieve the currently logged in user using ParseUser.getCurrentUser()
+
This retrieves the currently logged in ParseUser with a valid session, either from memory or
+ disk if necessary.
+
+
+
+
Returns:
The currently logged in ParseUser
+
+
+
+
+
+logOut
+
+public static void logOut()
+
+
Logs out the currently logged in user session. This will remove the session from disk, log out
+ of linked services, and future calls to ParseUser.getCurrentUser() will return null.
+
Requests a password reset email to be sent to the specified email address associated with the
+ user account. This email allows the user to securely reset their password on the Parse site.
+
Requests a password reset email to be sent in a background thread to the specified email
+ address associated with the user account. This email allows the user to securely reset their
+ password on the Parse site.
+
+ This is preferable to using requestPasswordReset(), unless your code is already running from a
+ background thread.
+
+
+
+
Parameters:
email - The email address associated with the user that forgot their password.
callback - callback.done(e) is called when the request completes.
ParseException - Throws an exception if the server is inaccessible.
+
+
+
+
+
+isNew
+
+public boolean isNew()
+
+
Indicates whether this ParseUser was created during this session through a call to
+ ParseUser.signUp() or by logging in with a linked service such as Facebook.
+
+
+
+
+
+
+
+
+enableAutomaticUser
+
+public static void enableAutomaticUser()
+
+
Enables automatic creation of anonymous users. After calling this method,
+ ParseUser.getCurrentUser() will always have a value. The user will only be created on
+ the server once the user has been saved, or once an object with a relation to that user or an
+ ACL that refers to the user has been saved. Note: saveEventually will not work if an item being
+ saved has a relation to an automatic user that has never been saved.
+
+A service to listen for push notifications. This operates in the same process as the parent
+ application.
+
+ The PushService can listen to pushes from two different sources: Google Cloud Messaging (GCM) or
+ the Parse Push Notification Service (PPNS). Parse will inspect your application's manifest at
+ runtime and determine which service to use for push. We recommend using GCM for push on devices
+ that have Google Play Store support. PPNS support is provided for apps that want to avoid a
+ dependency on the Google Play Store, and for devices (like Kindles) which do not have Play Store
+ support.
+
+ To configure the PushService for GCM, ensure these permission declarations are present in your
+ AndroidManifest.xml as children of the <manifest> element:
+
+
+
+ Replace YOUR_PACKAGE_NAME in the declarations above with your application's package name. Also,
+ make sure that com.parse.GcmBroadcastReceiver and com.parse.PushService are declared as children
+ of the <application> element:
+
+
+
+ Again, replace YOUR_PACKAGE_NAME with your application's package name.
+
+ To configure the PushService for PPNS, ensure these permission declarations are present in your
+ AndroidManifest.xml as children of the <manifest> element:
+
+
+
+ Also, make sure that com.parse.ParseBroadcastReceiver and com.parse.PushService are declared as
+ children of the <application> element:
+
+ <service android:name="com.parse.PushService" />
+ <receiver android:name="com.parse.ParseBroadcastReceiver">
+ <intent-filter>
+ <action android:name="android.intent.action.BOOT_COMPLETED" />
+ <action android:name="android.intent.action.USER_PRESENT" />
+ </intent-filter>
+ </receiver>
+
+ Note that you can configure the push service for both GCM and PPNS by adding all the declarations
+ above to your application's manifest. In this case, Parse will use GCM on devices with Play
+ Store support and fall back to using PPNS on devices without Play Store support.
+
+ Once push notifications are configured in the manifest, you can subscribe to a push channel by
+ calling:
+
+
+
+ When the client receives a push message, a notification will appear in the system tray. When the
+ user taps the notification, they will enter the application through a new instance of
+ YourActivity.
+
subscribe(Context context,
+ String channel,
+ Class<? extends Activity> cls)
+
+
+ Helper function to subscribe to push notifications with the default application icon.
+
+
+
+static void
+
subscribe(Context context,
+ String channel,
+ Class<? extends Activity> cls,
+ int icon)
+
+
+ Call this function when the user should be subscribed to a new push channel.
Helper function to subscribe to push notifications with the default application icon.
+
+
+
Parameters:
context - This is used to access local storage to cache the subscription, so it must currently
+ be a viable context.
channel - A string identifier that determines which messages will cause a push notification to
+ be sent to this client. The channel name must start with a letter and contain only
+ letters, numbers, dashes, and underscores.
cls - This should be a subclass of Activity. An instance of this Activity is started when
+ the user responds to this push notification. If you are not sure what to use here,
+ just use your application's main Activity subclass.
+
Call this function when the user should be subscribed to a new push channel. When push
+ notifications are sent out on this channel subsequently, this device will display a "toast"
+ notification in the system tray. This function returns immediately, even when there is no
+ internet access. In that case the subscription is cached and when internet access is next
+ available the client will inform the server of its subscription. This starts a PushService
+ running in the background that will not permanently terminate as long as the user is subscribed
+ to some channel, unless the application is uninstalled.
+
+
+
Parameters:
context - This is used to access local storage to cache the subscription, so it must currently
+ be a viable context.
channel - A string identifier that determines which messages will cause a push notification to
+ be sent to this client. The channel name must start with a letter and contain only
+ letters, numbers, dashes, and underscores.
cls - This should be a subclass of Activity. An instance of this Activity is started when
+ the user responds to this push notification. If you are not sure what to use here,
+ just use your application's main Activity subclass.
Cancels a previous call to subscribe. If the user is not subscribed to this channel, this is a
+ no-op. This call does not require internet access. It returns without blocking.
+
+
+
Parameters:
context - A currently viable Context.
channel - The string defining the channel to unsubscribe from.
Provides a default Activity class to handle pushes. Setting a default allows your program to
+ handle pushes that aren't registered with a subscribe call. This can happen when your
+ application changes its subscriptions directly through the ParseInstallation or via
+ push-to-query.
+
+
+
Parameters:
context - This is used to access local storage to cache the subscription, so it must currently
+ be a viable context.
cls - This should be a subclass of Activity. An instance of this Activity is started when
+ the user responds to this push notification. If you are not sure what to use here,
+ just use your application's main Activity subclass.
Provides a default Activity class to handle pushes. Setting a default allows your program to
+ handle pushes that aren't registered with a subscribe call. This can happen when your
+ application changes its subscriptions directly through the ParseInstallation or via
+ push-to-query.
+
+
+
Parameters:
context - This is used to access local storage to cache the subscription, so it must currently
+ be a viable context.
cls - This should be a subclass of Activity. An instance of this Activity is started when
+ the user responds to this push notification. If you are not sure what to use here,
+ just use your application's main Activity subclass.
Accesses the current set of channels for which the current installation is subscribed. It is
+ important to remember that the device may receive pushes by means other than channels. This
+ method returns the local cache, so it returns without blocking on network IO. In rare
+ circumstances this may be stale, but only after the installation was edited via the REST API
+ using the master key.
+
+
+
Parameters:
context - A currently viable Context.
+
Returns:
A set containing all of the channels this application is currently subscribed to.
+A RefreshCallback is used to run code after refresh is used to update a ParseObject in a
+ background thread.
+
+ The easiest way to use a RefreshCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the refresh is complete.
+ The done function will be run in the UI thread, while the refresh happens in a
+ background thread. This ensures that the UI does not freeze while the refresh happens.
+
+ For example, this sample code refreshes an object of class "MyClass" and id
+ myId. It calls a different function depending on whether the refresh succeeded or
+ not.
+
+A RequestPasswordResetCallback is used to run code requesting a password reset for a user.
+
+ The easiest way to use a RequestPasswordResetCallback is through an anonymous inner class.
+ Override the done function to specify what the callback should do after the request
+ is complete. The done function will be run in the UI thread, while the request
+ happens in a background thread. This ensures that the UI does not freeze while the request
+ happens.
+
+ For example, this sample code requests a password reset for a user and calls a different function
+ depending on whether the request succeeded or not.
+
+
+
+ ParseUser.requestPasswordResetInBackground("forgetful@example.com",
+ new RequestPasswordResetCallback() {
+ public void done(ParseException e) {
+ if (e == null) {
+ requestedSuccessfully();
+ } else {
+ requestDidNotSucceed();
+ }
+ }
+ });
+
+A SaveCallback is used to run code after saving a ParseObject in a background thread.
+
+ The easiest way to use a SaveCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the save is complete. The
+ done function will be run in the UI thread, while the save happens in a background
+ thread. This ensures that the UI does not freeze while the save happens.
+
+ For example, this sample code saves the object myObject and calls a different
+ function depending on whether the save succeeded or not.
+
+A SendCallback is used to run code after sending a ParsePush in a background thread.
+
+ The easiest way to use a SendCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the send is complete. The
+ done function will be run in the UI thread, while the send happens in a background
+ thread. This ensures that the UI does not freeze while the send happens.
+
+ For example, this sample code sends the message "Hello world" on the
+ "hello" channel and logs whether the send succeeded.
+
+A SignUpCallback is used to run code after signing up a ParseUser in a background thread.
+
+ The easiest way to use a SignUpCallback is through an anonymous inner class. Override the
+ done function to specify what the callback should do after the save is complete. The
+ done function will be run in the UI thread, while the signup happens in a background
+ thread. This ensures that the UI does not freeze while the signup happens.
+
+ For example, this sample code signs up the object myUser and calls a different
+ function depending on whether the signup succeeded or not.
+
ParseObject.deleteEventually(DeleteCallback callback)
+
+
+ Deletes this object from the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
ParseObject.fetchAllInBackground(List<T> objects,
+ FindCallback<T> callback)
+
+
+ Fetches all the objects in the provided list in the background
+
+
+
+ void
+
ParseQuery.findInBackground(FindCallback<T> callback)
+
+
+ Retrieves a list of ParseObjects that satisfy this query from the server in a background
+ thread.
ParseObject.fetchInBackground(GetCallback<T> callback)
+
+
+ Fetches this object with the data from the server in a background thread.
+
+
+
+ void
+
ParseQuery.getFirstInBackground(GetCallback<T> callback)
+
+
+ Retrieves at most one ParseObject that satisfies this query from the server in a background
+ thread.
+
+
+
+ void
+
ParseQuery.getInBackground(String objectId,
+ GetCallback<T> callback)
+
+
+ Constructs a ParseObject whose id is already known by fetching data from the server in a
+ background thread.
ParseGeoPoint.getCurrentLocationInBackground(long timeout,
+ Criteria criteria,
+ LocationCallback callback)
+
+
+ Fetches the user's current location and returns a new ParseGeoPoint via the provided
+ LocationCallback.
+
+
+
+static void
+
ParseGeoPoint.getCurrentLocationInBackground(long timeout,
+ LocationCallback callback)
+
+
+ Fetches the user's current location and returns a new ParseGeoPoint via the provided
+ LocationCallback.
ParseFacebookUtils.logIn(Collection<String> permissions,
+ Activity activity,
+ int activityCode,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Facebook for authentication.
+
+
+
+static void
+
ParseFacebookUtils.logIn(Collection<String> permissions,
+ Activity activity,
+ LogInCallback callback)
+
+
+ Logs in a user using the default activity code if single sign-on is enabled.
+
+
+
+static void
+
ParseTwitterUtils.logIn(Context context,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Twitter for authentication.
+
+
+
+static void
+
ParseAnonymousUtils.logIn(LogInCallback callback)
+
+
+ Creates an anonymous user.
+
+
+
+static void
+
ParseFacebookUtils.logIn(String facebookId,
+ String accessToken,
+ Date expirationDate,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Facebook for authentication.
+
+
+
+static void
+
ParseTwitterUtils.logIn(String twitterId,
+ String screenName,
+ String authToken,
+ String authTokenSecret,
+ LogInCallback callback)
+
+
+ Logs in a ParseUser using Twitter for authentication.
ParseObject.setACL(ParseACL acl)
+
+
+ Set the ParseACL governing this object.
+
+
+
+static void
+
ParseACL.setDefaultACL(ParseACL acl,
+ boolean withAccessForCurrentUser)
+
+
+ Sets a default ACL that will be applied to all ParseObjects when they are created.
CountCallback.done(int count,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the count is complete.
+
+
+
+abstract void
+
FindCallback.done(List<T> objects,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the fetch is complete.
+
+
+
+abstract void
+
SignUpCallback.done(ParseException e)
+
+
+ Override this function with the code you want to run after the signUp is complete.
+
+
+
+abstract void
+
SendCallback.done(ParseException e)
+
+
+ Override this function with the code you want to run after the send is complete.
+
+
+
+abstract void
+
SaveCallback.done(ParseException e)
+
+
+ Override this function with the code you want to run after the save is complete.
+
+
+
+abstract void
+
RequestPasswordResetCallback.done(ParseException e)
+
+
+ Override this function with the code you want to run after the request is complete.
+
+
+
+abstract void
+
DeleteCallback.done(ParseException e)
+
+
+ Override this function with the code you want to run after the delete is complete.
+
+
+
+abstract void
+
LocationCallback.done(ParseGeoPoint geoPoint,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the location fetch is complete.
+
+
+
+abstract void
+
RefreshCallback.done(ParseObject object,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the save is complete.
+
+
+
+abstract void
+
LogInCallback.done(ParseUser user,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the save is complete.
+
+
+
+abstract void
+
GetCallback.done(T object,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the fetch is complete.
+
+
+
+abstract void
+
FunctionCallback.done(T object,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the cloud function is complete.
ParseUser.logIn(String username,
+ String password)
+
+
+ Logs in a user with a username and password.
+
+
+
+ void
+
ParseObject.refresh()
+
+
+ Refreshes this object with the data from the server.
+
+
+
+static void
+
ParseUser.requestPasswordReset(String email)
+
+
+ Requests a password reset email to be sent to the specified email address associated with the
+ user account.
+
+
+
+ void
+
ParseObject.save()
+
+
+ Saves this object to the server.
+
+
+
+ void
+
ParseFile.save()
+
+
+ Saves the file to the Parse cloud synchronously.
+
+
+
+static void
+
ParseObject.saveAll(List<ParseObject> objects)
+
+
+ Saves each object in the provided list.
+
+
+
+ void
+
ParsePush.send()
+
+
+ Sends this push notification while blocking this thread until the push notification has
+ successfully reached the Parse servers.
LocationCallback.done(ParseGeoPoint geoPoint,
+ ParseException e)
+
+
+ Override this function with the code you want to run after the location fetch is complete.
ParseQuery.whereNear(String key,
+ ParseGeoPoint point)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point
+ given.
ParseQuery.whereWithinGeoBox(String key,
+ ParseGeoPoint southwest,
+ ParseGeoPoint northeast)
+
+
+ Add a constraint to the query that requires a particular key's coordinates be contained within
+ a given rectangular geographic bounding box.
ParseQuery.whereWithinKilometers(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseQuery.whereWithinMiles(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseQuery.whereWithinRadians(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseObject.createWithoutData(Class<T> subclass,
+ String objectId)
+
+
+ Creates a reference to an existing ParseObject for use in creating associations between
+ ParseObjects.
ParseObject.createWithoutData(String className,
+ String objectId)
+
+
+ Creates a reference to an existing ParseObject for use in creating associations between
+ ParseObjects.
ParseObject.fetchAll(List<ParseObject> objects)
+
+
+ Fetches all the objects in the provided list.
+
+
+
+static void
+
ParseObject.registerSubclass(Class<? extends ParseObject> subclass)
+
+
+ Registers a custom subclass type with the Parse SDK, enabling strong-typing of those
+ ParseObjects whenever they appear.
+
+
+
+static void
+
ParseObject.saveAll(List<ParseObject> objects)
+
+
+ Saves each object in the provided list.
ParseQuery.whereContainedIn(String key,
+ Collection<? extends Object> values)
+
+
+ Add a constraint to the query that requires a particular key's value to be contained in the
+ provided list of values.
ParseQuery.whereContainsAll(String key,
+ Collection<?> values)
+
+
+ Add a constraint to the query that requires a particular key's value match another ParseQuery.
ParseQuery.whereDoesNotMatchKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match any value
+ for a key in the results of another ParseQuery.
ParseQuery.whereDoesNotMatchQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match another
+ ParseQuery.
ParseQuery.whereEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be equal to the
+ provided value.
ParseQuery.whereGreaterThan(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be greater than the
+ provided value.
ParseQuery.whereGreaterThanOrEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be greater than or
+ equal to the provided value.
ParseQuery.whereLessThan(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be less than the
+ provided value.
ParseQuery.whereLessThanOrEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be less than or equal
+ to the provided value.
ParseQuery.whereMatches(String key,
+ String regex)
+
+
+ Add a regular expression constraint for finding string values that match the provided regular
+ expression.
ParseQuery.whereMatchesKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value matches a value for a key
+ in the results of another ParseQuery
ParseQuery.whereMatchesQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value match another ParseQuery.
ParseQuery.whereNear(String key,
+ ParseGeoPoint point)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point
+ given.
ParseQuery.whereNotContainedIn(String key,
+ Collection<? extends Object> values)
+
+
+ Add a constraint to the query that requires a particular key's value not be contained in the
+ provided list of values.
ParseQuery.whereNotEqualTo(String key,
+ Object value)
+
+
+ Add a constraint to the query that requires a particular key's value to be not equal to the
+ provided value.
ParseQuery.whereWithinGeoBox(String key,
+ ParseGeoPoint southwest,
+ ParseGeoPoint northeast)
+
+
+ Add a constraint to the query that requires a particular key's coordinates be contained within
+ a given rectangular geographic bounding box.
ParseQuery.whereWithinKilometers(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseQuery.whereWithinMiles(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseQuery.whereWithinRadians(String key,
+ ParseGeoPoint point,
+ double maxDistance)
+
+
+ Add a proximity based constraint for finding objects with key point values near the point given
+ and within the maximum distance given.
ParseQuery.whereDoesNotMatchKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match any value
+ for a key in the results of another ParseQuery.
ParseQuery.whereDoesNotMatchQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value does not match another
+ ParseQuery.
ParseQuery.whereMatchesKeyInQuery(String key,
+ String keyInQuery,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value matches a value for a key
+ in the results of another ParseQuery
ParseQuery.whereMatchesQuery(String key,
+ ParseQuery<?> query)
+
+
+ Add a constraint to the query that requires a particular key's value match another ParseQuery.
ParseFacebookUtils.link(ParseUser user,
+ Collection<String> permissions,
+ Activity activity,
+ int activityCode,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
+
+
+
+static void
+
ParseFacebookUtils.link(ParseUser user,
+ Collection<String> permissions,
+ Activity activity,
+ SaveCallback callback)
+
+
+ Links a user using the default activity code if single sign-on is enabled.
ParseTwitterUtils.link(ParseUser user,
+ Context context,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
ParseFacebookUtils.link(ParseUser user,
+ String facebookId,
+ String accessToken,
+ Date expirationDate,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
ParseTwitterUtils.link(ParseUser user,
+ String twitterId,
+ String screenName,
+ String authToken,
+ String authTokenSecret,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
ParseFacebookUtils.link(ParseUser user,
+ Collection<String> permissions,
+ Activity activity,
+ int activityCode,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
+
+
+
+static void
+
ParseFacebookUtils.link(ParseUser user,
+ Collection<String> permissions,
+ Activity activity,
+ SaveCallback callback)
+
+
+ Links a user using the default activity code if single sign-on is enabled.
+
+
+
+static void
+
ParseTwitterUtils.link(ParseUser user,
+ Context context,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
+
+
+
+static void
+
ParseFacebookUtils.link(ParseUser user,
+ String facebookId,
+ String accessToken,
+ Date expirationDate,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Facebook account, allowing you to use Facebook for authentication, and
+ providing access to Facebook data for the user.
+
+
+
+static void
+
ParseTwitterUtils.link(ParseUser user,
+ String twitterId,
+ String screenName,
+ String authToken,
+ String authTokenSecret,
+ SaveCallback callback)
+
+
+ Links a ParseUser to a Twitter account, allowing you to use Twitter for authentication, and
+ providing access to Twitter data for the user.
ParseObject.saveEventually(SaveCallback callback)
+
+
+ Saves this object to the server at some unspecified time in the future, even if Parse is
+ currently inaccessible.
ParseGeoPoint represents a latitude / longitude point that may be associated with a key in a
+ ParseObject or used as a reference point for geo queries.
A ParseException gets raised whenever a ParseObject issues an invalid request, such as
+ deleting or editing an object that no longer exists on the server, or when there is a network
+ failure preventing communication with the Parse server.
GetDataCallback
+
+
+ A GetDataCallback is used to run code after a ParseFile fetches its data on a background
+ thread.
+
+
+
LocationCallback
+
+
+ A LocationCallback is used to run code after a Location has been fetched by some
+ LocationProvider.
+
+
+
LogInCallback
+
+
+ A LogInCallback is used to run code after logging in a user.
+
+
+
ParseACL
+
+
+ A ParseACL is used to control which users can access or modify a particular object.
+
+
+
ParseClassName
+
+
+ Associates a class name for a subclass of ParseObject.
+
+
+
ParseException
+
+
+ A ParseException gets raised whenever a ParseObject issues an invalid request, such as
+ deleting or editing an object that no longer exists on the server, or when there is a network
+ failure preventing communication with the Parse server.
+
+
+
ParseFile
+
+
+ ParseFile is a local representation of a file that is saved to the Parse cloud.
+
+
+
ParseGeoPoint
+
+
+ ParseGeoPoint represents a latitude / longitude point that may be associated with a key in a
+ ParseObject or used as a reference point for geo queries.
+This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
+Package
+
+
+
+Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:
+
Interfaces (italic)
Classes
Enums
Exceptions
Errors
Annotation Types
+
+
+Class/Interface
+
+
+
+Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
+
Class inheritance diagram
Direct Subclasses
All Known Subinterfaces
All Known Implementing Classes
Class/interface declaration
Class/interface description
+
+
Nested Class Summary
Field Summary
Constructor Summary
Method Summary
+
+
Field Detail
Constructor Detail
Method Detail
+Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
+
+
+Annotation Type
+
+
+
+Each annotation type has its own separate page with the following sections:
+
Annotation Type declaration
Annotation Type description
Required Element Summary
Optional Element Summary
Element Detail
+
+
+
+Enum
+
+
+
+Each enum has its own separate page with the following sections:
+
Enum declaration
Enum description
Enum Constant Summary
Enum Constant Detail
+
+
+Use
+
+Each documented package, class and interface has its own Use page. This page describes what packages, classes, methods, constructors and fields use any part of the given class or package. Given a class or interface A, its Use page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
+
+Tree (Class Hierarchy)
+
+There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
+
When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
+
+
+Deprecated API
+
+The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
+
+Index
+
+The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
+
+Prev/Next
+These links take you to the next or previous class, interface, package, or related page.
+Frames/No Frames
+These links show and hide the HTML frames. All pages are available with or without frames.
+
+
+Serialized Form
+Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
+
Atomically adds the objects contained in a Collection to the array associated with a
+ given key, only adding elements which are not already present in the array.
+
This reports time as the server sees it, so that if you create a ParseObject, then wait a
+ while, and then call save(), the creation time will be the time of the first save() call rather
+ than the time the object was created locally.
+
This reports time as the server sees it, so that if you make changes to a ParseObject, then
+ wait a while, and then call save(), the updated time will be the time of the save() call rather
+ than the time the object was changed locally.
+
Indicates whether this ParseUser was created during this session through a call to
+ ParseUser.signUp() or by logging in with a linked service such as Facebook.
+
A ParseException gets raised whenever a ParseObject issues an invalid request, such as
+ deleting or editing an object that no longer exists on the server, or when there is a network
+ failure preventing communication with the Parse server.
ParseGeoPoint represents a latitude / longitude point that may be associated with a key in a
+ ParseObject or used as a reference point for geo queries.
Tracks this application being launched (and if this happened as the result of the user opening
+ a push notification, this method sends along information to correlate this open with that
+ push).
+
+
+
+
+
+
+
+
diff --git a/TodoListManager/libs/Parse-1.4.2-javadoc/style.css b/TodoListManager/libs/Parse-1.4.2-javadoc/style.css
new file mode 100644
index 0000000..101d1ec
--- /dev/null
+++ b/TodoListManager/libs/Parse-1.4.2-javadoc/style.css
@@ -0,0 +1,136 @@
+/* Javadoc style sheet for Parse, by Christophe TAUZIET */
+
+html, body, frame {
+ background-color: #FFFFFF;
+ color:#000000;
+ font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+ margin: 0px;
+ padding: 10px;
+
+}
+
+h1, h2, h3 {
+ color: #555555;
+}
+
+h1 {
+ font-size: 145%;
+}
+
+a:link {
+ line-height: 14px;
+ font-weight: bold;
+ text-decoration: none;
+ color: #444444;
+}
+a:visited {
+ color: #777777;
+ text-decoration: none;
+ font-weight: bold;
+}
+a:hover {
+ border-bottom: 2px solid #666666;
+}
+hr{
+ display: none;
+}
+
+table:nth-child(4) {
+ margin: -20px 0 0 -20px;
+}
+
+/* Table colors */
+.TableHeadingColor {
+ padding: 5px 0px;
+ background-color: #1789BA;
+ background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(0%, #1789BA), color-stop(100%, #0A67A0));
+ background-image: -webkit-linear-gradient(#1789BA, #0A67A0);
+ background-image: -moz-linear-gradient(#1789BA, #0A67A0);
+ background-image: -o-linear-gradient(#1789BA, #0A67A0);
+ background-image: -ms-linear-gradient(#1789BA, #0A67A0);
+ background-image: linear-gradient(#1789BA, #0A67A0);
+ -moz-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ -webkit-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ -o-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ color: white;
+ text-shadow: rgba(0, 0, 0, 0.6) 0 -1px 0;
+ font-size: 20px;
+ text-align: center;
+ font-weight: 200;
+}
+
+.TableHeadingColor b {
+ font-weight: 200;
+}
+
+.TableHeadingColor th {
+ padding-left: 15px;
+}
+
+.TableHeadingColor a:link, .TableHeadingColor a:visited {
+ color: #bbbbbb;
+}
+.TableHeadingColor a:hover {
+ border: none;
+ background-color:#666666;
+}
+.TableSubHeadingColor {
+ background: #EEEEEE;
+ color:#000000;
+}
+.TableRowColor {
+ background: #FFFFFF;
+ color:#000000;
+}
+.FrameTitleFont {
+ font-size: 100%;
+ color: #000000;
+}
+.FrameHeadingFont {
+ font-size: 90%;
+ color:#000000;
+}
+.FrameItemFont {
+ font-size: 90%;
+ color:#000000;
+}
+
+.NavBarCell1 {
+ padding: 10px 10px 10px 20px;
+ background-color: #1789BA;
+ background-image: -webkit-linear-gradient(#1789BA, #0A67A0);
+ background-image: -moz-linear-gradient(#1789BA, #0A67A0);
+ background-image: -o-linear-gradient(#1789BA, #0A67A0);
+ background-image: -ms-linear-gradient(#1789BA, #0A67A0);
+ background-image: linear-gradient(#1789BA, #0A67A0);
+ -moz-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ -webkit-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ -o-box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ box-shadow: rgba(255, 255, 255, 0.2) 0 1px 0px 0 inset, rgba(255, 255, 255, 0.2) 0 1px 0px 0;
+ border: 1px solid #363636;
+ color: white;
+ text-shadow: rgba(0, 0, 0, 0.6) 0 -1px 0;
+ font-size: 20px;
+}
+
+.NavBarCell1 a:hover {
+ border: none;
+}
+.NavBarCell1Rev {
+ background-color: #0A67A0;
+ background-image: -webkit-linear-gradient(#0A67A0, #1789BA);
+ background-image: -moz-linear-gradient(#0A67A0, #1789BA);
+ background-image: -o-linear-gradient(#0A67A0, #1789BA);
+ background-image: -ms-linear-gradient(#0A67A0, #1789BA);
+ background-image: linear-gradient(#0A67A0, #1789BA);
+ border: 1px solid #363636;
+ padding: 10px 10px 10px 10px;
+}
+.NavBarFont1, .NavBarFont1Rev {
+ color:#FFFFFF;
+}
+.NavBarCell2, .NavBarCell3 {
+ background-color:#FFFFFF;
+ color:#000000;
+}
\ No newline at end of file
diff --git a/TodoListManager/libs/Parse-1.4.2.jar b/TodoListManager/libs/Parse-1.4.2.jar
new file mode 100644
index 0000000..c52ce6e
Binary files /dev/null and b/TodoListManager/libs/Parse-1.4.2.jar differ
diff --git a/TodoListManager/libs/Parse-1.4.2.jar.properties b/TodoListManager/libs/Parse-1.4.2.jar.properties
new file mode 100644
index 0000000..b7f319b
--- /dev/null
+++ b/TodoListManager/libs/Parse-1.4.2.jar.properties
@@ -0,0 +1 @@
+doc=Parse-1.4.2-javadoc
diff --git a/TodoListManager/libs/third_party_licenses.txt b/TodoListManager/libs/third_party_licenses.txt
new file mode 100644
index 0000000..234c642
--- /dev/null
+++ b/TodoListManager/libs/third_party_licenses.txt
@@ -0,0 +1,622 @@
+THE FOLLOWING SETS FORTH ATTRIBUTION NOTICES FOR THIRD PARTY SOFTWARE THAT MAY BE CONTAINED IN PORTIONS OF THE PARSE PRODUCT.
+
+-----
+
+The following software may be included in this product: Apache Jakarta Commons Codec. This software contains the following license and notice below:
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-----
+
+The following software may be included in this product: oauth-signpost. This software contains the following license and notice below:
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-----
+
+The following software may be included in this product: Apache Commons IO. This software contains the following license and notice below:
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/TodoListManager/src/il/ac/huji/todolist/ActionTaskDialog.java b/TodoListManager/src/il/ac/huji/todolist/ActionTaskDialog.java
index d5c1c8d..8d1ecef 100644
--- a/TodoListManager/src/il/ac/huji/todolist/ActionTaskDialog.java
+++ b/TodoListManager/src/il/ac/huji/todolist/ActionTaskDialog.java
@@ -25,10 +25,10 @@ public class ActionTaskDialog extends DialogFragment {
private static final int CALL_POS = 1;
private int _pos; // position of the task in the list
- private String _task; // the long-pressed task
+ private TodoTask _task; // the long-pressed task
@SuppressLint("ValidFragment")
- public ActionTaskDialog(int pos, String task) {
+ public ActionTaskDialog(int pos, TodoTask task) {
super();
_pos = pos;
_task = task;
@@ -39,6 +39,10 @@ public ActionTaskDialog(int pos, String task) {
public int getPos() {
return _pos;
}
+
+ public TodoTask getTask() {
+ return _task;
+ }
/* The activity that creates an instance of this dialog fragment must
* implement this interface in order to receive event callbacks.
@@ -73,8 +77,8 @@ public Dialog onCreateDialog(Bundle savedInstanceState) {
actions.add(getResources().getString(R.string.dialog_delete_list_item));
images.add(R.drawable.ic_action_discard);
- if(_task.startsWith(getResources().getString(R.string.dialog_call_list_item))) {
- actions.add(_task);
+ if(_task.getTitle().startsWith(getResources().getString(R.string.dialog_call_list_item))) {
+ actions.add(_task.getTitle());
images.add(R.drawable.ic_action_call);
}
@@ -83,7 +87,7 @@ public Dialog onCreateDialog(Bundle savedInstanceState) {
// Use the Builder class for convenient dialog construction
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
- builder.setTitle(_task)
+ builder.setTitle(_task.getTitle())
.setAdapter(adapter, new DialogInterface.OnClickListener() {
@Override
@@ -93,7 +97,7 @@ public void onClick(DialogInterface dialog, int which) {
}
else if (which == CALL_POS) {
Intent callIntent = new Intent(Intent.ACTION_DIAL);
- callIntent.setData(Uri.parse("tel:" + _task.split(" ")[1]));
+ callIntent.setData(Uri.parse("tel:" + _task.getTitle().split(" ")[1]));
startActivity(callIntent);
}
}
diff --git a/TodoListManager/src/il/ac/huji/todolist/TodoListManagerActivity.java b/TodoListManager/src/il/ac/huji/todolist/TodoListManagerActivity.java
index a09f17c..64f5939 100644
--- a/TodoListManager/src/il/ac/huji/todolist/TodoListManagerActivity.java
+++ b/TodoListManager/src/il/ac/huji/todolist/TodoListManagerActivity.java
@@ -4,6 +4,8 @@
import java.util.Date;
+import com.parse.Parse;
+
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
@@ -38,7 +40,10 @@ protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_to_do_list);
- _helper = new TodoTaskSQLiteHelper(this);
+ // Initialize databases
+ _helper = TodoTaskSQLiteHelper.getInstanse(this);
+ Parse.initialize(this, "z6oaJ0v3LcRPapj4w3ZDJS7ImSl9beyDlATdGjtZ",
+ "seCevpBGpkvBEmuUZyCHHaJAAqHGVitVwkw2dEEI");
_listToDoTask = (ListView) findViewById(R.id.list_todo_tasks);
@@ -59,7 +64,8 @@ public void run() {
@SuppressLint("NewApi")
public boolean onItemLongClick(AdapterView parent, View child, int pos, long id) {
Cursor current = (Cursor)_adapter.getItem(pos);
- _actionTaskDialog = new ActionTaskDialog(current.getInt(0), current.getString(1));
+ _actionTaskDialog = new ActionTaskDialog(current.getInt(0),
+ new TodoTask(current.getString(1)));
_actionTaskDialog.show(getFragmentManager(), "actionTask");
return true;
}
diff --git a/TodoListManager/src/il/ac/huji/todolist/TodoTask.java b/TodoListManager/src/il/ac/huji/todolist/TodoTask.java
index 363cffc..14a6f2a 100644
--- a/TodoListManager/src/il/ac/huji/todolist/TodoTask.java
+++ b/TodoListManager/src/il/ac/huji/todolist/TodoTask.java
@@ -19,6 +19,10 @@ public TodoTask(String title, long due) {
this._title = title;
this._due = due;
}
+
+ public TodoTask(String title) {
+ this._title = title;
+ }
public int getID() {
return _id;
diff --git a/TodoListManager/src/il/ac/huji/todolist/TodoTaskSQLiteHelper.java b/TodoListManager/src/il/ac/huji/todolist/TodoTaskSQLiteHelper.java
index b1aaec7..f92717c 100644
--- a/TodoListManager/src/il/ac/huji/todolist/TodoTaskSQLiteHelper.java
+++ b/TodoListManager/src/il/ac/huji/todolist/TodoTaskSQLiteHelper.java
@@ -1,14 +1,26 @@
package il.ac.huji.todolist;
+import java.util.List;
+
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
+import android.provider.Settings.Secure;
import android.util.Log;
+import com.parse.FindCallback;
+import com.parse.ParseException;
+import com.parse.ParseObject;
+import com.parse.ParseQuery;
+
+import com.parse.SaveCallback;
+
public class TodoTaskSQLiteHelper extends SQLiteOpenHelper {
+ private static TodoTaskSQLiteHelper _instanse;
+
private static final String TABLE_TASKS = "todo_tasks";
private static final String COLUMN_ID = "_id";
private static final String COLUMN_TITLE = "title";
@@ -17,6 +29,11 @@ public class TodoTaskSQLiteHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "todo_db";
private static final int DATABASE_VERSION = 1;
+ /** Unique ID for the device */
+ private String _androidID;
+
+ private Context _context;
+
// Database creation sql statement
private static final String DATABASE_CREATE =
"CREATE TABLE " + TABLE_TASKS
@@ -26,15 +43,26 @@ public class TodoTaskSQLiteHelper extends SQLiteOpenHelper {
+ COLUMN_DUE + " TEXT"
+ ");";
- public TodoTaskSQLiteHelper(Context context) {
+ private TodoTaskSQLiteHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
+ this._context = context;
+ this._androidID = Secure.getString(_context.getContentResolver(),
+ Secure.ANDROID_ID);
+ }
+
+ public static TodoTaskSQLiteHelper getInstanse(Context context) {
+ if (_instanse == null) {
+ _instanse = new TodoTaskSQLiteHelper(context);
+ }
+
+ return _instanse;
}
@Override
public void onCreate(SQLiteDatabase database) {
- database.execSQL(DATABASE_CREATE);
Log.i(TodoTaskSQLiteHelper.class.getName(),
"Creating database");
+ database.execSQL(DATABASE_CREATE);
}
@Override
@@ -53,16 +81,37 @@ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
* @param task The task to add.
*/
public void addTask(TodoTask task) {
+ // inserting row to local database
SQLiteDatabase db = this.getWritableDatabase();
- ContentValues values = new ContentValues();
+ final ContentValues values = new ContentValues();
values.put(COLUMN_TITLE, task.getTitle()); // task title
values.put(COLUMN_DUE, task.getDue()); // task due
-
- // inserting row
- db.insert(TABLE_TASKS, null, values);
+
+ long id = db.insert(TABLE_TASKS, null, values);
db.close(); // closing database connection
+ // insert row to Parse database
+ final ParseObject parseTask = new ParseObject(_androidID);
+ parseTask.put("ID", id);
+ parseTask.put("Title", task.getTitle());
+ parseTask.put("Due", task.getDue());
+
+ parseTask.saveEventually(new SaveCallback() {
+
+ @Override
+ public void done(ParseException e) {
+ if (e == null) {
+ // Success!
+ String objectId = parseTask.getObjectId();
+ Log.i(TodoTaskSQLiteHelper.class.getName(),
+ "Parse ID: " + objectId);
+ } else {
+ // Failure!
+ }
+ }
+ });
+
Log.i(TodoTaskSQLiteHelper.class.getName(),
"Inserting new task: " + task.getTitle() + " due: " + task.getDue());
}
@@ -77,7 +126,7 @@ public TodoTask getTask(int id) {
Cursor cursor = db.query(
TABLE_TASKS,
- new String[] {COLUMN_ID, COLUMN_TITLE, COLUMN_DUE },
+ new String[] {COLUMN_ID, COLUMN_TITLE, COLUMN_DUE},
COLUMN_ID + "=?",
new String[] {String.valueOf(id)},
null, null, null, null);
@@ -107,13 +156,25 @@ public Cursor getAllTasks() {
* Delete a task with an id.
* @param id The id of the task as it appears in the database.
*/
- public void deleteTask(int id){
+ public void deleteTask(int id) {
SQLiteDatabase db = this.getWritableDatabase();
db.delete(TABLE_TASKS, COLUMN_ID + " = ?",
new String[] { String.valueOf(id) });
db.close();
+ ParseQuery query = ParseQuery.getQuery(_androidID);
+ query.whereEqualTo("ID", id);
+ query.findInBackground(new FindCallback() {
+
+ @Override
+ public void done(List objects, ParseException e) {
+ for (ParseObject parseTask : objects) {
+ parseTask.deleteEventually();
+ }
+ }
+ });
+
Log.i(TodoTaskSQLiteHelper.class.getName(),
"Deleted task with id: " + id);
}
com.parse.CountCallback
+