org.bitcoinj.wallet.listeners.KeyChainEventListener Java Examples

@Test
public void events() throws Exception {
    // Check that events are registered with the right chains and that if a chain is added, it gets the event
    // listeners attached properly even post-hoc.
    final AtomicReference<ECKey> ran = new AtomicReference<>(null);
    final KeyChainEventListener listener = new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> keys) {
            ran.set(keys.get(0));
        }
    };
    group.addEventListener(listener, Threading.SAME_THREAD);
    ECKey key = group.freshKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    assertEquals(key, ran.getAndSet(null));
    ECKey key2 = new ECKey();
    group.importKeys(key2);
    assertEquals(key2, ran.getAndSet(null));
    group.removeEventListener(listener);
    ECKey key3 = new ECKey();
    group.importKeys(key3);
    assertNull(ran.get());
}
 

@Test
public void events() throws Exception {
    // Check that events are registered with the right chains and that if a chain is added, it gets the event
    // listeners attached properly even post-hoc.
    final AtomicReference<ECKey> ran = new AtomicReference<>(null);
    final KeyChainEventListener listener = new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> keys) {
            ran.set(keys.get(0));
        }
    };
    group.addEventListener(listener, Threading.SAME_THREAD);
    ECKey key = group.freshKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    assertEquals(key, ran.getAndSet(null));
    ECKey key2 = new ECKey();
    group.importKeys(key2);
    assertEquals(key2, ran.getAndSet(null));
    group.removeEventListener(listener);
    ECKey key3 = new ECKey();
    group.importKeys(key3);
    assertNull(ran.get());
}
 

@Test
public void events() throws Exception {
    // Check that events are registered with the right chains and that if a chain is added, it gets the event
    // listeners attached properly even post-hoc.
    final AtomicReference<ECKey> ran = new AtomicReference<>(null);
    final KeyChainEventListener listener = new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> keys) {
            ran.set(keys.get(0));
        }
    };
    group.addEventListener(listener, Threading.SAME_THREAD);
    ECKey key = group.freshKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    assertEquals(key, ran.getAndSet(null));
    ECKey key2 = new ECKey();
    group.importKeys(key2);
    assertEquals(key2, ran.getAndSet(null));
    group.removeEventListener(listener);
    ECKey key3 = new ECKey();
    group.importKeys(key3);
    assertNull(ran.get());
}
 

private void queueOnKeysAdded(final List<ECKey> keys) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<KeyChainEventListener> registration : listeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onKeysAdded(keys);
            }
        });
    }
}
 

@Test
public void keyEvents() throws Exception {
    // Check that we can register an event listener, generate some keys and the callbacks are invoked properly.
    wallet = new Wallet(PARAMS);
    final List<ECKey> keys = Lists.newLinkedList();
    wallet.addKeyChainEventListener(Threading.SAME_THREAD, new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> k) {
            keys.addAll(k);
        }
    });
    wallet.freshReceiveKey();
    assertEquals(1, keys.size());
}
 

/**
 * Adds an HD chain to the chains list, and make it the default chain (from which keys are issued).
 * Useful for adding a complex pre-configured keychain, such as a married wallet.
 */
public void addAndActivateHDChain(DeterministicKeyChain chain) {
    log.info("Creating and activating a new HD chain: {}", chain);
    for (ListenerRegistration<KeyChainEventListener> registration : basic.getListeners())
        chain.addEventListener(registration.listener, registration.executor);
    if (lookaheadSize >= 0)
        chain.setLookaheadSize(lookaheadSize);
    if (lookaheadThreshold >= 0)
        chain.setLookaheadThreshold(lookaheadThreshold);
    chains.add(chain);
}
 

/**
 * Adds an HD chain to the chains list, and make it the default chain (from which keys are issued).
 * Useful for adding a complex pre-configured keychain, such as a married wallet.
 */
public void addAndActivateHDChain(DeterministicKeyChain chain) {
    log.info("Creating and activating a new HD chain: {}", chain);
    for (ListenerRegistration<KeyChainEventListener> registration : basic.getListeners())
        chain.addEventListener(registration.listener, registration.executor);
    if (lookaheadSize >= 0)
        chain.setLookaheadSize(lookaheadSize);
    if (lookaheadThreshold >= 0)
        chain.setLookaheadThreshold(lookaheadThreshold);
    chains.add(chain);
}
 

/** Adds a listener for events that are run when keys are added, on the given executor. */
public void addEventListener(KeyChainEventListener listener, Executor executor) {
    checkNotNull(listener);
    checkNotNull(executor);
    basic.addEventListener(listener, executor);
    for (DeterministicKeyChain chain : chains)
        chain.addEventListener(listener, executor);
}
 

/** Removes a listener for events that are run when keys are added. */
public boolean removeEventListener(KeyChainEventListener listener) {
    checkNotNull(listener);
    for (DeterministicKeyChain chain : chains)
        chain.removeEventListener(listener);
    return basic.removeEventListener(listener);
}
 

/** Removes a listener for events that are run when keys are added. */
public boolean removeEventListener(KeyChainEventListener listener) {
    checkNotNull(listener);
    for (DeterministicKeyChain chain : chains)
        chain.removeEventListener(listener);
    return basic.removeEventListener(listener);
}
 

/** Adds a listener for events that are run when keys are added, on the given executor. */
public void addEventListener(KeyChainEventListener listener, Executor executor) {
    checkNotNull(listener);
    checkNotNull(executor);
    basic.addEventListener(listener, executor);
    for (DeterministicKeyChain chain : chains)
        chain.addEventListener(listener, executor);
}
 

/**
 * Adds an HD chain to the chains list, and make it the default chain (from which keys are issued).
 * Useful for adding a complex pre-configured keychain, such as a married wallet.
 */
public void addAndActivateHDChain(DeterministicKeyChain chain) {
    log.info("Creating and activating a new HD chain: {}", chain);
    for (ListenerRegistration<KeyChainEventListener> registration : basic.getListeners())
        chain.addEventListener(registration.listener, registration.executor);
    if (lookaheadSize >= 0)
        chain.setLookaheadSize(lookaheadSize);
    if (lookaheadThreshold >= 0)
        chain.setLookaheadThreshold(lookaheadThreshold);
    chains.add(chain);
}
 

@Test
public void keyEvents() throws Exception {
    // Check that we can register an event listener, generate some keys and the callbacks are invoked properly.
    wallet = new Wallet(UNITTEST);
    final List<ECKey> keys = Lists.newLinkedList();
    wallet.addKeyChainEventListener(Threading.SAME_THREAD, new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> k) {
            keys.addAll(k);
        }
    });
    wallet.freshReceiveKey();
    assertEquals(1, keys.size());
}
 

private void queueOnKeysAdded(final List<ECKey> keys) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<KeyChainEventListener> registration : listeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onKeysAdded(keys);
            }
        });
    }
}
 

private void queueOnKeysAdded(final List<ECKey> keys) {
    checkState(lock.isHeldByCurrentThread());
    for (final ListenerRegistration<KeyChainEventListener> registration : listeners) {
        registration.executor.execute(new Runnable() {
            @Override
            public void run() {
                registration.listener.onKeysAdded(keys);
            }
        });
    }
}
 

/**
 * Removes a listener for events that are run when keys are added.
 */
public boolean removeEventListener(KeyChainEventListener listener) {
    checkNotNull(listener);
    for (DeterministicKeyChain chain : chains)
        chain.removeEventListener(listener);
    return basic.removeEventListener(listener);
}
 

/**
 * Adds a listener for events that are run when keys are added, on the given executor.
 */
public void addEventListener(KeyChainEventListener listener, Executor executor) {
    checkNotNull(listener);
    checkNotNull(executor);
    basic.addEventListener(listener, executor);
    for (DeterministicKeyChain chain : chains)
        chain.addEventListener(listener, executor);
}
 

@Test
public void keyEvents() throws Exception {
    // Check that we can register an event listener, generate some keys and the callbacks are invoked properly.
    wallet = new Wallet(PARAMS);
    final List<ECKey> keys = Lists.newLinkedList();
    wallet.addKeyChainEventListener(Threading.SAME_THREAD, new KeyChainEventListener() {
        @Override
        public void onKeysAdded(List<ECKey> k) {
            keys.addAll(k);
        }
    });
    wallet.freshReceiveKey();
    assertEquals(1, keys.size());
}
 

@Override
public boolean removeEventListener(KeyChainEventListener listener) {
    return basicKeyChain.removeEventListener(listener);
}
 

/** Adds a listener for events that are run when keys are added, on the user thread. */
void addEventListener(KeyChainEventListener listener);
 

/** Adds a listener for events that are run when keys are added, on the given executor. */
void addEventListener(KeyChainEventListener listener, Executor executor);
 

/** Removes a listener for events that are run when keys are added. */
boolean removeEventListener(KeyChainEventListener listener);
 

@Override
public void addEventListener(KeyChainEventListener listener, Executor executor) {
    basicKeyChain.addEventListener(listener, executor);
}
 

public List<ListenerRegistration<KeyChainEventListener>> getListeners() {
    return new ArrayList<>(listeners);
}
 

@Override
public void addEventListener(KeyChainEventListener listener) {
    addEventListener(listener, Threading.USER_THREAD);
}
 

@Override
public void addEventListener(KeyChainEventListener listener) {
    basicKeyChain.addEventListener(listener);
}
 

@Override
public void addEventListener(KeyChainEventListener listener, Executor executor) {
    listeners.add(new ListenerRegistration<>(listener, executor));
}
 

@Override
public boolean removeEventListener(KeyChainEventListener listener) {
    return ListenerRegistration.removeFromList(listener, listeners);
}
 

/** Adds a listener for events that are run when keys are added, on the user thread. */
public void addEventListener(KeyChainEventListener listener) {
    addEventListener(listener, Threading.USER_THREAD);
}
 

/** Adds a listener for events that are run when keys are added, on the given executor. */
void addEventListener(KeyChainEventListener listener, Executor executor);