Java 类android.content.OperationApplicationException 实例源码

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    ContentProviderResult[] result = null;
    isApplyingBatch = true;
    final SQLiteDatabase db = db();
    db.beginTransaction();
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
        isApplyingBatch = false;
    }
    return result;
}

private void flushApksToDbInBatch(Map<String, Long> appIds) throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String, List<Apk>> entries : apksToSave.entrySet()) {
        for (Apk apk : entries.getValue()) {
            apk.appId = appIds.get(apk.packageName);
        }
        apksToSaveList.addAll(entries.getValue());
    }

    calcApkCompatibilityFlags(apksToSaveList);

    ArrayList<ContentProviderOperation> apkOperations = insertApks(apksToSaveList);

    try {
        context.getContentResolver().applyBatch(TempApkProvider.getAuthority(), apkOperations);
    } catch (RemoteException | OperationApplicationException e) {
        throw new RepoUpdater.UpdateException(repo, "An internal error occurred while updating the database", e);
    }
}

private static @NonNull RefreshResult updateContactsDatabase(@NonNull Context context,
                                                             @NonNull String localNumber,
                                                             @NonNull List<ContactTokenDetails> activeTokens,
                                                             boolean removeMissing)
{
  Optional<AccountHolder> account = getOrCreateAccount(context);

  if (account.isPresent()) {
    try {
      List<String> newUsers = DatabaseFactory.getContactsDatabase(context)
                                             .setRegisteredUsers(account.get().getAccount(), localNumber, activeTokens, removeMissing);

      return new RefreshResult(newUsers, account.get().isFresh());
    } catch (RemoteException | OperationApplicationException e) {
      Log.w(TAG, e);
    }
  }

  return new RefreshResult(new LinkedList<String>(), false);
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    ContentProviderResult[] results;

    SQLiteDatabase db = mOpenHelper.getWritableDatabase();

    db.beginTransaction();
    try {
        inBatch.set(true);
        results = super.applyBatch(operations);
        inBatch.set(false);

        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }

    notifyChange();

    return results;
}

/**
 * Since old repository URL could be used, do not actually update the existing record,
 * but create a new one.
 */
public static int updateUrl(Context mContext, long id, String url) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    ops.add(ContentProviderOperation
                    .newDelete(ContentUris.withAppendedId(ProviderContract.Repos.ContentUri.repos(), id))
                    .build());

    ops.add(ContentProviderOperation
                    .newInsert(ProviderContract.Repos.ContentUri.repos())
                    .withValue(ProviderContract.Repos.Param.REPO_URL, url)
                    .build());

    try {
        mContext.getContentResolver().applyBatch(ProviderContract.AUTHORITY, ops);
    } catch (RemoteException | OperationApplicationException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }

    return 1;
}

public static void set(Context context, List<VersionedRook> books) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    /* Delete all previous. */
    ops.add(ContentProviderOperation
            .newDelete(ProviderContract.CurrentRooks.ContentUri.currentRooks())
            .build());

    /* Insert each one. */
    for (VersionedRook book: books) {
        ContentValues values = new ContentValues();
        CurrentRooksClient.toContentValues(values, book);

        ops.add(ContentProviderOperation
                .newInsert(ProviderContract.CurrentRooks.ContentUri.currentRooks())
                .withValues(values)
                .build());
    }

    try {
        context.getContentResolver().applyBatch(ProviderContract.AUTHORITY, ops);
    } catch (RemoteException | OperationApplicationException e) {
        e.printStackTrace();
    }
}

public static int delete(Context context, long[] noteIds) {
    int deleted = 0;

    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    for (long noteId: noteIds) {
        ops.add(ContentProviderOperation
                .newDelete(ProviderContract.Notes.ContentUri.notes())
                .withSelection(ProviderContract.Notes.UpdateParam._ID + "=" + noteId, null)
                .build()
        );
    }

    try {
        context.getContentResolver().applyBatch(ProviderContract.AUTHORITY, ops);
    } catch (RemoteException | OperationApplicationException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }

    if (BuildConfig.LOG_DEBUG) LogUtils.d(TAG, "Deleted " + deleted + " notes");

    return deleted;
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    try {
        Field uriField = ContentProviderOperation.class.getDeclaredField("mUri");
        uriField.setAccessible(true);
        for (ContentProviderOperation operation : operations) {
            Uri pluginUri = Uri.parse(operation.getUri().getQueryParameter(KEY_URI));
            uriField.set(operation, pluginUri);
        }
    } catch (Exception e) {
        return new ContentProviderResult[0];
    }

    if (operations.size() > 0) {
        ContentProvider provider = getContentProvider(operations.get(0).getUri());
        if (provider != null) {
            return provider.applyBatch(operations);
        }
    }

    return new ContentProviderResult[0];
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(
        @NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final Context context = getContext();
    if (context == null) {
        return new ContentProviderResult[0];
    }
    final SampleDatabase database = SampleDatabase.getInstance(context);
    database.beginTransaction();
    try {
        final ContentProviderResult[] result = super.applyBatch(operations);
        database.setTransactionSuccessful();
        return result;
    } finally {
        database.endTransaction();
    }
}

@Test
public void cheese_applyBatch() throws RemoteException, OperationApplicationException {
    final ArrayList<ContentProviderOperation> operations = new ArrayList<>();
    operations.add(ContentProviderOperation
            .newInsert(SampleContentProvider.URI_CHEESE)
            .withValue(Cheese.COLUMN_NAME, "Peynir")
            .build());
    operations.add(ContentProviderOperation
            .newInsert(SampleContentProvider.URI_CHEESE)
            .withValue(Cheese.COLUMN_NAME, "Queso")
            .build());
    final ContentProviderResult[] results = mContentResolver.applyBatch(
            SampleContentProvider.AUTHORITY, operations);
    assertThat(results.length, is(2));
    final Cursor cursor = mContentResolver.query(SampleContentProvider.URI_CHEESE,
            new String[]{Cheese.COLUMN_NAME}, null, null, null);
    assertThat(cursor, notNullValue());
    assertThat(cursor.getCount(), is(2));
    assertThat(cursor.moveToFirst(), is(true));
    cursor.close();
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

private static @NonNull RefreshResult updateContactsDatabase(@NonNull Context context,
                                                             @NonNull String localNumber,
                                                             @NonNull List<ContactTokenDetails> activeTokens,
                                                             boolean removeMissing)
{
  Optional<AccountHolder> account = getOrCreateAccount(context);

  if (account.isPresent()) {
    try {
      List<String> newUsers = DatabaseFactory.getContactsDatabase(context)
                                             .setRegisteredUsers(account.get().getAccount(), localNumber, activeTokens, removeMissing);

      return new RefreshResult(newUsers, account.get().isFresh());
    } catch (RemoteException | OperationApplicationException e) {
      Log.w(TAG, e);
    }
  }

  return new RefreshResult(new LinkedList<String>(), false);
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    if (DBG) Log.d(TAG, "applyBatch");
    ContentProviderResult[] result = null;
    SQLiteDatabase db = mDbHolder.get();
    db.beginTransaction();
    try {
         result = super.applyBatch(operations);
         db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
    if (result != null) {
        mCr.notifyChange(MusicStore.ALL_CONTENT_URI, null);
    }
    return result;
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    SQLiteDatabase db = mDbHolder.get();
    db.beginTransaction();
    ContentProviderResult[] result = null;
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
        ContentResolver res = mCr;
        res.notifyChange(ScraperStore.ALL_CONTENT_URI, null);
        return result;
    } finally {
        db.endTransaction();
    }
}

@Override
public void transactionSuccess() {
    try {
        ContentProviderResult[] cpr = context.getContentResolver().applyBatch(
                dsUri.getAuthority(), trans);
        if(cpr == null || cpr.length != trans.size()){
            throw new DaoException();
        }
        for (int i = 0; i < cpr.length; i++) {
            if (cpr[i] == null || ( cpr[i].count == null && cpr[i].uri == null)) {
                throw new DaoException();
            }
        }
    } catch (RemoteException | OperationApplicationException e) {
        throw new DaoException();
    } finally {
        trans = null;
    }
}

@Override
public ContentProviderResult[] applyBatch( ArrayList<ContentProviderOperation> operations )
        throws OperationApplicationException {

    ContentProviderResult[] contentProviderResults;
    try {
        getWritableDatabase().beginTransaction();
        contentProviderResults = new ContentProviderResult[operations
                .size()];

        int i = 0;
        for (ContentProviderOperation cpo : operations) {
            contentProviderResults[i] = cpo.apply(this, contentProviderResults, i);
            if(contentProviderResults[i] == null || (contentProviderResults[i].count == null && contentProviderResults[i].uri == null)){
                throw new DaoException();
            }
            i++;
        }
        getWritableDatabase().setTransactionSuccessful();
    } finally{
        if (getWritableDatabase().inTransaction()) {
            getWritableDatabase().endTransaction();
        }            
    }
    return contentProviderResults;
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
protected Void doInBackground(Void... params) {
    @DvrStorageStatusManager.StorageStatus int storageStatus = getDvrStorageStatus();
    if (storageStatus == DvrStorageStatusManager.STORAGE_STATUS_MISSING) {
        return null;
    }
    List<ContentProviderOperation> ops = getDeleteOps(storageStatus
            == DvrStorageStatusManager.STORAGE_STATUS_TOTAL_CAPACITY_TOO_SMALL);
    if (ops == null || ops.isEmpty()) {
        return null;
    }
    Log.i(TAG, "New device storage mounted. # of recordings to be forgotten : "
            + ops.size());
    for (int i = 0 ; i < ops.size() && !isCancelled() ; i += BATCH_OPERATION_COUNT) {
        int toIndex = (i + BATCH_OPERATION_COUNT) > ops.size()
                ? ops.size() : (i + BATCH_OPERATION_COUNT);
        ArrayList<ContentProviderOperation> batchOps =
                new ArrayList<>(ops.subList(i, toIndex));
        try {
            mContext.getContentResolver().applyBatch(TvContract.AUTHORITY, batchOps);
        } catch (RemoteException | OperationApplicationException e) {
            Log.e(TAG, "Failed to clean up  RecordedPrograms.", e);
        }
    }
    return null;
}

public void scannedChannelHandlingCompleted() {
    mIsScanning.set(false);
    if (!mPreviousScannedChannels.isEmpty()) {
        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        for (TunerChannel channel : mPreviousScannedChannels) {
            ops.add(ContentProviderOperation.newDelete(
                    TvContract.buildChannelUri(channel.getChannelId())).build());
        }
        try {
            mContext.getContentResolver().applyBatch(TvContract.AUTHORITY, ops);
        } catch (RemoteException | OperationApplicationException e) {
            Log.e(TAG, "Error deleting obsolete channels", e);
        }
    }
    if (mChannelScanListener != null && mChannelScanHandler != null) {
        mChannelScanHandler.post(new Runnable() {
            @Override
            public void run() {
                mChannelScanListener.onChannelHandlingDone();
            }
        });
    } else {
        Log.e(TAG, "Error. mChannelScanListener is null.");
    }
}

@Override
public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    Log_OC.d("FileContentProvider", "applying batch in provider " + this +
            " (temporary: " + isTemporary() + ")" );
    ContentProviderResult[] results = new ContentProviderResult[operations.size()];
    int i=0;

    SQLiteDatabase db = mDbHelper.getWritableDatabase();
    db.beginTransaction();  // it's supposed that transactions can be nested
    try {
        for (ContentProviderOperation operation : operations) {
            results[i] = operation.apply(this, results, i);
            i++;
        }
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
    Log_OC.d("FileContentProvider", "applied batch in provider " + this);
    return results;
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

public static Uri add(ContactSpec spec) {

        // original code http://stackoverflow.com/questions/4744187/how-to-add-new-contacts-in-android
        // good blog http://androiddevelopement.blogspot.de/2011/07/insert-update-delete-view-contacts-in.html

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();

        addContactBase(ops);
        addContactDisplayName(spec, ops);
        addContactAddress(spec, ops);

        try {
            ContentProviderResult[] results = InstrumentationRegistry.getTargetContext().getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
            return results[0].uri;
        } catch (RemoteException | OperationApplicationException e) {
            throw new IllegalStateException("Could not add contact", e);
        }
    }

@Override
public @NonNull ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    final SQLiteDatabase db = helper.getWritableDatabase();

    db.beginTransaction();

    try {
        final ContentProviderResult[] results =
                super.applyBatch(operations);
        db.setTransactionSuccessful();

        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
public ContentProviderResult[] applyBatch(
        ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    /*SQLiteDatabase db = sqlOpenHelper.getWritableDatabase();
    isInBatchMode.set(true);
    db.beginTransaction();
    try {
        final ContentProviderResult[] retResult = super.applyBatch(operations);
        db.setTransactionSuccessful();
        getContext().getContentResolver().notifyChange(ApparelContract.CONTENT_URI, null);
        return retResult;
    }
    finally {
        isInBatchMode.remove();
        db.endTransaction();
    }*/
    return null;
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mDbHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

private void deleteMultiContract(List<Contact> contacts) {
    showProgressDialog();
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();
    for (int i = 0; i < contacts.size(); i++) {
        Log.d(TAG, "deleteMultiContract contacts.dataId == " + contacts.get(i).dataId + ", name == " + contacts.get(i).displayName);
        ops.add(ContentProviderOperation.newDelete(ContactsContract.Data.CONTENT_URI)
                .withSelection(ContactsContract.Data._ID + "=?",
                        new String[]{contacts.get(i).dataId})
                .build());
    }
    try {
        getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
    } catch (RemoteException | OperationApplicationException e) {
        e.printStackTrace();
    }
    UpdateContactService.updateContacts(MainActivity.this, (ArrayList<Contact>) contacts);
    mHandler.postDelayed(new Runnable() {
        @Override
        public void run() {
            mContactTask = new HandleContactTask();
            mContactTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }
    }, 100);
}

/**
 * Apply the given set of {@link ContentProviderOperation}, executing inside
 * a {@link SQLiteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@NonNull
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this, results, i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

void fixContactPhonetic(Set<ContactLite> contactIds) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();
    for (ContactLite contact : contactIds) {
        ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                .withSelection(
                        String.format("%s = ?", ContactsContract.Data._ID),
                        new String[]{String.valueOf(contact.dataId)})
                .withValue(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_GIVEN_NAME, contact.phoneticGivenName)
                .withValue(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_MIDDLE_NAME, contact.phoneticMiddleName)
                .withValue(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_FAMILY_NAME, contact.phoneticFamilyName)
                .withValue(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_NAME_STYLE, contact.phoneticNameStyle)
                .build());
    }
    try {
        context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
    } catch (RemoteException | OperationApplicationException e) {
        Log.e(TAG, "Error when updating", e);
    }
    Log.i(TAG, "Fix done:" + contactIds.size());
}

private void updateCache() {

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        ops.addAll(deleteFromCache(toDelete));
        ops.addAll(insertIntoCache(toInsert));

        if (ops.size() > 0) {
            try {
                context.getContentResolver().applyBatch(InstalledAppProvider.getAuthority(), ops);
                Utils.debugLog(TAG, "Finished executing " + ops.size() + " CRUD operations on installed app cache.");
            } catch (RemoteException | OperationApplicationException e) {
                Log.e(TAG, "Error updating installed app cache: " + e);
            }
        }

    }

@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
    throws OperationApplicationException {
    ContentProviderResult[] result = null;
    isApplyingBatch = true;
    final SQLiteDatabase db = db();
    db.beginTransaction();
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
        isApplyingBatch = false;
    }
    return result;
}

private void flushApksToDbInBatch() throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String, List<Apk>> entries : apksToSave.entrySet()) {
        apksToSaveList.addAll(entries.getValue());
    }

    calcApkCompatibilityFlags(apksToSaveList);

    ArrayList<ContentProviderOperation> apkOperations = new ArrayList<>();
    ContentProviderOperation clearOrphans = deleteOrphanedApks(appsToSave, apksToSave);
    if (clearOrphans != null) {
        apkOperations.add(clearOrphans);
    }
    apkOperations.addAll(insertOrUpdateApks(apksToSaveList));

    try {
        context.getContentResolver().applyBatch(TempApkProvider.getAuthority(), apkOperations);
    } catch (RemoteException | OperationApplicationException e) {
        throw new RepoUpdater.UpdateException(repo, "An internal error occurred while updating the database", e);
    }
}

private void updateCache() {

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        ops.addAll(deleteFromCache(toDelete));
        ops.addAll(insertIntoCache(toInsert));

        if (ops.size() > 0) {
            try {
                context.getContentResolver().applyBatch(InstalledAppProvider.getAuthority(), ops);
                Utils.debugLog(TAG, "Finished executing " + ops.size() + " CRUD operations on installed app cache.");
            } catch (RemoteException | OperationApplicationException e) {
                Log.e(TAG, "Error updating installed app cache: " + e);
            }
        }

    }

private void flushApksToDbInBatch() throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String, List<Apk>> entries : apksToSave.entrySet()) {
        apksToSaveList.addAll(entries.getValue());
    }

    calcApkCompatibilityFlags(apksToSaveList);

    ArrayList<ContentProviderOperation> apkOperations = new ArrayList<>();
    ContentProviderOperation clearOrphans = deleteOrphanedApks(appsToSave, apksToSave);
    if (clearOrphans != null) {
        apkOperations.add(clearOrphans);
    }
    apkOperations.addAll(insertOrUpdateApks(apksToSaveList));

    try {
        context.getContentResolver().applyBatch(TempApkProvider.getAuthority(), apkOperations);
    } catch (RemoteException | OperationApplicationException e) {
        throw new RepoUpdater.UpdateException(repo, "An internal error occurred while updating the database", e);
    }
}

public synchronized static void updateEvent(Context context, Contact contact, DateUnknownYear newBirthday) throws EventException {
    // TODO UNIFORMISE
    for (CalendarEvent event : getEventsSavedOrCreateNewsForEachYear(context, contact)) {
        // Construct each anniversary of new birthday
        int year = new DateTime(event.getDate()).getYear();
        Date newBirthdayDate = DateUnknownYear.getDateWithYear(newBirthday.getDate(), year);
        event.setDateStart(newBirthdayDate);
        event.setAllDay(true);
        ArrayList<ContentProviderOperation> operations = new ArrayList<>();
        ContentProviderOperation contentProviderOperation = EventProvider.update(event);
        operations.add(contentProviderOperation);
        try {
            ContentProviderResult[] contentProviderResults =
                    context.getContentResolver().applyBatch(CalendarContract.AUTHORITY, operations);
            for(ContentProviderResult contentProviderResult : contentProviderResults) {
                if (contentProviderResult.count != 0)
                    Log.d(TAG, "Update event : " + event.toString());
            }
        } catch (RemoteException|OperationApplicationException e) {
            Log.e(TAG, "Unable to update event : " + e.getMessage());
        }
    }
}

public synchronized static void deleteEventsFromContact(Context context, Contact contact) {
    ArrayList<ContentProviderOperation> operations = new ArrayList<>();
    try {
        for (CalendarEvent event : getEventsSavedForEachYear(context, contact)) {
            operations.add(ReminderProvider.deleteAll(context, event.getId()));
            operations.add(EventProvider.delete(event));
        }
        ContentProviderResult[] contentProviderResults =
                context.getContentResolver().applyBatch(CalendarContract.AUTHORITY, operations);
        for(ContentProviderResult contentProviderResult : contentProviderResults) {
            Log.d(TAG, contentProviderResult.toString());
            if (contentProviderResult.uri != null)
                Log.d(TAG, contentProviderResult.uri.toString());
        }
    } catch (RemoteException |OperationApplicationException |EventException e) {
        Log.e(TAG, "Unable to deleteById events : " + e.getMessage());
    }
}