import org.bitcoin.protocols.payments.Protos.Payment; //导入依赖的package包/类
@Test
public void testPaymentMessage() throws Exception {
    // Create
    List<Transaction> transactions = new LinkedList<Transaction>();
    transactions.add(FakeTxBuilder.createFakeTx(NETWORK_PARAMS, AMOUNT, TO_ADDRESS));
    Coin refundAmount = Coin.SATOSHI;
    Address refundAddress = new ECKey().toAddress(NETWORK_PARAMS);
    Payment payment = PaymentProtocol.createPaymentMessage(transactions, refundAmount, refundAddress, MEMO,
            MERCHANT_DATA);
    byte[] paymentBytes = payment.toByteArray();

    // Parse
    Payment parsedPayment = Payment.parseFrom(paymentBytes);
    List<Transaction> parsedTransactions = PaymentProtocol.parseTransactionsFromPaymentMessage(NETWORK_PARAMS,
            parsedPayment);
    assertEquals(transactions, parsedTransactions);
    assertEquals(1, parsedPayment.getRefundToCount());
    assertEquals(MEMO, parsedPayment.getMemo());
    assertArrayEquals(MERCHANT_DATA, parsedPayment.getMerchantData().toByteArray());
}
 

import org.bitcoin.protocols.payments.Protos.Payment; //导入依赖的package包/类
@Test
public void testPaymentMessage() throws Exception {
    // Create
    List<Transaction> transactions = new LinkedList<>();
    transactions.add(FakeTxBuilder.createFakeTx(NETWORK_PARAMS, AMOUNT, TO_ADDRESS));
    Coin refundAmount = Coin.SATOSHI;
    Address refundAddress = new ECKey().toAddress(NETWORK_PARAMS);
    Payment payment = PaymentProtocol.createPaymentMessage(transactions, refundAmount, refundAddress, MEMO,
            MERCHANT_DATA);
    byte[] paymentBytes = payment.toByteArray();

    // Parse
    Payment parsedPayment = Payment.parseFrom(paymentBytes);
    List<Transaction> parsedTransactions = PaymentProtocol.parseTransactionsFromPaymentMessage(NETWORK_PARAMS,
            parsedPayment);
    assertEquals(transactions, parsedTransactions);
    assertEquals(1, parsedPayment.getRefundToCount());
    assertEquals(MEMO, parsedPayment.getMemo());
    assertArrayEquals(MERCHANT_DATA, parsedPayment.getMerchantData().toByteArray());
}
 

import org.bitcoin.protocols.payments.Protos.Payment; //导入依赖的package包/类
@Test
public void testPaymentAck() throws Exception {
    // Create
    Payment paymentMessage = Protos.Payment.newBuilder().build();
    PaymentACK paymentAck = PaymentProtocol.createPaymentAck(paymentMessage, MEMO);
    byte[] paymentAckBytes = paymentAck.toByteArray();

    // Parse
    PaymentACK parsedPaymentAck = PaymentACK.parseFrom(paymentAckBytes);
    assertEquals(paymentMessage, parsedPaymentAck.getPayment());
    assertEquals(MEMO, parsedPaymentAck.getMemo());
}
 

import org.bitcoin.protocols.payments.Protos.Payment; //导入依赖的package包/类
@Override
public void send(final Payment payment) {
    super.backgroundHandler.post(new Runnable() {
        @Override
        public void run() {
            log.info("trying to send tx to {}", url);

            final Request.Builder request = new Request.Builder();
            request.url(url);
            request.cacheControl(new CacheControl.Builder().noCache().build());
            request.header("Accept", PaymentProtocol.MIMETYPE_PAYMENTACK);
            if (userAgent != null)
                request.header("User-Agent", userAgent);
            request.post(new RequestBody() {
                @Override
                public MediaType contentType() {
                    return MediaType.parse(PaymentProtocol.MIMETYPE_PAYMENT);
                }

                @Override
                public long contentLength() throws IOException {
                    return payment.getSerializedSize();
                }

                @Override
                public void writeTo(final BufferedSink sink) throws IOException {
                    payment.writeTo(sink.outputStream());
                }
            });

            final Call call = Constants.HTTP_CLIENT.newCall(request.build());
            try {
                final Response response = call.execute();
                if (response.isSuccessful()) {
                    log.info("tx sent via http");

                    final InputStream is = response.body().byteStream();
                    final Protos.PaymentACK paymentAck = Protos.PaymentACK.parseFrom(is);
                    is.close();

                    final boolean ack = !"nack".equals(PaymentProtocol.parsePaymentAck(paymentAck).getMemo());

                    log.info("received {} via http", ack ? "ack" : "nack");

                    onResult(ack);
                } else {
                    final int responseCode = response.code();
                    final String responseMessage = response.message();

                    log.info("got http error {}: {}", responseCode, responseMessage);
                    onFail(R.string.error_http, responseCode, responseMessage);
                }
            } catch (final IOException x) {
                log.info("problem sending", x);

                onFail(R.string.error_io, x.getMessage());
            }
        }
    });
}
 

import org.bitcoin.protocols.payments.Protos.Payment; //导入依赖的package包/类
public abstract void send(Payment payment);