Java Code Examples for androidx.annotation.VisibleForTesting#NONE

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
public void simulateDisconnect() {
    if (this.mockMode) {
        setState(GattState.DISCONNECTED);
        for (ConnectionEventListener asyncConnListener : getConnectionEventListeners()) {
            asyncConnListener.onClientConnectionStateChanged(new TransactionResult.Builder()
                    .resultStatus(TransactionResult.TransactionResultStatus.FAILURE)
                    .gattState(getGattState())
                    .responseStatus(GattStatus.GATT_UNKNOWN.ordinal()).build(), this);
        }
    } else {
        throw new IllegalStateException(String.format(Locale.ENGLISH, "[%s] You can't simulate a disconnection if you are not in mock mode", getDevice()));
    }
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
@SuppressWarnings("SameParameterValue")
    // API Method
void populateMockScanResultIndividualValue(int callbackType, ScanResult scanResult) {
    if (callback != null) {
        callback.onScanResult(callbackType, scanResult);
    }
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
FitbitGatt(AlwaysConnectedScanner alwaysConnectedScanner, Handler fitbitGattAsyncOperationHandler, Handler connectionCleanup, LooperWatchdog watchDog) {
    this.overallGattEventListeners = new CopyOnWriteArrayList<>();
    this.alwaysConnectedScanner = alwaysConnectedScanner;
    this.fitbitGattAsyncOperationHandler = fitbitGattAsyncOperationHandler;
    this.connectionCleanup = connectionCleanup;
    this.asyncOperationThreadWatchdog = watchDog;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
List<FitbitBluetoothDevice> getNewlyScannedDevicesOnly() {
    ArrayList<FitbitBluetoothDevice> devices = new ArrayList<>();
    for (FitbitBluetoothDevice iteratedDevice : getConnectionMap().keySet()) {
        if (iteratedDevice.origin.equals(FitbitBluetoothDevice.DeviceOrigin.SCANNED)) {
            devices.add(iteratedDevice);
        }
    }
    return devices;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
void injectMockScanner(ScannerInterface scanner) {
    this.scanner = scanner;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
void populateMockScanResultBatchValues(List<ScanResult> scanResults) {
    if (callback != null) {
        callback.onBatchScanResults(scanResults);
    }
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
@SuppressWarnings({"unused", "WeakerAccess"})
    // API Method
List<GattClientListener> getAllGattClientListeners() {
    return getClientCallback().getGattClientListeners();
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
void unregisterAllGattEventListeners() {
    overallGattEventListeners.clear();
}
 

/**
 * Do not do this unless you truly know what you are doing, there are very, very few reasons
 * to perform this operation.
 */
@VisibleForTesting(otherwise = VisibleForTesting.NONE)
@SuppressWarnings({"unused", "WeakerAccess"})
// API Method
public void shutdown() {
    Timber.v("Someone wants to shutdown the gatt");
    this.overallGattEventListeners.clear();
    this.servicesToAdd.clear();
    this.connectionMap.clear();
    if (asyncOperationThreadWatchdog != null) {
        this.asyncOperationThreadWatchdog.stopProbing();
    }
    //clean up callbacks and listeners;
    if (serverCallback != null) {
        serverCallback.unregisterAll();
    }
    if (this.appContext != null && this.aclListener != null) {
        this.aclListener.unregister(this.appContext);
    }
    if (this.peripheralScanner != null) {
        this.peripheralScanner.onDestroy(this.appContext);
    }
    if (this.aclListener != null) {
        this.aclListener.unregister(this.appContext);
    }
    if (radioStatusListener != null) {
        radioStatusListener.stopListening();
        radioStatusListener.removeListener();
    }

    if(serverConnection != null) {
        List<ServerConnectionEventListener> serverConnectionEventListeners = serverConnection.getConnectionEventListeners();
        for (ServerConnectionEventListener serverConnectionEventListener : serverConnectionEventListeners) {
            serverConnection.unregisterConnectionEventListener(serverConnectionEventListener);
        }
        serverConnection.close();
        serverConnection = null;
        if(gattServer != null) {
            gattServer.close();
        }
    }
    //clear up all references
    this.gattServer = null;
    this.serverConnection = null;
    this.connectionCleanup = null;
    this.isInitialized.set(false);
    this.isGattClientStarted.set(false);
    this.isGattServerStarted.set(false);
    this.appContext = null;
    this.serverCallback = null;
    this.clientCallback = null;
    this.radioStatusListener = null;
    this.aclListener = null;
    this.peripheralScanner = null;
    this.asyncOperationThreadWatchdog = null;
}
 

@Nullable
@VisibleForTesting(otherwise = VisibleForTesting.NONE)
@GuardedBy("this")
public LayoutState getCommittedLayoutState() {
  return mCommittedLayoutState;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
void setEmulateOnAttachToWindow(final boolean emulateOnAttachToWindow) {
    mEmulateOnAttachToWindow = emulateOnAttachToWindow;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
public CallFetcher<P> getFetcher() {
    return fetcher;
}
 

@VisibleForTesting(otherwise = VisibleForTesting.NONE)
public CallProcessor<P> getProcessor() {
    return processor;
}