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

/**
 * This method checks whether the supplied characteristic possesses properties supporting the requested kind of operation, specified by
 * the supplied bitmask.
 *
 * Emits {@link BleIllegalOperationException} if there was no match between supported and necessary properties of characteristic and
 * check has not been suppressed
 *
 * @param characteristic   a {@link BluetoothGattCharacteristic} the operation is done on
 * @param neededProperties properties required for the operation to be successfully completed
 * @return {@link Completable} deferring execution of the check till subscription
 */
public Completable checkAnyPropertyMatches(final BluetoothGattCharacteristic characteristic,
                                           final @BluetoothGattCharacteristicProperty int neededProperties) {
    return Completable.fromAction(new Action() {
        public void run() {
            final int characteristicProperties = characteristic.getProperties();

            if ((characteristicProperties & neededProperties) == 0) {
                BleIllegalOperationException exception = resultHandler.handleMismatchData(characteristic, neededProperties);
                if (exception != null) {
                    throw exception;
                }
            }
        }
    });
}
 

private Completable checkEvents()
{
    //check events for corresponding tokens
    return Completable.fromAction(() -> {
        for (EventDefinition ev : eventList)
        {
            try
            {
                getEvents(ev);
            }
            catch (Exception e)
            {
                //TODO: Handle event issues
                e.printStackTrace();
            }
        }
    });
}
 

@Override public Completable write(@NonNull final String name, @Nullable final ByteString value) {
  return Completable.fromAction(new Action() {
    @Override public void run() throws Exception {
      checkCanStoreSecurely();

      synchronized (dataLock) {
        if (value == null) {
          storage.remove(name);
          return;
        }

        prepareKeyStore();

        Cipher cipher = createCipher();
        cipher.init(Cipher.ENCRYPT_MODE, getPublicKey());

        storage.put(name, ByteString.of(cipher.doFinal(value.toByteArray())));
      }
    }
  });
}
 

@Override
public Completable setModuleEnabled(boolean enabled) {
    return Completable.fromAction(() -> {
        boolean result = context.getSharedPreferences(CONFIG_FILE, Context.MODE_PRIVATE)
                .edit().putBoolean(KEY_MODULE_ENABLED, enabled).commit();
        if (!result) {
            throw new IOException("Failed writing module enabled value to local storage");
        }
    });
}
 

@Override
protected Completable doBegin() {
    return Completable.fromAction(() -> {
        if (connection0.getAutoCommit()) {
            connection0.setAutoCommit(false);
        }
    });
}
 

private Completable saveLastGeneratedSubmissionId() {
    return Completable.fromAction(() -> {
        boolean result = context.getSharedPreferences(
                ONGOING_SUBMISSIONS_CONFIG_FILE, Context.MODE_PRIVATE)
                .edit().putInt(KEY_LAST_SUBMISSION_ID, lastGeneratedSubmissionId).commit();
        if (!result) {
            throw new IOException("Failed writing last submission id to local storage");
        }
    });
}
 

private Task<Void> logMessageClick(Action action) {

    Logging.logd("Attempting to record: " + MESSAGE_CLICK);
    Completable completable =
        Completable.fromAction(() -> metricsLoggerClient.logMessageClick(inAppMessage, action));

    return logImpressionIfNeeded(completable);
  }
 

Completable setMetadataIds(final SMSMetadata metadata) {
    return Completable.fromAction(() -> {
                OutputStream fos = context.openFileOutput(METADATA_FILE, Context.MODE_PRIVATE);
                JsonWriter writer = new JsonWriter(new OutputStreamWriter(fos, StandardCharsets.UTF_8));
                getGson().toJson(metadata, SMSMetadata.class, writer);
                writer.flush();
                writer.close();
            }
    );
}
 

@Override
public Completable deleteIfExist() {
    return Completable.fromAction(this::blockingDeleteIfExist);
}
 

private Completable updateWasImpressed() {
  return Completable.fromAction(() -> wasImpressed = true);
}
 

@Override
public Completable setGatewayNumber(String number) {
    return Completable.fromAction(() -> gatewayNumber = number);
}
 

public Completable insertItem(ChecklistItem item) {
    return Completable.fromAction(() -> mDataSource.insertItem(item));
}
 

@Override
public Completable delete() {
    return Completable.fromAction(this::blockingDelete);
}
 

@Override
public Completable setDefaultWallet(Wallet wallet) {
	return Completable.fromAction(() -> preferenceRepositoryType.setCurrentWalletAddress(wallet.address));
}
 

public Completable put(NetworkInfo networkInfo, Wallet wallet, TokenInfo tokenInfo) {
    return Completable.fromAction(() -> putInNeed(networkInfo, wallet, tokenInfo));
}
 

@Override
protected Completable doCommit() {
    return Completable.fromAction(() -> connection0.commit());
}
 

@Override
protected Completable doRollback() {
    return Completable.fromAction(() -> {
        connection0.rollback();
    });
}
 

public Completable updateName(final String name, final int id) {
    return Completable.fromAction(() -> mDataSource.updateName(name, id));
}
 

@Override
public Completable setDefaultWallet(Wallet wallet)
{
	return Completable.fromAction(() -> preferenceRepositoryType.setCurrentWalletAddress(wallet.address));
}
 

@Override
public Completable updateEventSubmissionState(String eventUid, State state) {
    return Completable.fromAction(() -> eventStore.setState(eventUid, state));
}