/** Registers/subscribes the application for receiving BPS pushes */
  public void registerBPSPush(
      final String appId, final String BPDSUri, final String contentUri, final String listenUri) {
    NonBlockingReceiverDestination listenDest = null;
    NonBlockingSenderDestination bpsServerDest = null;
    try {
      final MessageListener bpsListener = new DestinationListener("BPS", true);

      final InboundDestinationConfiguration config1 =
          InboundDestinationConfigurationFactory.createBPSConfiguration(
              true, true, false, appId, BPDSUri); // serverUrl

      listenDest =
          DestinationFactory.createNonBlockingReceiverDestination(
              config1, URI.create(listenUri), bpsListener);
      final MessageListener subscriptionListener = new SubscriptionResponseListener("Subscription");
      bpsServerDest =
          DestinationFactory.createNonBlockingSenderDestination(
              _context, URI.create(contentUri), subscriptionListener);

      final ByteMessage subscrMsg =
          BpsSubscriptionMessageBuilder.createByteSubscriptionMessage(
              bpsServerDest, listenDest, "user", "pwd");

      ((HttpMessage) subscrMsg).setQueryParam("field1", "xxxxx");
      ((HttpMessage) subscrMsg).setQueryParam("osversion", "6.0");
      bpsServerDest.send(subscrMsg);
    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
    public void run() {

      try {
        final Object lock = _responseListener.getLock();

        // Send message to retrieve the response
        if (_message == null) {

          ((NonBlockingSenderDestination) _destination).send();
        } else {
          ((NonBlockingSenderDestination) _destination).send(_message);
        }

        // Wait till a response is received by the message listener
        synchronized (lock) {
          try {
            lock.wait(TIMEOUT * 1000);
          } catch (final InterruptedException ex) {
            //
          }
        }

        if (_responseListener.isOnMessage()) {
          final Message responseMsg = _responseListener.getResponse();
          _responseCallback.updateUI(responseMsg);
        } else {
          _responseCallback.timeoutDialog(TIMEOUT);
        }

      } catch (final Exception e) {
        alertDialog(e.toString());
      } finally {
        if (_releaseDestination && _destination != null) {
          _destination.release();
        }
      }
    }
  /**
   * Sends cancellable/non-cancellable message and tries to cancel using destination.
   *
   * @param msgString Message string to be sent with the message
   * @param isCancellable True if message can be canceled, otherwise false
   */
  public void testMessageCancellable(final String msgString, final boolean isCancellable) {
    if (_cancellationDest == null) {
      // Check if destination is created
      alertDialog("Please register destination first!");
      return;
    }

    final ByteMessage msg = _cancellationDest.createByteMessage();

    try {
      msg.setStringPayload(msgString);
      msg.setCancellable(isCancellable); // Cancellable
      final int msgId = _cancellationDest.send(msg);
      _cancellationDest.cancel(msgId);
    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /*
   * Sends non-cancellable and cancellable messages, then tries to cancel them
   * on best effort.
   */
  public void testCancelAllCancellable() {
    try {
      if (_cancellationDest == null) // check if destination is created
      {
        alertDialog("Please register destination first!");
        return;
      }

      final int numMsg = 5; // number of messages to be sent

      final ByteMessage[] messages = new ByteMessage[numMsg];
      final int[] msgIds = new int[numMsg];

      // Create messages
      for (int i = 0; i < messages.length; i++) {
        messages[i] = _cancellationDest.createByteMessage();
        messages[i].setCancellable(true);
        messages[i].setStringPayload("Message " + i + "[cancellable]");
      }

      // Reset two first messages as non-cancellable
      messages[0].setCancellable(false);
      messages[0].setStringPayload("Message 0 [non-cancellable]");
      messages[1].setCancellable(false);
      messages[1].setStringPayload("Message 1 [non-cancellable]");

      // Send messages and read IDs
      for (int i = 0; i < messages.length; i++) {
        msgIds[i] = _cancellationDest.send(messages[i]);
      }

      // Use another method to cancel all
      _cancellationDest.cancelAllCancellable();

      // NOTE: If a message has already been sent, then it
      // can not be canceled.

    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }