Java BitcoinURI类代码示例

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
@Override
public void onLoadFinished(final Loader<Address> loader, final Address currentAddress) {
    if (!currentAddress.equals(currentAddressQrAddress)) {
        currentAddressQrAddress = new AddressAndLabel(currentAddress, config.getOwnName());

        final String addressStr = BitcoinURI.convertToBitcoinURI(currentAddressQrAddress.address, null,
                currentAddressQrAddress.label, null);

        currentAddressQrBitmap = new BitmapDrawable(getResources(), Qr.bitmap(addressStr));
        currentAddressQrBitmap.setFilterBitmap(false);

        currentAddressUriRef.set(addressStr);

        updateView();
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public void showQrDialog() {
    try {
        Address receiveAddress = walletServiceBinder.getCurrentReceiveAddress();
        String bitcoinUriStr = BitcoinURI.convertToBitcoinURI(receiveAddress, null, null, null);
        QrDialogFragment
                .newInstance(new BitcoinURI(bitcoinUriStr))
                .show(getFragmentManager(), "qr_dialog_fragment");
        Log.d(TAG, "showQrDialog - bitcoinUri" + bitcoinUriStr);
    } catch (Exception e) {
        Log.w(TAG, "Error showing QR Code: ", e);
        AlertDialog.Builder builder = new AlertDialog.Builder(this, R.style.AlertDialogAccent);
        Dialog dialog = builder
                .setTitle(R.string.qr_code_error_title)
                .setMessage(getString(R.string.qr_code_error_message, e.getMessage()))
                .setNeutralButton(R.string.ok, null)
                .create();
        dialog.show();
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == Constants.QR_ACTIVITY_RESULT_REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {
            final String scanContent = data.getStringExtra(Intents.Scan.RESULT);
            try {
                BitcoinURI bitcoinURI = new BitcoinURI(scanContent);
                if (bitcoinURI.getAddress() != null) {
                    addressEditText.setText(bitcoinURI.getAddress().toString());
                    return;
                }
            } catch (BitcoinURIParseException e) {
                Log.w(TAG, "Could not parse scanned content: '" + scanContent + "'", e);
            }
            // set to scanned content if no address detected
            addressEditText.setText(scanContent);
        }
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
@Override
public void onLoadFinished(final Loader<Address> loader, final Address currentAddress)
{
    if (!currentAddress.equals(currentAddressQrAddress))
    {
        currentAddressQrAddress = new AddressAndLabel(currentAddress, config.getOwnName());

        final String addressStr = BitcoinURI.convertToBitcoinURI(currentAddressQrAddress.address, null, currentAddressQrAddress.label, null);

        final int size = getResources().getDimensionPixelSize(R.dimen.bitmap_dialog_qr_size);
        currentAddressQrBitmap = Qr.bitmap(addressStr, size);

        currentAddressUriRef.set(addressStr);

        updateView();
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
/**
 * Returns a future that will be notified with a PaymentSession object after it is fetched using the provided uri.
 * uri is a BIP-72-style BitcoinURI object that specifies where the {@link org.bitcoin.protocols.payments.Protos.PaymentRequest} object may
 * be fetched in the r= parameter.
 * If verifyPki is specified and the payment request object specifies a PKI method, then the system trust store will
 * be used to verify the signature provided by the payment request. An exception is thrown by the future if the
 * signature cannot be verified.
 * If trustStoreLoader is null, the system default trust store is used.
 */
public static ListenableFuture<PaymentSession> createFromBitcoinUri(final BitcoinURI uri, final boolean verifyPki, @Nullable final TrustStoreLoader trustStoreLoader)
        throws PaymentProtocolException {
    String url = uri.getPaymentRequestUrl();
    if (url == null)
        throw new PaymentProtocolException.InvalidPaymentRequestURL("No payment request URL (r= parameter) in BitcoinURI " + uri);
    try {
        return fetchPaymentRequest(new URI(url), verifyPki, trustStoreLoader);
    } catch (URISyntaxException e) {
        throw new PaymentProtocolException.InvalidPaymentRequestURL(e);
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public static PaymentIntent fromBitcoinUri(final BitcoinURI bitcoinUri) {
    final Address address = bitcoinUri.getAddress();
    final Output[] outputs = address != null ? buildSimplePayTo(bitcoinUri.getAmount(), address) : null;
    final String bluetoothMac = (String) bitcoinUri.getParameterByName(Bluetooth.MAC_URI_PARAM);
    final String paymentRequestHashStr = (String) bitcoinUri.getParameterByName("h");
    final byte[] paymentRequestHash = paymentRequestHashStr != null ? base64UrlDecode(paymentRequestHashStr) : null;

    return new PaymentIntent(PaymentIntent.Standard.BIP21, null, null, outputs, bitcoinUri.getLabel(),
            bluetoothMac != null ? "bt:" + bluetoothMac : null, null, bitcoinUri.getPaymentRequestUrl(),
            paymentRequestHash);
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
private String determineBitcoinRequestStr(final boolean includeBluetoothMac) {
    final Coin amount = amountCalculatorLink.getAmount();
    final String ownName = config.getOwnName();

    final StringBuilder uri = new StringBuilder(BitcoinURI.convertToBitcoinURI(address, amount, ownName, null));
    if (includeBluetoothMac && bluetoothMac != null) {
        uri.append(amount == null && ownName == null ? '?' : '&');
        uri.append(Bluetooth.MAC_URI_PARAM).append('=').append(bluetoothMac);
    }
    return uri.toString();
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public PaymentFinalizeStep(BitcoinURI bitcoinURI, Transaction transaction,
                                                    List<TransactionSignature> clientTxSignatures,
                                                    List<TransactionSignature> serverTxSignatures,
                                                    WalletService.WalletServiceBinder walletService) {
    super(bitcoinURI);
    this.transaction = transaction;
    this.clientTxSignatures = clientTxSignatures;
    this.serverTxSignatures = serverTxSignatures;
    this.walletService = walletService;
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public InstantPaymentServerHandlerCLTV(InputStream inputStream, OutputStream outputStream,
                                                   BitcoinURI paymentRequestURI,
                                                   PaymentRequestDelegate paymentRequestDelegate,
                                                   WalletService.WalletServiceBinder walletServiceBinder) {
    super(inputStream, outputStream);
    this.paymentRequestURI = paymentRequestURI;
    this.paymentRequestDelegate = paymentRequestDelegate;
    this.walletServiceBinder = walletServiceBinder;
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public ListenableFuture<Transaction> sendCoins(final Address address, final Coin amount) {
    ExecutorService executor = Executors.newSingleThreadExecutor(bitcoinjThreadFactory);
    ListeningExecutorService sendCoinsExecutor = MoreExecutors.listeningDecorator(executor);
    ListenableFuture<Transaction> txFuture = sendCoinsExecutor.submit(new Callable<Transaction>() {
        @Override
        public Transaction call() throws Exception {
            BitcoinURI payment = new BitcoinURI(BitcoinURI.convertToBitcoinURI(address, amount, null, null));
            CLTVInstantPaymentStep step = new CLTVInstantPaymentStep(walletServiceBinder, payment);
            step.process(null);
            Transaction fullySignedTx = step.getTransaction();
            maybeCommitAndBroadcastTransaction(fullySignedTx);
            Log.i(TAG, "Send Coins - address=" + address + ", amount=" + amount
                    + ", txHash=" + fullySignedTx.getHashAsString());
            return fullySignedTx;
        }
    });
    sendCoinsExecutor.shutdown();
    Futures.addCallback(txFuture, new FutureCallback<Transaction>() {
        @Override
        public void onSuccess(Transaction result) {
            Log.i(TAG, "sendCoins - onSuccess - tx " + result.getHashAsString());
            broadcastInstantPaymentSuccess();
        }

        @Override
        public void onFailure(Throwable t) {
            Log.e(TAG, "sendCoins - onFailure - failed with the following throwable: ", t);
            broadcastInstantPaymentFailure();
        }
    });
    return txFuture;
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
@Override
protected DialogFragment getDialogFragment() {
    try {
        return ReceiveDialogFragment.newInstance(new BitcoinURI(BitcoinURI.convertToBitcoinURI(walletServiceBinder.getCurrentReceiveAddress(),this.coin(),"","")));
    } catch (BitcoinURIParseException e) {
        return null;
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
public static String bitcoinUriToString(BitcoinURI bitcoinURI) {
    return BitcoinURI.convertToBitcoinURI(
            bitcoinURI.getAddress(),
            bitcoinURI.getAmount(),
            bitcoinURI.getLabel(),
            bitcoinURI.getMessage());
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
@Override
public void onReceive(Context context, Intent intent) {
    String uri = intent.getStringExtra(Constants.BITCOIN_URI_KEY);
    try {
        final BitcoinURI bitcoinURI = new BitcoinURI(uri);
        startServers(bitcoinURI);
        showAuthViewAndGetResult(bitcoinURI, false, false);
    } catch (BitcoinURIParseException e) {
        Log.w(TAG, "Could not parse Bitcoin URI: " + uri);
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
private void startServers(BitcoinURI bitcoinURI) {
    Log.d(TAG, "Start servers.");
    for (AbstractServer server : servers) {
        server.setPaymentRequestUri(bitcoinURI);
        server.start();
    }
}
 

import org.bitcoinj.uri.BitcoinURI; //导入依赖的package包/类
private boolean showAuthViewAndGetResult(BitcoinURI paymentRequest, boolean isBlocking, final boolean showAccept) {
    countDownLatch = new CountDownLatch(1); //because we need a synchronous answer
    restartServers = true;
    authViewDialog = AuthenticationDialog.newInstance(paymentRequest, showAccept);
    authViewDialog.show(getSupportFragmentManager(), "auth_view_dialog");
    if (isBlocking) {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            Log.e(TAG, "Interrupted while waiting: ", e);
        }
    }
    return authviewResponse;
}