android.content.OperationApplicationException Java Examples

/**
 * Test that an update that doesn't change anything doesn't trigger a notification.
 */
@Test
public void testNoOpUpdate() throws RemoteException, OperationApplicationException
{
    RowSnapshot<TaskLists> taskList = new VirtualRowSnapshot<>(new LocalTaskListsTable(mAuthority));
    RowSnapshot<Tasks> task = new VirtualRowSnapshot<>(new TaskListScoped(taskList, new TasksTable(mAuthority)));
    OperationsQueue queue = new BasicOperationsQueue(mClient);

    queue.enqueue(
            new Seq<>(
                    new Put<>(taskList, new NameData("list1")),
                    new Put<>(task, new TitleData("task1"))));
    queue.flush();

    assertThat(new Seq<>(
                    new Put<>(task, new TitleData("task1"))),
            notifies(
                    TaskContract.getContentUri(mAuthority),
                    queue,
                    // there should no notification
                    emptyIterable()));
}
 

private void insertAllNewContacts() {

        // Set up a batch operation on Contacts ContentProvider
        ArrayList<ContentProviderOperation> batchOperation = new ArrayList<>();

        for (String name : mNames) {
            addRecordToBatchInsertOperation(name, batchOperation);
        }

        try {

            // Apply all batched operations
            getContentResolver().applyBatch(ContactsContract.AUTHORITY,
                    batchOperation);

        } catch (RemoteException | OperationApplicationException e) {
            Log.i(TAG, "RemoteException");
        }

    }
 

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

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

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

@SuppressWarnings("UnusedReturnValue")
List<Uri> execute() {
    List<Uri> resultUris = new ArrayList<>();
    if (mOperations.size() == 0) {
        return resultUris;
    }
    // Apply the mOperations to the content provider
    try {
        ContentProviderResult[] results = mResolver.applyBatch(ContactsContract.AUTHORITY, mOperations);
        if (results.length > 0) {
            for (ContentProviderResult result : results) {
                resultUris.add(result.uri);
            }
        }
    } catch (final OperationApplicationException | RemoteException e) {
        Log.e(TAG, "storing contact data failed", e);
    }
    mOperations.clear();
    return resultUris;
}
 

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

private void flushApksToDbInBatch(Map<String, Long> appIds) throws IndexUpdater.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 IndexUpdater.UpdateException("An internal error occurred while updating the database", e);
    }
}
 

@Override
public void execute(Context context, ContentProviderClient contentProviderClient, RowDataSnapshot<TaskContract.Instances> data, Uri taskUri) throws RemoteException, OperationApplicationException
{
    try
    {
        RowStateInfo rsi = new RowStateInfo(data);
        new NotificationPrefs(context).next()
                .edit()
                .putString(
                        taskUri.toString(),
                        new JSONObject()
                                .put("version", new TaskVersion(data).value())
                                .put("started", rsi.started())
                                .put("due", rsi.due())
                                .put("done", rsi.done())
                                .put("ongoing", rsi.pinned()).toString())
                .apply();
    }
    catch (JSONException e)
    {
        throw new RuntimeException("Unable to serialize to JSON", e);
    }
}
 

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

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

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

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

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

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

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

/**
 * {@inheritDoc}
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    ContentProviderResult[] result = null;

    SQLiteDatabase db = this.getDatabaseHelper().getWritableDatabase();

    db.beginTransaction();
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
    return result;
}
 

@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    if (operations.size() > 0) {
        ContentProvider provider = getContentProvider(operations.get(0).getUri());
        if (provider != null) {
            try {
                for (ContentProviderOperation operation : operations) {
                    Uri pluginUri = Uri.parse(operation.getUri().getQueryParameter(IntentConstant.EXTRA_TARGET_URI_KEY));
                    ReflectionUtils.on(operation).set("mUri", pluginUri);
                }
                return provider.applyBatch(operations);
            } catch (Exception e) {
                return new ContentProviderResult[0];
            }
        }
    }
    return new ContentProviderResult[0];
}
 

public static void saveInTransaction(Context context, List<? extends CPDefaultRecord> records) throws RemoteException, OperationApplicationException {

        List<ContentProviderOperation> operations = prepareTransaction(context, records);
        ContentProviderResult[] contentProviderResults = CPOrm.applyPreparedOperations(operations);

        Map<Class, Long> referenceIds = new HashMap<>();

        for (int i = 0; i < contentProviderResults.length; i++) {

            ContentProviderResult result = contentProviderResults[i];
            CPDefaultRecord source = records.get(i);

            referenceIds.remove(source.getClass());
            if(result.uri != null && source.getId() == null && ContentUris.parseId(result.uri) != -1){

                source.setId(ContentUris.parseId(result.uri));
                referenceIds.put(source.getClass(), source.getId());
            }

            try {
                applyReferenceResults(source.getClass(), source, referenceIds);
            } catch (IllegalAccessException e) {
                CPOrmLog.e("Failed to apply back reference id's for uri " + result.uri);
            }
        }
    }
 

@Override
public void execute(Context context, ContentProviderClient contentProviderClient, RowDataSnapshot<TaskContract.Instances> rowSnapshot, Uri taskUri) throws RemoteException, OperationApplicationException
{
    for (TaskAction action : mDelegates)
    {
        action.execute(context, contentProviderClient, rowSnapshot, taskUri);
    }
}
 

@Override
public void execute(Context context, ContentProviderClient contentProviderClient, RowDataSnapshot<TaskContract.Instances> rowSnapshot, Uri taskUri) throws RemoteException, OperationApplicationException
{
    AlarmManagerCompat.setExactAndAllowWhileIdle(
            (AlarmManager) context.getSystemService(Context.ALARM_SERVICE),
            AlarmManager.RTC_WAKEUP,
            System.currentTimeMillis() + mDelayMillis,
            PendingIntent.getBroadcast(
                    context,
                    (int) ContentUris.parseId(taskUri),
                    new Intent(context, ActionReceiver.class).setAction(mAction).setData(taskUri),
                    PendingIntent.FLAG_UPDATE_CURRENT));
}
 

@Override
public void execute(Context context, ContentProviderClient contentProviderClient, RowDataSnapshot<TaskContract.Instances> data, Uri taskUri) throws RemoteException, OperationApplicationException
{
    int id = (int) ContentUris.parseId(taskUri);
    NotificationCompat.Builder builder = new NotificationCompat.Builder(context, ActionService.CHANNEL_DUE_DATES);
    builder.setContentTitle(context.getString(R.string.task_completed));
    builder.setSmallIcon(R.drawable.ic_notification);
    builder.setStyle(new NotificationCompat.DecoratedCustomViewStyle());
    builder.setDefaults(new NoSignal().value());

    final RemoteViews undoView = new RemoteViews(context.getPackageName(), R.layout.undo_notification);
    undoView.setTextViewText(R.id.description_text, context.getString(R.string.task_completed));

    undoView.setOnClickPendingIntent(
            R.id.status_bar_latest_event_content,
            PendingIntent.getBroadcast(
                    context,
                    id,
                    new Intent(context, ActionReceiver.class).setData(taskUri).setAction(ActionService.ACTION_UNDO_COMPLETE),
                    PendingIntent.FLAG_CANCEL_CURRENT));
    builder.setContent(undoView);

    // When the notification is cleared, we perform the destructive action
    builder.setDeleteIntent(PendingIntent.getBroadcast(
            context,
            id,
            new Intent(context, ActionReceiver.class).setData(taskUri).setAction(ActionService.ACTION_FINISH_COMPLETE),
            PendingIntent.FLAG_CANCEL_CURRENT));
    builder.setShowWhen(false);
    if (Build.VERSION.SDK_INT >= 21)
    {
        // don't execute this on Android 4, otherwise no notification will show up
        builder.setGroup(GROUP_UNDO);
    }
    builder.setColor(new ResourceColor(context, R.color.primary).argb());

    NotificationManagerCompat.from(context).notify("tasks.undo", id, builder.build());
}
 

@Override
public ContentProviderResult[] applyBatch(
		ArrayList<ContentProviderOperation> operations)
		throws OperationApplicationException {
       initIfNecessary();
	return super.applyBatch(operations);
}
 

@Override
public ContentProviderResult[] applyBatch(final ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
	final SQLiteDatabase database = getDatabase();
	database.beginTransaction();
	try {
		final ContentProviderResult[] results = super.applyBatch(operations);
		database.setTransactionSuccessful();
		return results;
	} finally {
		database.endTransaction();
	}
}
 

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        ContentProviderResult[] result =  super.applyBatch(operations);
        db.setTransactionSuccessful();
        return result;
    } finally {
        db.endTransaction();
    }
}
 

@Override
public ContentProviderResult[] applyBatch(
		ArrayList<ContentProviderOperation> operations)
		throws OperationApplicationException {
       initIfNecessary();
	return super.applyBatch(operations);
}
 

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

    if (debugEnabled) {
        CPOrmLog.d("********* Apply Batch **********");
        CPOrmLog.d("Operations Count: " + operations.size());
    }

    isBatchOperation.set(true);
    changedUri.set(new LinkedHashSet<Uri>());

    boolean success = false;
    ContentProviderResult[] contentProviderResults = null;
    SQLiteDatabase db = database.getWritableDatabase();
    try {
        db.beginTransactionNonExclusive();
        contentProviderResults = super.applyBatch(operations);
        db.setTransactionSuccessful();
        success = true;
        return contentProviderResults;
    } finally {
        db.endTransaction();

        if(success && changedUri.get() != null) {
            for (Uri uri : changedUri.get()) {

                if (uri != null) {
                    TableDetails tableDetails = uriMatcherHelper.getTableDetails(uri);
                    notifyChanges(uri, tableDetails);
                }
            }
        }
        isBatchOperation.set(false);
        changedUri.remove();
    }
}
 

@Override
protected void onHandleWork(@NonNull Intent intent)
{
    try
    {
        Uri instanceUri = intent.getData();
        if (instanceUri == null || instanceUri.getAuthority() == null)
        {
            throw new RuntimeException(String.format("Invalid task instance Uri %s", instanceUri));
        }

        ContentProviderClient contentProviderClient = getContentResolver().acquireContentProviderClient(instanceUri);
        for (RowSnapshot<TaskContract.Instances> snapshot : new QueryRowSet<>(
                new InstancesView<>(instanceUri.getAuthority(), contentProviderClient),
                new org.dmfs.android.contentpal.projections.Composite<>(
                        Id.PROJECTION,
                        EffectiveDueDate.PROJECTION,
                        TaskStart.PROJECTION,
                        TaskPin.PROJECTION,
                        EffectiveTaskColor.PROJECTION,
                        TaskTitle.PROJECTION,
                        TaskVersion.PROJECTION,
                        TaskIsClosed.PROJECTION),
                new EqArg<>(TaskContract.Instances._ID, ContentUris.parseId(instanceUri))))
        {
            resolveAction(intent.getAction()).execute(this, contentProviderClient, snapshot.values(), instanceUri);
        }
    }
    catch (RuntimeException | RemoteException | OperationApplicationException e)
    {
        Log.e("ActionService", String.format("unable to execute action %s", intent.getAction()), e);
    }
}
 

/**
 * Accesses the Contacts content provider directly to insert a new contact.
 * <p>
 * The contact is called "__DUMMY ENTRY" and only contains a name.
 */
private void insertDummyContact() {
    // Two operations are needed to insert a new contact.
    ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(2);

    // First, set up a new raw contact.
    ContentProviderOperation.Builder op =
            ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
                    .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null)
                    .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null);
    operations.add(op.build());

    // Next, set the name for the contact.
    op = ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
            .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
            .withValue(ContactsContract.Data.MIMETYPE,
                    ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
            .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME,
                    DUMMY_CONTACT_NAME);
    operations.add(op.build());

    // Apply the operations.
    ContentResolver resolver = getActivity().getContentResolver();
    try {
        resolver.applyBatch(ContactsContract.AUTHORITY, operations);
    } catch (RemoteException | OperationApplicationException e) {
        Snackbar.make(mMessageText.getRootView(), "Could not add a new contact: " +
                e.getMessage(), Snackbar.LENGTH_LONG);
    }
}
 

private void applyOperationsInBatches(@NonNull ContentResolver contentResolver,
                                      @NonNull String authority,
                                      @NonNull List<ContentProviderOperation> operations,
                                      int batchSize)
    throws OperationApplicationException, RemoteException
{
  List<List<ContentProviderOperation>> batches = Util.chunk(operations, batchSize);
  for (List<ContentProviderOperation> batch : batches) {
    contentResolver.applyBatch(authority, new ArrayList<>(batch));
  }
}