Java ContentResolver.requestSync方法代码示例

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Based on https://gist.github.com/udacityandroid/7230489fb8cb3f46afee
 */
private static void configurePeriodicSync(Context context, int syncInterval, int flexTime) {
    Account account = getSyncAccount(context, syncInterval, flexTime);
    String authority = context.getString(R.string.rnsb_content_authority);
    
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // We can enable inexact timers in our periodic sync (better for batter life)
        SyncRequest request = new SyncRequest.Builder().
                syncPeriodic(syncInterval, flexTime).
                setSyncAdapter(account, authority).
                setExtras(new Bundle()).build();
        ContentResolver.requestSync(request);
    } else {
        ContentResolver.addPeriodicSync(account,
                authority, new Bundle(), syncInterval);
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Updates ContentResolver sync settings for an Account's specified SyncAdapter.
 *
 * <p>Sets an accounts SyncAdapter (selected based on authority) to sync/not-sync automatically
 * and immediately requests/cancels a sync.
 *
 * <p>updateSync should always be called under {@link AccountSnippet#mLock} write lock to avoid
 * flapping between the getSyncAutomatically and setSyncAutomatically calls.
 *
 * @param account A Google Account.
 * @param authority The authority of a content provider that should (not) be synced.
 * @param sync Whether or not the account's content provider should be synced.
 */
private void updateSync(Account account, String authority, boolean sync) {
    if (ContentResolver.getSyncAutomatically(account, authority) != sync) {
        ContentResolver.setSyncAutomatically(account, authority, sync);
        if (sync) {
            ContentResolver.requestSync(account, authority, new Bundle());
        } else {
            ContentResolver.cancelSync(account, authority);
        }
        Log.i(
                "Set sync to "
                        + sync
                        + " for account "
                        + account
                        + ", adapter "
                        + authority
                        + ".");
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Helper method to schedule the sync adapter periodic execution
 */
public static void configurePeriodicSync(Context context, int syncInterval, int flexTime) {
    Account account = getSyncAccount(context);
    String authority = context.getString(R.string.content_authority);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // we can enable inexact timers in our periodic sync
        SyncRequest request = new SyncRequest.Builder().
                syncPeriodic(syncInterval, flexTime).
                setSyncAdapter(account, authority).
                setExtras(new Bundle()).build();
        ContentResolver.requestSync(request);
    } else {
        ContentResolver.addPeriodicSync(account,
                authority, new Bundle(), syncInterval);
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
public void setSyncActivated(boolean enabled) {
	
       ContentResolver.setMasterSyncAutomatically(enabled);
       
       if (enabled) {
       	SyncAdapterType[] types = ContentResolver.getSyncAdapterTypes();
       	AccountManager accmgr = AccountManager.get(mContext);
       	for (SyncAdapterType type : types) {
       		
       		Account[] accounts = accmgr.getAccountsByType(type.accountType);
       		for (Account account : accounts) {
       			
       			if (Constants.DEBUG) {
       				Log.d(TAG, "synching account, name:" + account.name  + ", type: " + account.type);
       			}
       			
       			enabled = ContentResolver.getSyncAutomatically(account, type.authority);
       			if (enabled) {
       				// trigger update for next account
       				ContentResolver.requestSync(account, type.authority, new Bundle());
       			}
       		}
       	}
       }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
@Override
public void onReceive(Context context, Intent intent) {
    String accountName = AccountUtils.getActiveAccountName(context);
    if (TextUtils.isEmpty(accountName)) {
        return;
    }
    Account account = AccountUtils.getActiveAccount(context);
    if (account != null) {
        if (intent.getBooleanExtra(EXTRA_USER_DATA_SYNC_ONLY, false) ) {
            // this is a request to sync user data only, so do a manual sync right now
            // with the userDataOnly == true.
            SyncHelper.requestManualSync(account, true);
        } else {
            // this is a request to sync everything
            ContentResolver.requestSync(account, ScheduleContract.CONTENT_AUTHORITY, new Bundle());
        }
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
public static void requestSync(Context context, Bundle previousExtras) {
    int attempt = previousExtras.getInt(BUNDLE_ATTEMPT, 0);

    if (attempt > MAX_REPEATED_SYNC_ATTEMPT) {
        if (BuildConfig.DEBUG) {
            Log.d(LOG_TAG, String.format("" +
                    "Repeated sync is requested: attempt %s: denied", attempt));
        }

        return;
    }

    Bundle newExtras = new Bundle();
    newExtras.putInt(BUNDLE_ATTEMPT, attempt + 1);

    if (BuildConfig.DEBUG) {
        Log.d(LOG_TAG, String.format("Repeated sync is requested: attempt %s", attempt));
    }

    ContentResolver.requestSync(makeAccount(context), GigApplication.getSyncAuthority(), newExtras);
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
public static void syncImmediately(Context context) {

        Bundle bundle = new Bundle();
        bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
        bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
        ContentResolver.requestSync(getSyncAccount(context),
                AUTHORITY, bundle);
        System.out.println("xxxx syncImmediately");
    }
 

import android.content.ContentResolver; //导入方法依赖的package包/类
static public void requestSync(Context context) {
    String accountType = context.getResources().getString(R.string.account_type);
    Logger logger = Logger.getInstance(context);
    for (Account account : AccountManager.get(context).getAccountsByType(accountType)){
        Bundle extras = new Bundle();
        extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
        extras.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
        ContentResolver.requestSync(account, CalendarContract.AUTHORITY, extras);
        logger.info(TAG, "Explicitly requested sync for account %s", account.name);
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Helper method to have the sync adapter sync immediately
 */
public static void syncImmediately(Context context, int syncInterval, int syncFlexTime) {
    Bundle bundle = new Bundle();
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
    ContentResolver.requestSync(getSyncAccount(context, syncInterval, syncFlexTime),
            context.getString(R.string.rnsb_content_authority), bundle);
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Helper method to have the sync adapter sync immediately
 * @param context The context used to access the account service
 */
public static void syncImmediately(Context context) {
    Bundle bundle = new Bundle();
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
    ContentResolver.requestSync(getSyncAccount(context),
            context.getString(R.string.content_authority), bundle);
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
public static void requestImmediateSync() {
    Bundle b = new Bundle();
    b.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
    b.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);

    Account account = AccountService.getAccount();
    ContentResolver.requestSync(account, FuelUpContract.CONTENT_AUTHORITY, b);
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
@Override
public void onChange(boolean selfChange, Uri uri) {
    Bundle bundle = new Bundle();
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
    ContentResolver.requestSync(
            AccountService.getAccount(),
            FuelUpContract.CONTENT_AUTHORITY,
            bundle);
    PreferencesUtils.setLastChange(context);
    Log.i(LOG_TAG, "sync adapter has been notified");
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
public void sync(Bundle data) {
    AccountManager manager = (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE);
    Account[] accounts = manager.getAccountsByType(context.getString(R.string.auth_type));
    if (accounts.length > 0) {
        Bundle settings = new Bundle();
        settings.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
        settings.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
        settings.putString(SyncAdapter.KEY_SYNC_MODEL, model.getModelName());
        if (data != null)
            settings.putAll(data);
        ContentResolver.requestSync(accounts[0], model.getAuthority(), settings);
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Helper method to schedule the sync adapter periodic execution
 */
public static void configurePeriodicSync(Context context, long syncInterval, long flexTime) {
    Account account = getSyncAccount(context);
    String authority = context.getString(R.string.content_authority);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // we can enable inexact timers in our periodic sync
        SyncRequest request = new SyncRequest.Builder().
                syncPeriodic(syncInterval, flexTime).
                setSyncAdapter(account, authority).
                setExtras(new Bundle()).build();
        ContentResolver.requestSync(request);
    } else {
        ContentResolver.addPeriodicSync(account,
                authority, new Bundle(), syncInterval);
    }
}
 

import android.content.ContentResolver; //导入方法依赖的package包/类
/**
 * Helper method to trigger an immediate sync ("refresh").
 * <p>
 * <p>This should only be used when we need to preempt the normal sync schedule. Typically, this
 * means the user has pressed the "refresh" button.
 * <p>
 * Note that SYNC_EXTRAS_MANUAL will cause an immediate sync, without any optimization to
 * preserve battery life. If you know new data is available (perhaps via a GCM notification),
 * but the user is not actively waiting for that data, you should omit this flag; this will give
 * the OS additional freedom in scheduling your sync request.
 */
public static void forceRefreshAll(Context context) {
    Bundle bundle = new Bundle();
    // Disable sync backoff and ignore sync preferences.
    // In other words...perform sync NOW!
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
    bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
    ContentResolver.requestSync(
            getAccount(context),        // Sync account
            CONTENT_AUTHORITY,          // Content authority
            bundle);         // Extras
}