public void pushMetadataOnSave(Metadata model, GtasksInvoker invoker) throws IOException {
AndroidUtilities.sleepDeep(1000L);
String taskId = model.getValue(GtasksMetadata.ID);
String listId = model.getValue(GtasksMetadata.LIST_ID);
String parent = gtasksMetadataService.getRemoteParentId(model);
String priorSibling = gtasksMetadataService.getRemoteSiblingId(listId, model);
MoveRequest move = new MoveRequest(invoker, taskId, listId, parent, priorSibling);
com.google.api.services.tasks.model.Task result = move.push();
// Update order metadata from result
if (result != null) {
model.setValue(GtasksMetadata.GTASKS_ORDER, Long.parseLong(result.getPosition()));
model.putTransitory(SyncFlags.GTASKS_SUPPRESS_SYNC, true);
metadataDao.saveExisting(model);
}
}
private void sync() {
try {
int batchSize = 4;
List<ClientToServerMessage<?>> messageBatch = new ArrayList<ClientToServerMessage<?>>();
while (true) {
synchronized (monitor) {
while ((pendingMessages.isEmpty() && !timeForBackgroundSync())
|| !actFmPreferenceService.isLoggedIn()
|| !syncMigration) {
try {
if ((pendingMessages.isEmpty() || !actFmPreferenceService.isLoggedIn())
&& notificationId >= 0) {
notificationManager.cancel(notificationId);
notificationId = -1;
}
monitor.wait();
AndroidUtilities.sleepDeep(
500L); // Wait briefly for large database operations to finish (e.g. adding a task
// with several tags may trigger a message before all saves are done--fix
// this?)
if (!syncMigration) {
syncMigration =
Preferences.getBoolean(AstridNewSyncMigrator.PREF_SYNC_MIGRATION, false);
}
} catch (InterruptedException e) {
// Ignored
}
}
}
boolean recordSyncSuccess = true;
if (timeForBackgroundSync()) {
repopulateQueueFromOutstandingTables();
enqueueMessage(
BriefMe.instantiateBriefMeForClass(
TaskListMetadata.class, NameMaps.PUSHED_AT_TASK_LIST_METADATA),
DEFAULT_REFRESH_RUNNABLE);
enqueueMessage(
BriefMe.instantiateBriefMeForClass(Task.class, NameMaps.PUSHED_AT_TASKS),
DEFAULT_REFRESH_RUNNABLE);
enqueueMessage(
BriefMe.instantiateBriefMeForClass(TagData.class, NameMaps.PUSHED_AT_TAGS),
DEFAULT_REFRESH_RUNNABLE);
enqueueMessage(
BriefMe.instantiateBriefMeForClass(User.class, NameMaps.PUSHED_AT_USERS),
DEFAULT_REFRESH_RUNNABLE);
setTimeForBackgroundSync(false);
}
while (messageBatch.size() < batchSize && !pendingMessages.isEmpty()) {
ClientToServerMessage<?> message = pendingMessages.remove(0);
if (message != null) {
messageBatch.add(message);
}
}
if (!messageBatch.isEmpty() && checkForToken()) {
JSONPayloadBuilder payload = new JSONPayloadBuilder();
MultipartEntity entity = new MultipartEntity();
boolean containsChangesHappened = false;
for (int i = 0; i < messageBatch.size(); i++) {
ClientToServerMessage<?> message = messageBatch.get(i);
boolean success = payload.addMessage(message, entity);
if (success) {
if (message instanceof ChangesHappened) {
containsChangesHappened = true;
}
} else {
messageBatch.remove(i);
i--;
}
}
if (payload.getMessageCount() == 0) {
messageBatch.clear();
continue;
}
setupNotification();
payload.addJSONObject(getClientVersion());
JSONArray errors = null;
try {
JSONObject response =
actFmInvoker.postSync(
payload.closeAndReturnString(), entity, containsChangesHappened, token);
// process responses
String time = response.optString("time");
JSONArray serverMessagesJson = response.optJSONArray("messages");
if (serverMessagesJson != null) {
setWidgetSuppression(true);
for (int i = 0; i < serverMessagesJson.length(); i++) {
JSONObject serverMessageJson = serverMessagesJson.optJSONObject(i);
if (serverMessageJson != null) {
ServerToClientMessage serverMessage =
ServerToClientMessage.instantiateMessage(serverMessageJson);
if (serverMessage != null) {
serverMessage.processMessage(time);
} else {
syncLog(
"Index "
+ i
+ " unable to instantiate message "
+ serverMessageJson.toString());
}
}
}
errors = response.optJSONArray("errors");
boolean errorsExist = (errors != null && errors.length() > 0);
replayOutstandingChanges(errorsExist);
setWidgetSuppression(false);
}
batchSize = Math.max(12, Math.min(batchSize, messageBatch.size()) * 2);
if (recordSyncSuccess) {
actFmPreferenceService.setLastError(null, null);
actFmPreferenceService.recordSuccessfulSync();
}
} catch (IOException e) {
Log.e(ERROR_TAG, "IOException", e);
batchSize = Math.max(batchSize / 2, 1);
}
Set<SyncMessageCallback> callbacksExecutedThisLoop = new HashSet<SyncMessageCallback>();
Map<Integer, List<JSONArray>> errorMap = buildErrorMap(errors);
for (int i = 0; i < messageBatch.size(); i++) {
ClientToServerMessage<?> message = messageBatch.get(i);
try {
SyncMessageCallback r = pendingCallbacks.remove(message);
if (r != null && !callbacksExecutedThisLoop.contains(r)) {
List<JSONArray> errorList = errorMap.get(i);
if (errorList == null || errorList.isEmpty()) {
r.runOnSuccess();
} else {
r.runOnErrors(errorList);
}
callbacksExecutedThisLoop.add(r);
}
} catch (Exception e) {
Log.e(ERROR_TAG, "Unexpected exception executing sync callback", e);
}
}
messageBatch.clear();
}
}
} catch (Exception e) {
// In the worst case, restart thread if something goes wrong
Log.e(ERROR_TAG, "Unexpected sync thread exception", e);
thread = null;
startSyncThread();
}
}
/** Synchronize with server when data changes */
public void pushTaskOnSave(Task task, ContentValues values, GtasksInvoker invoker, boolean sleep)
throws IOException {
if (sleep) AndroidUtilities.sleepDeep(1000L); // Wait for metadata to be saved
Metadata gtasksMetadata = gtasksMetadataService.getTaskMetadata(task.getId());
com.google.api.services.tasks.model.Task remoteModel = null;
boolean newlyCreated = false;
String remoteId = null;
String listId = Preferences.getStringValue(GtasksPreferenceService.PREF_DEFAULT_LIST);
if (listId == null) {
com.google.api.services.tasks.model.TaskList defaultList = invoker.getGtaskList(DEFAULT_LIST);
if (defaultList != null) {
listId = defaultList.getId();
Preferences.setString(GtasksPreferenceService.PREF_DEFAULT_LIST, listId);
} else {
listId = DEFAULT_LIST;
}
}
if (gtasksMetadata == null
|| !gtasksMetadata.containsNonNullValue(GtasksMetadata.ID)
|| TextUtils.isEmpty(gtasksMetadata.getValue(GtasksMetadata.ID))) { // Create case
if (gtasksMetadata == null) {
gtasksMetadata = GtasksMetadata.createEmptyMetadata(task.getId());
}
if (gtasksMetadata.containsNonNullValue(GtasksMetadata.LIST_ID)) {
listId = gtasksMetadata.getValue(GtasksMetadata.LIST_ID);
}
remoteModel = new com.google.api.services.tasks.model.Task();
newlyCreated = true;
} else { // update case
remoteId = gtasksMetadata.getValue(GtasksMetadata.ID);
listId = gtasksMetadata.getValue(GtasksMetadata.LIST_ID);
remoteModel = new com.google.api.services.tasks.model.Task();
remoteModel.setId(remoteId);
}
// If task was newly created but without a title, don't sync--we're in the middle of
// creating a task which may end up being cancelled
if (newlyCreated
&& (!values.containsKey(Task.TITLE.name) || TextUtils.isEmpty(task.getValue(Task.TITLE)))) {
return;
}
// Update the remote model's changed properties
if (values.containsKey(Task.DELETION_DATE.name) && task.isDeleted()) {
remoteModel.setDeleted(true);
}
if (values.containsKey(Task.TITLE.name)) {
remoteModel.setTitle(task.getValue(Task.TITLE));
}
if (values.containsKey(Task.NOTES.name)) {
remoteModel.setNotes(task.getValue(Task.NOTES));
}
if (values.containsKey(Task.DUE_DATE.name) && task.hasDueDate()) {
remoteModel.setDue(GtasksApiUtilities.unixTimeToGtasksDueDate(task.getValue(Task.DUE_DATE)));
}
if (values.containsKey(Task.COMPLETION_DATE.name)) {
if (task.isCompleted()) {
remoteModel.setCompleted(
GtasksApiUtilities.unixTimeToGtasksCompletionTime(task.getValue(Task.COMPLETION_DATE)));
remoteModel.setStatus("completed"); // $NON-NLS-1$
} else {
remoteModel.setCompleted(null);
remoteModel.setStatus("needsAction"); // $NON-NLS-1$
}
}
if (!newlyCreated) {
invoker.updateGtask(listId, remoteModel);
} else {
String parent = gtasksMetadataService.getRemoteParentId(gtasksMetadata);
String priorSibling = gtasksMetadataService.getRemoteSiblingId(listId, gtasksMetadata);
CreateRequest create = new CreateRequest(invoker, listId, remoteModel, parent, priorSibling);
com.google.api.services.tasks.model.Task created = create.executePush();
if (created != null) {
// Update the metadata for the newly created task
gtasksMetadata.setValue(GtasksMetadata.ID, created.getId());
gtasksMetadata.setValue(GtasksMetadata.LIST_ID, listId);
} else return;
}
task.setValue(Task.MODIFICATION_DATE, DateUtilities.now());
gtasksMetadata.setValue(GtasksMetadata.LAST_SYNC, DateUtilities.now() + 1000L);
metadataService.save(gtasksMetadata);
task.putTransitory(SyncFlags.GTASKS_SUPPRESS_SYNC, true);
taskDao.saveExistingWithSqlConstraintCheck(task);
}
/**
* Shows an Astrid notification. Pulls in ring tone and quiet hour settings from preferences. You
* can make it say anything you like.
*
* @param ringTimes number of times to ring (-1 = nonstop)
*/
public static void showNotification(
int notificationId, Intent intent, int type, String title, String text, int ringTimes) {
Context context = ContextManager.getContext();
if (notificationManager == null) notificationManager = new AndroidNotificationManager(context);
// quiet hours? unless alarm clock
boolean quietHours = false;
int quietHoursStart = Preferences.getIntegerFromString(R.string.p_rmd_quietStart, -1);
int quietHoursEnd = Preferences.getIntegerFromString(R.string.p_rmd_quietEnd, -1);
if (quietHoursStart != -1 && quietHoursEnd != -1 && ringTimes >= 0) {
int hour = new Date().getHours();
if (quietHoursStart <= quietHoursEnd) {
if (hour >= quietHoursStart && hour < quietHoursEnd) quietHours = true;
} else { // wrap across 24/hour boundary
if (hour >= quietHoursStart || hour < quietHoursEnd) quietHours = true;
}
}
PendingIntent pendingIntent =
PendingIntent.getActivity(
context, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT);
// set up properties (name and icon) for the notification
int icon;
switch (Preferences.getIntegerFromString(R.string.p_rmd_icon, ICON_SET_ASTRID)) {
case ICON_SET_PINK:
icon = R.drawable.notif_pink_alarm;
break;
case ICON_SET_BORING:
icon = R.drawable.notif_boring_alarm;
break;
default:
icon = R.drawable.notif_astrid;
}
// create notification object
Notification notification = new Notification(icon, text, System.currentTimeMillis());
notification.setLatestEventInfo(context, title, text, pendingIntent);
notification.flags |= Notification.FLAG_AUTO_CANCEL;
if (Preferences.getBoolean(R.string.p_rmd_persistent, true)) {
notification.flags |= Notification.FLAG_NO_CLEAR | Notification.FLAG_SHOW_LIGHTS;
notification.ledOffMS = 5000;
notification.ledOnMS = 700;
notification.ledARGB = Color.YELLOW;
} else notification.defaults = Notification.DEFAULT_LIGHTS;
AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
// detect call state
TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
int callState = tm.getCallState();
boolean voiceReminder = Preferences.getBoolean(R.string.p_voiceRemindersEnabled, false);
// if multi-ring is activated, set up the flags for insistent
// notification, and increase the volume to full volume, so the user
// will actually pay attention to the alarm
if (ringTimes != 1 && (type != ReminderService.TYPE_RANDOM)) {
notification.audioStreamType = AudioManager.STREAM_ALARM;
audioManager.setStreamVolume(
AudioManager.STREAM_ALARM, audioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM), 0);
// insistent rings until notification is disabled
if (ringTimes < 0) {
notification.flags |= Notification.FLAG_INSISTENT;
voiceReminder = false;
}
} else {
notification.audioStreamType = AudioManager.STREAM_NOTIFICATION;
}
// quiet hours = no sound
if (quietHours || callState != TelephonyManager.CALL_STATE_IDLE) {
notification.sound = null;
voiceReminder = false;
} else {
String notificationPreference = Preferences.getStringValue(R.string.p_rmd_ringtone);
if (audioManager.getStreamVolume(AudioManager.STREAM_RING) == 0) {
notification.sound = null;
voiceReminder = false;
} else if (notificationPreference != null) {
if (notificationPreference.length() > 0) {
Uri notificationSound = Uri.parse(notificationPreference);
notification.sound = notificationSound;
} else {
notification.sound = null;
}
} else {
notification.defaults |= Notification.DEFAULT_SOUND;
}
}
// quiet hours && ! due date or snooze = no vibrate
if (quietHours && !(type == ReminderService.TYPE_DUE || type == ReminderService.TYPE_SNOOZE)) {
notification.vibrate = null;
} else if (callState != TelephonyManager.CALL_STATE_IDLE) {
notification.vibrate = null;
} else {
if (Preferences.getBoolean(R.string.p_rmd_vibrate, true)
&& audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) {
notification.vibrate = new long[] {0, 1000, 500, 1000, 500, 1000};
} else {
notification.vibrate = null;
}
}
if (Constants.DEBUG)
Log.w("Astrid", "Logging notification: " + text); // $NON-NLS-1$ //$NON-NLS-2$
for (int i = 0; i < Math.max(ringTimes, 1); i++) {
notificationManager.notify(notificationId, notification);
AndroidUtilities.sleepDeep(500);
}
if (voiceReminder) {
AndroidUtilities.sleepDeep(2000);
for (int i = 0; i < 50; i++) {
AndroidUtilities.sleepDeep(500);
if (audioManager.getMode() != AudioManager.MODE_RINGTONE) break;
}
try {
VoiceOutputService.getVoiceOutputInstance().queueSpeak(text);
} catch (VerifyError e) {
// unavailable
}
}
}
