Examples with Task bolts.Task used on opensource projects

Example 26 with Task

use of bolts.Task in project Parse-SDK-Android by ParsePlatform.

the class OfflineStore method updateDataForObjectAsync.

private Task<Void> updateDataForObjectAsync(final String uuid, final ParseObject object, final ParseSQLiteDatabase db) {
    // Now actually encode the object as JSON.
    OfflineEncoder encoder = new OfflineEncoder(db);
    final JSONObject json = object.toRest(encoder);
    return encoder.whenFinished().onSuccessTask(new Continuation<Void, Task<Void>>() {

        @Override
        public Task<Void> then(Task<Void> task) throws Exception {
            // Put the JSON in the database.
            String className = object.getClassName();
            String objectId = object.getObjectId();
            int isDeletingEventually = json.getInt(ParseObject.KEY_IS_DELETING_EVENTUALLY);
            final ContentValues values = new ContentValues();
            values.put(OfflineSQLiteOpenHelper.KEY_CLASS_NAME, className);
            values.put(OfflineSQLiteOpenHelper.KEY_JSON, json.toString());
            if (objectId != null) {
                values.put(OfflineSQLiteOpenHelper.KEY_OBJECT_ID, objectId);
            }
            values.put(OfflineSQLiteOpenHelper.KEY_IS_DELETING_EVENTUALLY, isDeletingEventually);
            String where = OfflineSQLiteOpenHelper.KEY_UUID + " = ?";
            String[] args = { uuid };
            return db.updateAsync(OfflineSQLiteOpenHelper.TABLE_OBJECTS, values, where, args).makeVoid();
        }
    });
}

Example 27 with Task

use of bolts.Task in project Parse-SDK-Android by ParsePlatform.

the class OfflineStore method saveLocallyAsync.

/**
   * Stores a single object in the local database. If the object is a pointer, isn't dirty, and has
   * an objectId already, it may not be saved, since it would provide no useful data.
   *
   * @param object
   *          The object to save.
   * @param db
   *          A database connection to use.
   */
private Task<Void> saveLocallyAsync(final String key, final ParseObject object, final ParseSQLiteDatabase db) {
    // If this is just a clean, unfetched pointer known to Parse, then there is nothing to save.
    if (object.getObjectId() != null && !object.isDataAvailable() && !object.hasChanges() && !object.hasOutstandingOperations()) {
        return Task.forResult(null);
    }
    final Capture<String> uuidCapture = new Capture<>();
    // Make sure we have a UUID for the object to be saved.
    return getOrCreateUUIDAsync(object, db).onSuccessTask(new Continuation<String, Task<Void>>() {

        @Override
        public Task<Void> then(Task<String> task) throws Exception {
            String uuid = task.getResult();
            uuidCapture.set(uuid);
            return updateDataForObjectAsync(uuid, object, db);
        }
    }).onSuccessTask(new Continuation<Void, Task<Void>>() {

        @Override
        public Task<Void> then(Task<Void> task) throws Exception {
            final ContentValues values = new ContentValues();
            values.put(OfflineSQLiteOpenHelper.KEY_KEY, key);
            values.put(OfflineSQLiteOpenHelper.KEY_UUID, uuidCapture.get());
            return db.insertWithOnConflict(OfflineSQLiteOpenHelper.TABLE_DEPENDENCIES, values, SQLiteDatabase.CONFLICT_IGNORE);
        }
    });
}

Example 28 with Task

use of bolts.Task in project Parse-SDK-Android by ParsePlatform.

the class OfflineStore method getOrCreateUUIDAsync.

/**
   * Gets the UUID for the given object, if it has one. Otherwise, creates a new UUID for the object
   * and adds a new row to the database for the object with no data.
   */
private Task<String> getOrCreateUUIDAsync(final ParseObject object, ParseSQLiteDatabase db) {
    final String newUUID = UUID.randomUUID().toString();
    final TaskCompletionSource<String> tcs = new TaskCompletionSource<>();
    synchronized (lock) {
        Task<String> uuidTask = objectToUuidMap.get(object);
        if (uuidTask != null) {
            return uuidTask;
        }
        // The object doesn't have a UUID yet, so we're gonna have to make one.
        objectToUuidMap.put(object, tcs.getTask());
        uuidToObjectMap.put(newUUID, object);
        fetchedObjects.put(object, tcs.getTask().onSuccess(new Continuation<String, ParseObject>() {

            @Override
            public ParseObject then(Task<String> task) throws Exception {
                return object;
            }
        }));
    }
    /*
     * We need to put a placeholder row in the database so that later on, the save can just be an
     * update. This could be a pointer to an object that itself never gets saved offline, in which
     * case the consumer will just have to deal with that.
     */
    ContentValues values = new ContentValues();
    values.put(OfflineSQLiteOpenHelper.KEY_UUID, newUUID);
    values.put(OfflineSQLiteOpenHelper.KEY_CLASS_NAME, object.getClassName());
    db.insertOrThrowAsync(OfflineSQLiteOpenHelper.TABLE_OBJECTS, values).continueWith(new Continuation<Void, Void>() {

        @Override
        public Void then(Task<Void> task) throws Exception {
            // This will signal that the UUID does represent a row in the database.
            tcs.setResult(newUUID);
            return null;
        }
    });
    return tcs.getTask();
}

Example 29 with Task

use of bolts.Task in project Parse-SDK-Android by ParsePlatform.

the class Parse method initialize.

public static void initialize(Configuration configuration) {
    // NOTE (richardross): We will need this here, as ParsePlugins uses the return value of
    // isLocalDataStoreEnabled() to perform additional behavior.
    isLocalDatastoreEnabled = configuration.localDataStoreEnabled;
    ParsePlugins.Android.initialize(configuration.context, configuration.applicationId, configuration.clientKey);
    try {
        ParseRESTCommand.server = new URL(configuration.server);
    } catch (MalformedURLException ex) {
        throw new RuntimeException(ex);
    }
    Context applicationContext = configuration.context.getApplicationContext();
    ParseHttpClient.setKeepAlive(true);
    ParseHttpClient.setMaxConnections(20);
    // If we have interceptors in list, we have to initialize all http clients and add interceptors
    if (configuration.interceptors != null && configuration.interceptors.size() > 0) {
        initializeParseHttpClientsWithParseNetworkInterceptors(configuration.interceptors);
    }
    ParseObject.registerParseSubclasses();
    if (configuration.localDataStoreEnabled) {
        offlineStore = new OfflineStore(configuration.context);
    } else {
        ParseKeyValueCache.initialize(configuration.context);
    }
    // Make sure the data on disk for Parse is for the current
    // application.
    checkCacheApplicationId();
    final Context context = configuration.context;
    Task.callInBackground(new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            getEventuallyQueue(context);
            return null;
        }
    });
    ParseFieldOperations.registerDefaultDecoders();
    if (!allParsePushIntentReceiversInternal()) {
        throw new SecurityException("To prevent external tampering to your app's notifications, " + "all receivers registered to handle the following actions must have " + "their exported attributes set to false: com.parse.push.intent.RECEIVE, " + "com.parse.push.intent.OPEN, com.parse.push.intent.DELETE");
    }
    // May need to update GCM registration ID if app version has changed.
    // This also primes current installation.
    GcmRegistrar.getInstance().registerAsync().continueWithTask(new Continuation<Void, Task<Void>>() {

        @Override
        public Task<Void> then(Task<Void> task) throws Exception {
            // Prime current user in the background
            return ParseUser.getCurrentUserAsync().makeVoid();
        }
    }).continueWith(new Continuation<Void, Void>() {

        @Override
        public Void then(Task<Void> task) throws Exception {
            // Prime config in the background
            ParseConfig.getCurrentConfig();
            return null;
        }
    }, Task.BACKGROUND_EXECUTOR);
    if (ManifestInfo.getPushType() == PushType.PPNS) {
        PushService.startServiceIfRequired(applicationContext);
    }
    dispatchOnParseInitialized();
    // FYI we probably don't want to do this if we ever add other callbacks.
    synchronized (MUTEX_CALLBACKS) {
        Parse.callbacks = null;
    }
}

Example 30 with Task

use of bolts.Task in project Parse-SDK-Android by ParsePlatform.

the class ParseFile method getDataStreamInBackground.

/**
   * Asynchronously gets the data stream from cached file if available or fetches its content from
   * the network, saves the content as cached file and returns the data stream of the cached file.
   * The {@code ProgressCallback} will be called periodically with progress updates.
   *
   * @param progressCallback
   *          A {@code ProgressCallback} that is called periodically with progress updates.
   * @return A Task that is resolved when the data stream of this object has been fetched.
   */
public Task<InputStream> getDataStreamInBackground(final ProgressCallback progressCallback) {
    final TaskCompletionSource<Void> cts = new TaskCompletionSource<>();
    currentTasks.add(cts);
    return taskQueue.enqueue(new Continuation<Void, Task<InputStream>>() {

        @Override
        public Task<InputStream> then(Task<Void> toAwait) throws Exception {
            return fetchInBackground(progressCallback, toAwait, cts.getTask()).onSuccess(new Continuation<File, InputStream>() {

                @Override
                public InputStream then(Task<File> task) throws Exception {
                    return new FileInputStream(task.getResult());
                }
            });
        }
    }).continueWithTask(new Continuation<InputStream, Task<InputStream>>() {

        @Override
        public Task<InputStream> then(Task<InputStream> task) throws Exception {
            // release
            cts.trySetResult(null);
            currentTasks.remove(cts);
            return task;
        }
    });
}