/*
* Copyright 2014 Google Inc. All rights reserved.
*
* 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.
*/
package com.google.samples.apps.iosched.sync;
import android.accounts.Account;
import android.content.*;
import android.net.ConnectivityManager;
import android.os.Bundle;
import com.google.samples.apps.iosched.Config;
import com.google.samples.apps.iosched.provider.ScheduleContract;
import com.google.samples.apps.iosched.service.SessionAlarmService;
import com.google.samples.apps.iosched.service.SessionCalendarService;
import com.google.samples.apps.iosched.sync.userdata.AbstractUserDataSyncHelper;
import com.google.samples.apps.iosched.sync.userdata.UserDataSyncHelperFactory;
import com.google.samples.apps.iosched.util.AccountUtils;
import com.google.samples.apps.iosched.util.PrefUtils;
import com.google.samples.apps.iosched.util.UIUtils;
import java.io.IOException;
import static com.google.samples.apps.iosched.util.LogUtils.*;
/**
* A helper class for dealing with conference data synchronization.
* All operations occur on the thread they're called from, so it's best to wrap
* calls in an {@link android.os.AsyncTask}, or better yet, a
* {@link android.app.Service}.
*/
public class SyncHelper {
private static final String TAG = makeLogTag("SyncHelper");
private Context mContext;
private ConferenceDataHandler mConferenceDataHandler;
private RemoteConferenceDataFetcher mRemoteDataFetcher;
public SyncHelper(Context context) {
mContext = context;
mConferenceDataHandler = new ConferenceDataHandler(mContext);
mRemoteDataFetcher = new RemoteConferenceDataFetcher(mContext);
}
public static void requestManualSync(Account mChosenAccount) {
requestManualSync(mChosenAccount, false);
}
public static void requestManualSync(Account mChosenAccount, boolean userDataSyncOnly) {
if (mChosenAccount != null) {
LOGD(TAG, "Requesting manual sync for account " + mChosenAccount.name
+" userDataSyncOnly="+userDataSyncOnly);
Bundle b = new Bundle();
b.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
b.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
if (userDataSyncOnly) {
b.putBoolean(SyncAdapter.EXTRA_SYNC_USER_DATA_ONLY, true);
}
ContentResolver.setSyncAutomatically(mChosenAccount, ScheduleContract.CONTENT_AUTHORITY, true);
ContentResolver.setIsSyncable(mChosenAccount, ScheduleContract.CONTENT_AUTHORITY, 1);
boolean pending = ContentResolver.isSyncPending(mChosenAccount,
ScheduleContract.CONTENT_AUTHORITY);
if (pending) {
LOGD(TAG, "Warning: sync is PENDING. Will cancel.");
}
boolean active = ContentResolver.isSyncActive(mChosenAccount,
ScheduleContract.CONTENT_AUTHORITY);
if (active) {
LOGD(TAG, "Warning: sync is ACTIVE. Will cancel.");
}
if (pending || active) {
LOGD(TAG, "Cancelling previously pending/active sync.");
ContentResolver.cancelSync(mChosenAccount, ScheduleContract.CONTENT_AUTHORITY);
}
LOGD(TAG, "Requesting sync now.");
ContentResolver.requestSync(mChosenAccount, ScheduleContract.CONTENT_AUTHORITY, b);
} else {
LOGD(TAG, "Can't request manual sync -- no chosen account.");
}
}
/**
* Attempts to perform conference data synchronization. The data comes from the remote URL
* configured in {@link com.google.samples.apps.iosched.Config#MANIFEST_URL}. The remote URL
* must point to a manifest file that, in turn, can reference other files. For more details
* about conference data synchronization, refer to the documentation at
* http://code.google.com/p/iosched.
*
* @param syncResult (optional) the sync result object to update with statistics.
* @param account the account associated with this sync
* @return Whether or not the synchronization made any changes to the data.
*/
public boolean performSync(SyncResult syncResult, Account account, Bundle extras) {
boolean dataChanged = false;
if (!PrefUtils.isDataBootstrapDone(mContext)) {
LOGD(TAG, "Sync aborting (data bootstrap not done yet)");
return false;
}
long lastAttemptTime = PrefUtils.getLastSyncAttemptedTime(mContext);
long now = UIUtils.getCurrentTime(mContext);
long timeSinceAttempt = now - lastAttemptTime;
final boolean manualSync = extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
final boolean userDataOnly = extras.getBoolean(SyncAdapter.EXTRA_SYNC_USER_DATA_ONLY, false);
if (!manualSync && timeSinceAttempt >= 0 && timeSinceAttempt < Config.MIN_INTERVAL_BETWEEN_SYNCS) {
/*
Code removed because it was causing a runaway sync; probably because we are setting
syncResult.delayUntil incorrectly.
Random r = new Random();
long toWait = 10000 + r.nextInt(30000) // random jitter between 10 - 40 seconds
+ Config.MIN_INTERVAL_BETWEEN_SYNCS - timeSinceAttempt;
LOGW(TAG, "Sync throttled!! Another sync was attempted just " + timeSinceAttempt
+ "ms ago. Requesting delay of " + toWait + "ms.");
syncResult.fullSyncRequested = true;
syncResult.delayUntil = (System.currentTimeMillis() + toWait) / 1000L;
return false;*/
}
LOGI(TAG, "Performing sync for account: " + account);
PrefUtils.markSyncAttemptedNow(mContext);
long opStart;
long remoteSyncDuration, choresDuration;
opStart = System.currentTimeMillis();
// remote sync consists of these operations, which we try one by one (and tolerate
// individual failures on each)
final int OP_REMOTE_SYNC = 0;
final int OP_USER_SCHEDULE_SYNC = 1;
final int OP_USER_FEEDBACK_SYNC = 2;
int[] opsToPerform = userDataOnly ?
new int[] { OP_USER_SCHEDULE_SYNC } :
new int[] { OP_REMOTE_SYNC, OP_USER_SCHEDULE_SYNC, OP_USER_FEEDBACK_SYNC};
for (int op : opsToPerform) {
try {
switch (op) {
case OP_REMOTE_SYNC:
dataChanged |= doRemoteSync();
break;
case OP_USER_SCHEDULE_SYNC:
dataChanged |= doUserScheduleSync(account.name);
break;
case OP_USER_FEEDBACK_SYNC:
doUserFeedbackSync();
break;
}
} catch (AuthException ex) {
syncResult.stats.numAuthExceptions++;
// if we have a token, try to refresh it
if (AccountUtils.hasToken(mContext, account.name)) {
AccountUtils.refreshAuthToken(mContext);
} else {
LOGW(TAG, "No auth token yet for this account. Skipping remote sync.");
}
} catch (Throwable throwable) {
throwable.printStackTrace();
LOGE(TAG, "Error performing remote sync.");
increaseIoExceptions(syncResult);
}
}
remoteSyncDuration = System.currentTimeMillis() - opStart;
// If data has changed, there are a few chores we have to do
opStart = System.currentTimeMillis();
if (dataChanged) {
try {
performPostSyncChores(mContext);
} catch (Throwable throwable) {
throwable.printStackTrace();
LOGE(TAG, "Error performing post sync chores.");
}
}
clearExpertsIfNecessary();
choresDuration = System.currentTimeMillis() - opStart;
int operations = mConferenceDataHandler.getContentProviderOperationsDone();
if (syncResult != null && syncResult.stats != null) {
syncResult.stats.numEntries += operations;
syncResult.stats.numUpdates += operations;
}
if (dataChanged) {
long totalDuration = choresDuration + remoteSyncDuration;
LOGD(TAG, "SYNC STATS:\n" +
" * Account synced: " + (account == null ? "null" : account.name) + "\n" +
" * Content provider operations: " + operations + "\n" +
" * Remote sync took: " + remoteSyncDuration + "ms\n" +
" * Post-sync chores took: " + choresDuration + "ms\n" +
" * Total time: " + totalDuration + "ms\n" +
" * Total data read from cache: \n" +
(mRemoteDataFetcher.getTotalBytesReadFromCache() / 1024) + "kB\n" +
" * Total data downloaded: \n" +
(mRemoteDataFetcher.getTotalBytesDownloaded() / 1024) + "kB");
}
LOGI(TAG, "End of sync (" + (dataChanged ? "data changed" : "no data change") + ")");
updateSyncInterval(mContext, account);
return dataChanged;
}
public static void performPostSyncChores(final Context context) {
// Update search index
LOGD(TAG, "Updating search index.");
context.getContentResolver().update(ScheduleContract.SearchIndex.CONTENT_URI,
new ContentValues(), null, null);
// Sync calendars
LOGD(TAG, "Session data changed. Syncing starred sessions with Calendar.");
syncCalendar(context);
}
private static void syncCalendar(Context context) {
Intent intent = new Intent(SessionCalendarService.ACTION_UPDATE_ALL_SESSIONS_CALENDAR);
intent.setClass(context, SessionCalendarService.class);
context.startService(intent);
}
private void doUserFeedbackSync() {
LOGD(TAG, "Syncing feedback");
new FeedbackSyncHelper(mContext).sync();
}
/**
* Checks if the remote server has new data that we need to import. If so, download
* the new data and import it into the database.
*
* @return Whether or not data was changed.
* @throws IOException if there is a problem downloading or importing the data.
*/
private boolean doRemoteSync() throws IOException {
if (!isOnline()) {
LOGD(TAG, "Not attempting remote sync because device is OFFLINE");
return false;
}
LOGD(TAG, "Starting remote sync.");
// Fetch the remote data files via RemoteConferenceDataFetcher
String[] dataFiles = mRemoteDataFetcher.fetchConferenceDataIfNewer(
mConferenceDataHandler.getDataTimestamp());
if (dataFiles != null) {
LOGI(TAG, "Applying remote data.");
// save the remote data to the database
mConferenceDataHandler.applyConferenceData(dataFiles,
mRemoteDataFetcher.getServerDataTimestamp(), true);
LOGI(TAG, "Done applying remote data.");
// mark that conference data sync succeeded
PrefUtils.markSyncSucceededNow(mContext);
return true;
} else {
// no data to process (everything is up to date)
// mark that conference data sync succeeded
PrefUtils.markSyncSucceededNow(mContext);
return false;
}
}
/**
* Checks if there are changes on MySchedule to sync with/from remote AppData folder.
*
* @return Whether or not data was changed.
* @throws IOException if there is a problem uploading the data.
*/
private boolean doUserScheduleSync(String accountName) throws IOException {
if (!isOnline()) {
LOGD(TAG, "Not attempting myschedule sync because device is OFFLINE");
return false;
}
LOGD(TAG, "Starting user data (myschedule) sync.");
AbstractUserDataSyncHelper helper = UserDataSyncHelperFactory.buildSyncHelper(
mContext, accountName);
boolean modified = helper.sync();
if (modified) {
// schedule notifications for the starred sessions
Intent scheduleIntent = new Intent(
SessionAlarmService.ACTION_SCHEDULE_ALL_STARRED_BLOCKS,
null, mContext, SessionAlarmService.class);
mContext.startService(scheduleIntent);
}
return modified;
}
// Returns whether we are connected to the internet.
private boolean isOnline() {
ConnectivityManager cm = (ConnectivityManager) mContext.getSystemService(
Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo() != null &&
cm.getActiveNetworkInfo().isConnectedOrConnecting();
}
private void increaseIoExceptions(SyncResult syncResult) {
if (syncResult != null && syncResult.stats != null) {
++syncResult.stats.numIoExceptions;
}
}
private void increaseSuccesses(SyncResult syncResult) {
if (syncResult != null && syncResult.stats != null) {
++syncResult.stats.numEntries;
++syncResult.stats.numUpdates;
}
}
private boolean clearExpertsIfNecessary() {
if (Config.hasExpertsDirectoryExpired()) {
return 0 < mContext.getContentResolver()
.delete(ScheduleContract.Experts.CONTENT_URI, null, null);
}
return false;
}
public static class AuthException extends RuntimeException {
}
public static long calculateRecommendedSyncInterval(final Context context) {
long now = UIUtils.getCurrentTime(context);
long aroundConferenceStart = Config.CONFERENCE_START_MILLIS - Config.AUTO_SYNC_AROUND_CONFERENCE_THRESH;
if (now < aroundConferenceStart) {
return Config.AUTO_SYNC_INTERVAL_LONG_BEFORE_CONFERENCE;
} else if (now <= Config.CONFERENCE_END_MILLIS) {
return Config.AUTO_SYNC_INTERVAL_AROUND_CONFERENCE;
} else {
return Config.AUTO_SYNC_INTERVAL_AFTER_CONFERENCE;
}
}
public static void updateSyncInterval(final Context context, final Account account) {
LOGD(TAG, "Checking sync interval for " + account);
long recommended = calculateRecommendedSyncInterval(context);
long current = PrefUtils.getCurSyncInterval(context);
LOGD(TAG, "Recommended sync interval " + recommended + ", current " + current);
if (recommended != current) {
LOGD(TAG, "Setting up sync for account " + account + ", interval " + recommended + "ms");
ContentResolver.setIsSyncable(account, ScheduleContract.CONTENT_AUTHORITY, 1);
ContentResolver.setSyncAutomatically(account, ScheduleContract.CONTENT_AUTHORITY, true);
ContentResolver.addPeriodicSync(account, ScheduleContract.CONTENT_AUTHORITY,
new Bundle(), recommended / 1000L);
PrefUtils.setCurSyncInterval(context, recommended);
} else {
LOGD(TAG, "No need to update sync interval.");
}
}
}