Java Code Examples for io.reactivex.Completable#error()

private Completable validate(Entrypoint entrypoint, Entrypoint oldEntrypoint) {

        if (oldEntrypoint != null && oldEntrypoint.isDefaultEntrypoint()) {
            // Only the url of the default entrypoint can be updated.
            if (!entrypoint.getName().equals(oldEntrypoint.getName())
                    || !entrypoint.getDescription().equals(oldEntrypoint.getDescription())
                    || !entrypoint.getTags().equals(oldEntrypoint.getTags())) {
                return Completable.error(new InvalidEntrypointException("Only the url of the default entrypoint can be updated."));
            }
        }

        try {
            // Try to instantiate uri to check if it's a valid endpoint url.
            URL url = new URL(entrypoint.getUrl());
            if (!url.getProtocol().equals("http") && !url.getProtocol().equals("https")) {
                throw new MalformedURLException();
            }

            return Completable.complete();
        } catch (MalformedURLException e) {
            return Completable.error(new InvalidEntrypointException("Entrypoint must have a valid url."));
        }
    }
 

public Completable execute() {
    Map<String, Contact> contacts = chatsStorage.getContacts();

    Transaction<TransactionStateAsset> contactListTransaction = null;
    try {
        contactListTransaction = kvsHelper.transformToTransaction(
                Constants.KVS_CONTACT_LIST,
                true,
                contacts
        );
    } catch (EncryptionException e) {
        return Completable.error(e);
    }

    return apiKvsProvider.put(contactListTransaction);
}
 

public Completable updateBalance(){
    try {
        return Flowable.defer(() -> api.authorize(keyPair.getPublicKeyString().toLowerCase()))
                .doOnNext((authorization -> {
                    if (authorization.getAccount() == null){return;}

                    if (this.account == null){
                        this.account = authorization.getAccount();
                        return;
                    }

                    this.account.setBalance(authorization.getAccount().getBalance());
                    this.account.setUnconfirmedBalance(authorization.getAccount().getUnconfirmedBalance());

                }))
                .compose(requestControl())
                .ignoreElements();
    } catch (Exception ex){
        return Completable.error(ex);
    }
}
 

@Override
@RequiresApi(21 /* Build.VERSION_CODES.LOLLIPOP */)
public Completable requestConnectionPriority(int connectionPriority, long delay, @NonNull TimeUnit timeUnit) {
    if (connectionPriority != BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER
            && connectionPriority != BluetoothGatt.CONNECTION_PRIORITY_BALANCED
            && connectionPriority != BluetoothGatt.CONNECTION_PRIORITY_HIGH) {
        return Completable.error(
                new IllegalArgumentException(
                        "Connection priority must have valid value from BluetoothGatt (received "
                                + connectionPriority + ")"
                )
        );
    }

    if (delay <= 0) {
        return Completable.error(new IllegalArgumentException("Delay must be bigger than 0"));
    }

    return operationQueue
            .queue(operationsProvider.provideConnectionPriorityChangeOperation(connectionPriority, delay, timeUnit))
            .ignoreElements();
}
 

private Completable updateLocalFeature(RemoteDataEvent<Feature> event) {
  switch (event.getEventType()) {
    case ENTITY_LOADED:
    case ENTITY_MODIFIED:
      return event.value().map(localDataStore::mergeFeature).orElse(Completable.complete());
    case ENTITY_REMOVED:
      // TODO: Delete features:
      // localDataStore.removeFeature(event.getEntityId());
      return Completable.complete();
    case ERROR:
      event.error().ifPresent(e -> Timber.d(e, "Invalid features in remote db ignored"));
      return Completable.complete();
    default:
      return Completable.error(
          new UnsupportedOperationException("Event type: " + event.getEventType()));
  }
}
 

/** Save a copy of bitmap locally. */
public Completable savePhoto(Bitmap bitmap, String filename) {
  try {
    File file = fileUtil.saveBitmap(bitmap, filename);
    Timber.d("Photo saved %s : %b", filename, file.exists());
    return Completable.complete();
  } catch (IOException e) {
    return Completable.error(e);
  }
}
 

public static Completable validate(User user) {

        if (!isValid(user.getUsername(), USERNAME_PATTERN_COMPILED)) {
            return Completable.error(new InvalidUserException(String.format("Username [%s] is not a valid value", user.getUsername())));
        }

        if (!EmailValidator.isValid(user.getEmail())) {
            return Completable.error(new EmailFormatInvalidException(user.getEmail()));
        }

        if (!isValid(user.getFirstName(), NAME_STRICT_PATTERN_COMPILED)) {
            return Completable.error(new InvalidUserException(String.format("First name [%s] is not a valid value", user.getFirstName())));
        }

        if (!isValid(user.getLastName(), NAME_STRICT_PATTERN_COMPILED)) {
            return Completable.error(new InvalidUserException(String.format("Last name [%s] is not a valid value", user.getLastName())));
        }

        if (!isValid(user.getDisplayName(), NAME_LAX_PATTERN_COMPILED)) {
            return Completable.error(new InvalidUserException(String.format("Display name [%s] is not a valid value", user.getDisplayName())));
        }

        if (!isValid(user.getNickName(), NAME_LAX_PATTERN_COMPILED)) {
            return Completable.error(new InvalidUserException(String.format("Nick name [%s] is not a valid value", user.getNickName())));
        }

        if (user.getExternalId() != null && user.getExternalId().length() > DEFAULT_MAX_LENGTH) {
            return Completable.error(new InvalidUserException(String.format("External id [%s] is not a valid value", user.getExternalId())));
        }

        return Completable.complete();
    }
 

@NonNull
static Completable writeClientCharacteristicConfig(
        final BluetoothGattCharacteristic bluetoothGattCharacteristic,
        final DescriptorWriter descriptorWriter,
        final byte[] value
) {
    final BluetoothGattDescriptor descriptor = bluetoothGattCharacteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG_UUID);
    if (descriptor == null) {
        return Completable.error(new BleCannotSetCharacteristicNotificationException(
                bluetoothGattCharacteristic,
                BleCannotSetCharacteristicNotificationException.CANNOT_FIND_CLIENT_CHARACTERISTIC_CONFIG_DESCRIPTOR,
                null
        ));
    }

    return descriptorWriter.writeDescriptor(descriptor, value)
            .onErrorResumeNext(new Function<Throwable, CompletableSource>() {
                @Override
                public CompletableSource apply(Throwable throwable) {
                    return Completable.error(new BleCannotSetCharacteristicNotificationException(
                            bluetoothGattCharacteristic,
                            BleCannotSetCharacteristicNotificationException.CANNOT_WRITE_CLIENT_CHARACTERISTIC_CONFIG_DESCRIPTOR,
                            throwable
                    ));
                }
            });
}
 

/**
 * Set a new MetadataDownload configuration.
 * @param metadataIdsConfig Configuration with the metadata ids.
 * @return {@code Completable} that completes when the configuration is changed.
 */
public Completable setMetadataDownloadConfig(WebApiRepository.GetMetadataIdsConfig metadataIdsConfig) {
    if (metadataIdsConfig == null) {
        return Completable.error(new IllegalArgumentException("Received null config"));
    }
    return localDbRepository.setMetadataDownloadConfig(metadataIdsConfig);
}
 

/**
 * Set the gateway number to send the SMS. This is a required parameter before sending SMS.
 * @param gatewayNumber The gateway numberf
 * @return {@code Completable} that completes when the configuration is changed.
 */
public Completable setGatewayNumber(String gatewayNumber) {
    if (gatewayNumber == null || gatewayNumber.isEmpty()) {
        return Completable.error(new IllegalArgumentException("Gateway number can't be empty"));
    }
    return localDbRepository.setGatewayNumber(gatewayNumber);
}
 

@Override
public Completable intercept(ContainerRequestContext requestContext) {
    if (requestContext.getHeaders().containsKey("error")) {
        return Completable.error(new BadRequestException("Surprise!"));
    }
    return Completable.complete();
}
 

protected Completable rxAssertEquals(Object expected, Object actual) {
  Completable completable;
  try {
    Assert.assertEquals(expected, actual);
    completable = Completable.complete();
  } catch (AssertionError error) {
    completable = Completable.error(error);
  }
  return completable;
}
 

@Transaction
@Override
public Completable applyAndEnqueue(ObservationMutation mutation) {
  try {
    return apply(mutation).andThen(enqueue(mutation));
  } catch (LocalDataStoreException e) {
    return Completable.error(e);
  }
}
 

Completable removeOngoingSubmission(Integer id) {
    if (id == null) {
        return Completable.error(new IllegalArgumentException("Wrong submission id"));
    }
    return getOngoingSubmissions().flatMapCompletable(submissions -> {
        submissions.remove(id);
        return saveOngoingSubmissions(ongoingSubmissions);
    });
}
 

@Override
public Completable unsubscribe() {
    String unsubscribeTransactionJson = settings.getUnsubscribeFcmTransaction();
    if (unsubscribeTransactionJson == null || unsubscribeTransactionJson.isEmpty()) {
        //TODO: Обязательно проверь в тестах кейс с выходом
        return Completable.complete();
    }

    try {

        Transaction<TransactionChatAsset> transaction = gson.fromJson(
                unsubscribeTransactionJson,
                new TypeToken<Transaction<TransactionChatAsset>>() {}.getType()
        );

        AdamantPushSubscriptionMessageFactory subscribeFactory = (AdamantPushSubscriptionMessageFactory)messageFactoryProvider
                .getFactoryByType(SupportedMessageListContentType.ADAMANT_SUBSCRIBE_ON_NOTIFICATION);
        MessageProcessor<AdamantPushSubscriptionMessage> messageProcessor = subscribeFactory.getMessageProcessor();

        return messageProcessor
                .sendTransaction(Single.just(transaction))
                .ignoreElement()
                .doOnComplete(() -> {
                    settings.setNotificationToken("");
                    settings.setUnsubscribeFcmTransaction("");
                });
    } catch (Exception ex) {
        return Completable.error(ex);
    }

}
 

public Completable changeNotificationFacade(SupportedPushNotificationFacadeType newFacadeType) {
    SupportedPushNotificationFacadeType pushNotificationFacadeType = settings.getPushNotificationFacadeType();
    PushNotificationServiceFacade currentFacade = facades.get(pushNotificationFacadeType);
    PushNotificationServiceFacade newFacade = facades.get(newFacadeType);

    if ((currentFacade != null) && (newFacade != null)) {
        return currentFacade
                .unsubscribe()
                .andThen(newFacade.subscribe())
                .doOnComplete(() -> settings.setPushNotificationFacadeType(newFacadeType))
                .timeout(BuildConfig.DEFAULT_OPERATION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
    } else {
        return Completable.error(new NotSupportedPushNotificationFacade("Not Supported facade: " + pushNotificationFacadeType));
    }
}
 

@Override
public Completable destroy() {
    try {
        pgDatasource.close();
        return Completable.complete();
    } catch (Throwable e) {
        return Completable.error(e);
    }
}
 

@Override
protected Completable createInstanceFailingImmediately(RuntimeException e) {
    return Completable.error(e);
}
 

@Override public Completable write(String name, ByteString value) {
  return Completable.error(new UnsupportedOperationException());
}
 

@Override
public Completable rxStop() {
  return Completable.error(err);
}