How to use

CancellationSignal

in

androidx.core.os

@Override
protected void doIdentify() {
  try {
    mCancellationSignal = new CancellationSignal();
    mFingerprintManagerCompat.authenticate(null, 0, mCancellationSignal, new FingerprintManagerCompat.AuthenticationCallback() {
      @Override

@Override
protected void doCancelIdentify() {
  try {
    if (mCancellationSignal != null) {
      mCancellationSignal.cancel();
    }
  } catch (Throwable e) {
    onCatchException(e);
  }
}

@Override
public void authenticate(Context context, CryptoObject crypto, int flags, CancellationSignal cancel,
             AuthenticationCallback callback, Handler handler) {
  FingerprintManagerCompatApi23.authenticate(context, wrapCryptoObject(crypto), flags,
      cancel != null ? cancel.getCancellationSignalObject() : null, wrapCallback(callback), handler);
}

private void attachCancellationSignal(CancellationSignal cancellationSignal) {
  if (cancellationSignal != null) {
    cancellationSignal.throwIfCanceled();
    mCancellationSignalAttachCount += 1;
    if (mCancellationSignalAttachCount == 1) {
      // Reset cancellation flag before executing the statement.
      nativeResetCancel(mConnectionPtr, true /*cancelable*/);
      // After this point, onCancel() may be called concurrently.
      cancellationSignal.setOnCancelListener(this);
    }
  }
}

@SuppressLint("Assert")
private void detachCancellationSignal(CancellationSignal cancellationSignal) {
  if (cancellationSignal != null) {
    assert mCancellationSignalAttachCount > 0;
    mCancellationSignalAttachCount -= 1;
    if (mCancellationSignalAttachCount == 0) {
      // After this point, onCancel() cannot be called concurrently.
      cancellationSignal.setOnCancelListener(null);
      // Reset cancellation flag after executing the statement.
      nativeResetCancel(mConnectionPtr, false /*cancelable*/);
    }
  }
}

private boolean yieldTransactionUnchecked(long sleepAfterYieldDelayMillis,
    CancellationSignal cancellationSignal) {
  if (cancellationSignal != null) {
    cancellationSignal.throwIfCanceled();
  }
  if (!mConnectionPool.shouldYieldConnection(mConnection, mConnectionFlags)) {
    return false;
  }
  final int transactionMode = mTransactionStack.mMode;
  final SQLiteTransactionListener listener = mTransactionStack.mListener;
  final int connectionFlags = mConnectionFlags;
  endTransactionUnchecked(cancellationSignal, true); // might throw
  if (sleepAfterYieldDelayMillis > 0) {
    try {
      Thread.sleep(sleepAfterYieldDelayMillis);
    } catch (InterruptedException ex) {
      // we have been interrupted, that's all we need to do
    }
  }
  beginTransactionUnchecked(transactionMode, listener, connectionFlags,
      cancellationSignal); // might throw
  return true;
}

  @Test
  public void unsubscribe_cancels() throws Exception {
    assertFalse(module.cancellationSignal.isCanceled());
    ts.dispose();
    assertTrue(module.cancellationSignal.isCanceled());
  }
}

  cancellationSignal.throwIfCanceled();
cancellationSignal.setOnCancelListener(new CancellationSignal.OnCancelListener() {
  @Override
  public void onCancel() {
  cancellationSignal.setOnCancelListener(null);

cancellationSignal.setOnCancelListener(new CancellationSignal.OnCancelListener() {
  @Override
  public void onCancel() {

cancellationSignal.throwIfCanceled();

  @Test
  public void unsubscribe_cancels() throws Exception {
    assertFalse(module.cancellationSignal.isCanceled());
    ts.unsubscribe();
    assertTrue(module.cancellationSignal.isCanceled());
  }
}

public void startListening(FingerprintManagerCompat.CryptoObject cryptoObject) {
  if (!mListening) {
    mListening = true;
    mCancellationSignal = new CancellationSignal();
    mSelfCancelled = false;
    mFingerprintManagerCompat
        .authenticate(cryptoObject, 0, mCancellationSignal, this, null);
    mSwirlView.setState(SwirlView.State.ON);
  }
}

  @Override
  public void onCancel() {
    supportCancellationSignal.cancel();
  }
});

void authenticate(final CancellationSignal cancellationSignal,
             final AuthenticationListener listener,
             final Reprint.RestartPredicate restartPredicate,
             final int restartCount) throws SecurityException {
  final FingerprintManager fingerprintManager = fingerprintManager();
  if (fingerprintManager == null) {
    listener.onFailure(AuthenticationFailureReason.UNKNOWN, true,
        context.getString(R.string.fingerprint_error_hw_not_available), TAG, FINGERPRINT_ERROR_CANCELED);
    return;
  }
  final FingerprintManager.AuthenticationCallback callback =
      new AuthCallback(restartCount, restartPredicate, cancellationSignal, listener);
  // Why getCancellationSignalObject returns an Object is unexplained
  final android.os.CancellationSignal signalObject = cancellationSignal == null ? null :
      (android.os.CancellationSignal) cancellationSignal.getCancellationSignalObject();
  // Occasionally, an NPE will bubble up out of FingerprintManager.authenticate
  try {
    fingerprintManager.authenticate(null, signalObject, 0, callback, null);
  } catch (NullPointerException e) {
    logger.logException(e, "MarshmallowReprintModule: authenticate failed unexpectedly");
    listener.onFailure(AuthenticationFailureReason.UNKNOWN, true,
        context.getString(R.string.fingerprint_error_unable_to_process), TAG, FINGERPRINT_ERROR_CANCELED);
  }
}

  CancellationSignal cancellationSignal) {
if (cancellationSignal != null) {
  cancellationSignal.throwIfCanceled();

void beginAuthentication() {
  cancellationSignal = new CancellationSignal();
  FingerprintManagerCompat.AuthenticationCallback callback = new FingerprintManagerCompat.AuthenticationCallback() {
    @Override
    public void onAuthenticationError(int errMsgId, CharSequence errString) {
      super.onAuthenticationHelp(errMsgId, errString);
      if (!canceled) {
        fingerprintView.onError(errString.toString(), true);
      }
    }
    @Override
    public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
      super.onAuthenticationHelp(helpMsgId, helpString);
      if (!canceled) {
        fingerprintView.onError(helpString.toString(), false);
      }
    }
    @Override
    public void onAuthenticationSucceeded(FingerprintManagerCompat.AuthenticationResult result) {
      super.onAuthenticationSucceeded(result);
      fingerprintView.onSuccess(result.getCryptoObject());
    }
    @Override
    public void onAuthenticationFailed() {
      super.onAuthenticationFailed();
      fingerprintView.onError(R.string.fingerprint_not_recognized);
    }
  };
  fingerprintManager.authenticate(fingerprintView.cryptoObject(), 0, cancellationSignal, callback, null);
}

public void stopListening() {
  if (mCancellationSignal != null) {
    mSelfCancelled = true;
    mCancellationSignal.cancel();
    mCancellationSignal = null;
    mListening = false;
  }
}

private void endTransactionUnchecked(CancellationSignal cancellationSignal, boolean yielding) {
  if (cancellationSignal != null) {
    cancellationSignal.throwIfCanceled();

/**
 * Runs the provided SQL and returns a {@link Cursor} over the result set.
 *
 * @param supportQuery the SQL query. The SQL string must not be ; terminated
 * @param signal A signal to cancel the operation in progress, or null if none.
 * If the operation is canceled, then {@link OperationCanceledException} will be thrown
 * when the query is executed.
 * @return A {@link Cursor} object, which is positioned before the first entry. Note that
 * {@link Cursor}s are not synchronized, see the documentation for more details.
 */
@Override
@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
public Cursor query(SupportSQLiteQuery supportQuery, android.os.CancellationSignal signal) {
  final CancellationSignal supportCancellationSignal = new CancellationSignal();
  signal.setOnCancelListener(new android.os.CancellationSignal.OnCancelListener() {
    @Override
    public void onCancel() {
      supportCancellationSignal.cancel();
    }
  });
  return query(supportQuery, supportCancellationSignal);
}

void cancel() {
  cancellationSignal.cancel();
  this.canceled = true;
}