GitHub Pagesへ移行しましたmixi-inc.github.ioへお願いします。

目次

ContentProvider へのアクセス

バッチ処理

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);
}

Intent によるアクセス

データの同期

ContentProvider を用いた同期の仕組み

同期の仕組みを使用する準備

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();
 }
}

<!-- res/xml/authenticator.xml -->
<?xml version="1.0" encoding="utf-8"?>
<account-authenticator
 xmlns:android="http://schemas.android.com/apk/res/android"
 android:accountType="jp.co.mixi.sample.sync.stub.account"
 android:icon="@drawable/ic_launcher"
 android:smallIcon="@drawable/ic_launcher"
 android:label="@string/app_name"/>

<service
 android:name="jp.mixi.sample.sync.stub.authenticator.StubAuthenticatorService">
 <intent-filter>
 <action android:name="android.accounts.AccountAuthenticator"/>
 </intent-filter>
 <meta-data
 android:name="android.accounts.AccountAuthenticator"
 android:resource="@xml/authenticator" />
</service>
<provider
 android:name="jp.mixi.sample.sync.StubSyncProvider"
 android:authorities="jp.mixi.sample.sync.StubSyncProvider"
 android:export="false"
 android:syncable="true"/>

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;
 }
}

AbstractThreadedSyncAdapter

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) {
 // ここに同期のための処理を記述する
 }
}

Service

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();
 }
}

メタデータの宣言

<!-- res/xml/syncadapter.xml -->
<?xml version="1.0" encoding="utf-8"?>
<sync-adapter
 xmlns:android="http://schemas.android.com/apk/res/android"
 android:contentAuthority="jp.mixi.sample.sync.StubSyncProvider"
 android:accountType="jp.co.mixi.sample.sync.stub.account"
 android:userVisible="false"
 android:supportsUploading="false"
 android:allowParallelSyncs="false"
 android:isAlwaysSyncable="true"/>

AndroidManifest の宣言

<uses-permission
 android:name="android.permission.INTERNET"/>
<uses-permission
 android:name="android.permission.READ_SYNC_SETTINGS"/>
<uses-permission
 android:name="android.permission.WRITE_SYNC_SETTINGS"/>
<uses-permission
 android:name="android.permission.AUTHENTICATE_ACCOUNTS"/>

<service
 android:name="com.example.android.datasync.SyncService"
 android:exported="true"
 android:process=":sync">
 <intent-filter>
 <action android:name="android.content.SyncAdapter"/>
 </intent-filter>
 <meta-data
 android:name="android.content.SyncAdapter"
 android:resource="@xml/syncadapter" />
</service>

同期の実行と下位互換

指定した間隔で同期する

/**
 * @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);
 }
 }
}