com.parse.ParseEventuallyQueue Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of parse-android Show documentation
Show all versions of parse-android Show documentation
A library that gives you access to the powerful Parse cloud platform from your Android app.
/*
* Copyright (c) 2015-present, Parse, LLC.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
package com.parse;
import android.util.SparseArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import bolts.Task;
/* package */ abstract class ParseEventuallyQueue {
private boolean isConnected;
/**
* Gets notifications of various events happening in the command cache, so that tests can be
* synchronized.
*/
private TestHelper testHelper;
public abstract void onDestroy();
public void setConnected(boolean connected) {
isConnected = connected;
}
public boolean isConnected() {
return isConnected;
}
public abstract int pendingCount();
public void setTimeoutRetryWaitSeconds(double seconds) {
// do nothing
}
public void setMaxCacheSizeBytes(int bytes) {
// do nothing
}
/** See class TestHelper below. */
public TestHelper getTestHelper() {
if (testHelper == null) {
testHelper = new TestHelper();
}
return testHelper;
}
protected void notifyTestHelper(int event) {
notifyTestHelper(event, null);
}
protected void notifyTestHelper(int event, Throwable t) {
if (testHelper != null) {
testHelper.notify(event, t);
}
}
public abstract void pause();
public abstract void resume();
/**
* Attempts to run the given command and any pending commands. Adds the command to the pending set
* if it can't be run yet.
*
* @param command
* - The command to run.
* @param object
* - If this command references an unsaved object, we need to remove any previous command
* referencing that unsaved object. Otherwise, it will get created over and over again.
* So object is a reference to the object, if it has no objectId. Otherwise, it can be
* null.
*/
public abstract Task enqueueEventuallyAsync(ParseRESTCommand command,
ParseObject object);
protected ParseRESTCommand commandFromJSON(JSONObject json)
throws JSONException {
ParseRESTCommand command = null;
if (ParseRESTCommand.isValidCommandJSONObject(json)) {
command = ParseRESTCommand.fromJSONObject(json);
} else if (ParseRESTCommand.isValidOldFormatCommandJSONObject(json)) {
// do nothing
} else {
throw new JSONException("Failed to load command from JSON.");
}
return command;
}
/* package */ Task waitForOperationSetAndEventuallyPin(ParseOperationSet operationSet,
EventuallyPin eventuallyPin) {
return Task.forResult(null);
}
/* package */ abstract void simulateReboot();
/**
* Gets rid of all pending commands.
*/
public abstract void clear();
/**
* Fakes an object update notification for use in tests. This is used by saveEventually to make it
* look like test code has updated an object through the command cache even if it actually
* avoided executing update by determining the object wasn't dirty.
*/
void fakeObjectUpdate() {
if (testHelper != null) {
testHelper.notify(TestHelper.COMMAND_ENQUEUED);
testHelper.notify(TestHelper.COMMAND_SUCCESSFUL);
testHelper.notify(TestHelper.OBJECT_UPDATED);
}
}
/**
* Gets notifications of various events happening in the command cache, so that tests can be
* synchronized. See ParseCommandCacheTest for examples of how to use this.
*/
public static class TestHelper {
private static final int MAX_EVENTS = 1000;
public static final int COMMAND_SUCCESSFUL = 1;
public static final int COMMAND_FAILED = 2;
public static final int COMMAND_ENQUEUED = 3;
public static final int COMMAND_NOT_ENQUEUED = 4;
public static final int OBJECT_UPDATED = 5;
public static final int OBJECT_REMOVED = 6;
public static final int NETWORK_DOWN = 7;
public static final int COMMAND_OLD_FORMAT_DISCARDED = 8;
public static String getEventString(int event) {
switch (event) {
case COMMAND_SUCCESSFUL:
return "COMMAND_SUCCESSFUL";
case COMMAND_FAILED:
return "COMMAND_FAILED";
case COMMAND_ENQUEUED:
return "COMMAND_ENQUEUED";
case COMMAND_NOT_ENQUEUED:
return "COMMAND_NOT_ENQUEUED";
case OBJECT_UPDATED:
return "OBJECT_UPDATED";
case OBJECT_REMOVED:
return "OBJECT_REMOVED";
case NETWORK_DOWN:
return "NETWORK_DOWN";
case COMMAND_OLD_FORMAT_DISCARDED:
return "COMMAND_OLD_FORMAT_DISCARDED";
default:
throw new IllegalStateException("Encountered unknown event: " + event);
}
}
private SparseArray events = new SparseArray<>();
private TestHelper() {
clear();
}
public void clear() {
events.clear();
events.put(COMMAND_SUCCESSFUL, new Semaphore(MAX_EVENTS));
events.put(COMMAND_FAILED, new Semaphore(MAX_EVENTS));
events.put(COMMAND_ENQUEUED, new Semaphore(MAX_EVENTS));
events.put(COMMAND_NOT_ENQUEUED, new Semaphore(MAX_EVENTS));
events.put(OBJECT_UPDATED, new Semaphore(MAX_EVENTS));
events.put(OBJECT_REMOVED, new Semaphore(MAX_EVENTS));
events.put(NETWORK_DOWN, new Semaphore(MAX_EVENTS));
events.put(COMMAND_OLD_FORMAT_DISCARDED, new Semaphore(MAX_EVENTS));
for (int i = 0; i < events.size(); i++) {
int event = events.keyAt(i);
events.get(event).acquireUninterruptibly(MAX_EVENTS);
}
}
public int unexpectedEvents() {
int sum = 0;
for (int i = 0; i < events.size(); i++) {
int event = events.keyAt(i);
sum += events.get(event).availablePermits();
}
return sum;
}
public List getUnexpectedEvents() {
List unexpectedEvents = new ArrayList<>();
for (int i = 0; i < events.size(); i++) {
int event = events.keyAt(i);
if (events.get(event).availablePermits() > 0) {
unexpectedEvents.add(getEventString(event));
}
}
return unexpectedEvents;
}
public void notify(int event) {
notify(event, null);
}
public void notify(int event, Throwable t) {
events.get(event).release();
}
public boolean waitFor(int event) {
return waitFor(event, 1);
}
public boolean waitFor(int event, int permits) {
try {
return events.get(event).tryAcquire(permits, 10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
return false;
}
}
}
}