public void batchInsert(Context context, List<String> names) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

    // List に ContentProviderOperation を詰め込んで、バッチ処理時にすべてを実行するようにする
    for (String name : names) {
        ContentValues values = new ContentValues();
        values.put("name", name);

        // ContentProviderOperation#newInsert(Uri) によって、挿入に関する操作手順を生成するビルダーを取得する
        ContentProviderOperation insertOp = ContentProviderOperation.newInsert(MyContentProvider.CONTENT_URI)
                .withValues(values)  // ContentValues に含まれるデータを挿入
                .build();  // ContentProviderOperation を作成
        ops.add(insertOp);
    }

    ContentResolver resolver = context.getContentResolver();
    resolver.applyBatch(MyContentProvider.AUTHORITY, ops);  // バッチ処理を実行
}

public void batchUpdate(Context context, List<Integer> ids, List<String> names) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

    for (int i = 0; i < ids.size() && i < names.size(); i++) {
        Integer id = ids.get(i);
        String name = names.get(i);

        ContentValues values = new ContentValues();
        values.put("name", name);

        // ContentProviderOperation#newUpdate(Uri) によって、更新に関する操作手順を生成するビルダーを取得する
        ContentProviderOperation updateOp = ContentProviderOperation.newUpdate(MyContentProvider.CONTENT_URI)
                .withValues(values)
                .withSelection("_id = ?", new String[] { id.toString() })  // Update 対象の条件を付与
                .build();
        ops.add(updateOp);
    }

    ContentResolver resolver = context.getContentResolver();
    resolver.applyBatch(MyContentProvider.AUTHORITY, ops);  // バッチ処理を実行
}

public void batchDelete(Context context, List<Integer> ids) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

    for (Integer id : ids) {
        // ContentProviderOperation#newUpdate(Uri) によって、削除に関する操作手順を生成するビルダーを取得する
        ContentProviderOperation deleteOp = ContentProviderOperation.newDelete(MyContentProvider.CONTENT_URI)
                .withSelection("_id = ?", new String[] { id.toString() })
                .build();
        ops.add(deleteOp);
    }

    ContentResolver resolver = context.getContentResolver();
    resolver.applyBatch(MyContentProvider.AUTHORITY, ops);
}

public class StubAuthenticator extends AbstractAccountAuthenticator {
    public StubAuthenticator(Context context) {
        super(context);
    }

    @Override
    public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) throws NetworkErrorException {
        return null; // アカウント管理をしないため、null を返す
    }

    @Override
    public abstract Bundle confirmCredentials (AccountAuthenticatorResponse response, Account account, Bundle options) throws NetworkErrorException {
        return null; // アカウント生成の了承リクエストは無視するため、null を返す
    }

    @Override
    public abstract Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
        throw new UnsupportedOperationException("edit properties not supported"); // アカウント情報の編集は、アカウント管理をしないポリシーとなるので例外とする
    }

    @Override
    public abstract Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle options) throws NetowrkErrorException {
        throw new UnsupportedOperationException("get auth token not supported"); // トークン管理も、アカウント管理をしないため例外
    }

    @Override
    public abstract String getAuthTokenLabel(String authTokenType) {
        throw new UnsupportedOperationException("get auth token label not supported"); // トークン管理をしないので、トークンの種類に対応する表示も例外
    }

    @Override
    public abstract Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) throws NetworkErrorException {
        throw new UnsupportedOperationException("feature check not supported"); // アカウント管理をしないため例外
    }

    @Override
    public Bundle updateCredentials(AccountAuthenticatorResponse r, Account account, String s, Bundle bundle) throws NetworkErrorException {
        throw new UnsupportedOperationException(); // アカウント管理をしないため例外
    }
}

public class StubAuthenticatorService extends Service {
    // スタブの Authenticator を保持しておく
    private StubAuthenticator mAuthenticator;
    @Override
    public void onCreate() {
        mAuthenticator = new StubAuthenticator(this);
    }

    // システムは、Authenticator に対して RPC を実施する為にこの Service にバインドするので、RPC のための IBinder を Authenticator から取得する
    @Override
    public IBinder onBind(Intent intent) {
        return mAuthenticator.getIBinder();
    }
}

public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstancestate);
        setContentView(R.layout.activity_main);

        // ...
        Account account = createAccount();

    }

    private Account createAccount() {
        AccountManager manager = (AccountManager) getSystemService(Context.ACCOUNT_SERVICE);
        // スタブのアカウント情報を持つ Account オブジェクトを作る
        Account stubAccount = new Account("stubAccount", "jp.co.mixi.sample.sync.stub.account");

        // AccountManager にスタブのアカウント情報を登録
        if (manager.addAccountExplicitly(stubAccount, null, null)) {
            // 登録成功
        } else {
            // 既に登録されているか、アカウントが null、その他エラーの場合
        }
        return stubAccount;
    }
}

public MySyncAdapter extends AbstractThreadedSyncAdapter {
    public MySyncAdapter(Context context, boolean autoInitialize) {
        super(context, autoInitialize);
    }

    /**
     * 定期実行処理が走った時に呼ばれるコールバック
     *
     * @param account 定期実行のリクエストが紐付けられているアカウント
     * @param extras 定期実行をシステムに登録した時に渡すパラメータを含むマップオブジェクト
     * @param authority ContentProvider の AUTHORITY
     * @param provider ContentProvider へのアクセサ
     * @param syncResult 同期処理の結果を保持するオブジェクト。成功・例外などの情報を持つ
     */
    @Override
    public void onPerformSync(Account account, Bundle extras, String authority, ContentProviderClient provider, SyncResult syncResult) {
        // ここに同期のための処理を記述する
    }
}

public MySyncService extends Service {
    private static AbstractThreadedSyncAdapter sAdapter;
    private static final Object LOCK = new Object();
    @Override
    public void onCreate() {
        synchronized (LOCK) {
            if (sAdapter == null) {
                sAdapter = new MySyncAdapter(getApplicationContext(), true);
            }
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return sAdapter.getSyncAdapterBinder();
    }
}

/**
 * @param account 紐付けるアカウント
 * @param frequencySec 同期処理を実行する間隔(秒)
 */
public void applySyncPeriod(Account account, long frequencySec) {
    Bundle args = new Bundle(); // 同期処理の制御に関するパラメータを保持するマップオブジェクト
                                //何らか同期処理のために渡したいパラメータがある場合はこの Bundle に詰め込む
    ContentResolver.addPeriodicSync(account, StubContentProvider.AUTHORITY, args, frequencySec);
}

/**
 * @param account 紐付けるアカウント
 */
public void applySyncPeriod(Account account) {
    // 最後の boolean を true にすれば同期が有効となり、false にすれば同期が無効化される
    ContentResolver.setSyncAutomatically(account, StubContentProvider.AUTHORITY, true);   
}

public void dispatchSync(Account account) {
    Bundle args = new Bundle();
    args.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true); // 手動で同期するフラグをシステムに伝える
    args.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true); // キューの先頭に積み、すぐに同期を実行するようシステムに伝える
    ContentResolver.requestSync(account, StubContentProvider.AUTHORITY, args);
}

/**
 * @param account 紐付けるアカウント
 * @param frequencySec 同期処理を実行する間隔(秒)
 */
public void applySyncPeriod(Context context, Account account, long frequencySec) {
    Bundle args = new Bundle(); // 同期処理の制御に関するパラメータを保持するマップオブジェクト
                                //何らか同期処理のために渡したいパラメータがある場合はこの Bundle に詰め込む
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO) {
        // AlarmManager ではミリ秒で管理されるのでミリ秒へ変換
        long frequencyMillis = frequencySec * 1000;

        // AlarmManager によって、定期的にブロードキャストされる Intent を準備する
        Intent intent = new Intent(SyncTriggerReceiver.ACTION_TRIGGER, Uri.parse("alarm:" + authority));
        intent.putExtra(SyncTriggerReceiver.EXTRA_SYNC_AUTHORITY, StubContentProvider.AUTHORITY);
        intent.putExtra(SyncTriggerReceiver.EXTRA_SYNC_ACCOUNT_NAME, account.name);
        intent.putExtra(SyncTriggerReceiver.EXTRA_SYNC_ACCOUNT_TYPE, account.type);
        intent.putExtra(SyncTriggerReceiver.EXTRA_SYNC_EXTRAS, extras);

        // AlarmManager によって Intent のハンドリングがなされるため、遅延させるために PendingIntent を作成        
        PendingIntent pendingOperation = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);

        // AlarmManager に登録
        AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        manager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + frequencyMillis, frequencyMillis, operation);
    } else {
        ContentResolver.addPeriodicSync(account, StubContentProvider.AUTHORITY, args, frequencySec);
    }
}

public class SyncTriggerReceiver extends BroadcastReceiver {
    public static final String ACTION_TRIGGER = "ACTION_TRIGGER";
    public static final String EXTRA_SYNC_AUTHORITY = "authority";
    public static final String EXTRA_SYNC_ACCOUNT_NAME = "account_name";
    public static final String EXTRA_SYNC_ACCOUNT_TYPE = "account_type";
    public static final String EXTRA_SYNC_EXTRAS = "extras";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (ACTION_TRIGGER.equals(intent.getAction)) {
            String accountName = intent.getStringExtra(EXTRA_SYNC_ACCOUNT_NAME);
            String accountType = intent.getStringExtra(EXTRA_SYNC_ACCOUNT_TYPE);
            String authority = intent.getStringExtra(EXTRA_SYNC_AUTHORITY);
            Bundle extras = intent.getParcelableExtra(EXTRA_SYNC_EXTRAS);
            Account account = new Account(accountName, accountType);

            ContentResolver.requestSync(account, authority, extras);
        }
    }
}