/** Destroys destination - should be executed when the app is uninstalled */
 public void destroyReceiver(final String uriStr) {
   try {
     final Destination dest = DestinationFactory.getReceiverDestination(URI.create(uriStr));
     if (dest != null) {
       dest.destroy();
     }
   } catch (final Exception e) {
     alertDialog(e.toString());
   }
 }
    /**
     * Sends get request and receives response using BlockingSenderDestination
     *
     * @see Thread#run()
     */
    public void run() {
      BlockingSenderDestination blockSendDest = null;
      try {
        blockSendDest =
            (BlockingSenderDestination)
                DestinationFactory.getSenderDestination(_context.getName(), URI.create(_uriStr));
        if (blockSendDest == null) {
          blockSendDest =
              DestinationFactory.createBlockingSenderDestination(_context, URI.create(_uriStr));
        }

        // Send message and wait for response
        _response = blockSendDest.sendReceive();

        if (_response != null) {
          _completed = true;

          // For "http"
          final String alertString =
              "received Message [id:"
                  + _response.getMessageId()
                  + "]\n"
                  + "Response Code: "
                  + ((HttpMessage) _response).getResponseCode();
          alertDialog(alertString);
        }
      } catch (final Exception e) {
        _completed = true;
        alertDialog(e.toString());
      } finally {
        if (blockSendDest != null) {
          blockSendDest.release();
        }
      }
    }
  /** 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());
    }
  }
  /**
   * Creates non-blocking receiver destination (IPC) for the URI and registers a listener.
   *
   * @param uriStr
   * @param autoStartEnabled Auto-start application on incoming messages
   */
  public void startNonBlockingReceiverIPC(final String uriStr, final boolean autoStartEnabled) {
    NonBlockingReceiverDestination nonBlockRecvDest = null;

    try {
      nonBlockRecvDest =
          (NonBlockingReceiverDestination)
              DestinationFactory.getReceiverDestination(URI.create(uriStr));

      if (nonBlockRecvDest == null) // Not registered yet
      {
        final SimpleListener responseListener = new SimpleListener("NonBlockingReceiverIPC");

        // Prepare the inbound destination for incoming
        // messages (Inter Process Communication).
        final InboundDestinationConfiguration config =
            InboundDestinationConfigurationFactory.createIPCConfiguration(
                autoStartEnabled, true, false);

        nonBlockRecvDest =
            DestinationFactory.createNonBlockingReceiverDestination(
                config, URI.create(uriStr), null, responseListener);
      }
    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /**
   * Creates receiver destination (BES) for the URI and registers a listener
   *
   * @param uriStr URI of the receiver destination
   * @param autoStartEnabled Auto start application on incoming messages
   */
  public void startNonBlockingReceiverBES(final String uriStr, final boolean autoStartEnabled) {
    NonBlockingReceiverDestination nonBlockRecvDest = null;
    try {
      nonBlockRecvDest =
          (NonBlockingReceiverDestination)
              DestinationFactory.getReceiverDestination(URI.create(uriStr));
      if (nonBlockRecvDest == null) // Not registered yet
      {
        final MessageListener responseListener =
            new DestinationListener("NonBlockingReceiverBES", true);

        // Prepare the in-bound destination for incoming messages
        // (BES/http)
        final InboundDestinationConfiguration config =
            InboundDestinationConfigurationFactory.createBESConfiguration(
                autoStartEnabled, true, false);

        nonBlockRecvDest =
            DestinationFactory.createNonBlockingReceiverDestination(
                config, URI.create(uriStr), responseListener);
      }
    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
    /** @see Thread#run() */
    public void run() {
      BlockingReceiverDestination blockRecvDest = null;
      try {
        blockRecvDest =
            (BlockingReceiverDestination)
                DestinationFactory.getReceiverDestination(URI.create(_uriStr));

        if (blockRecvDest == null) // Not registered yet
        {
          InboundDestinationConfiguration config;

          // Prepare the inbound destination for incoming messages
          if (_configType == InboundDestinationConfiguration.CONFIG_TYPE_BES) {
            config =
                InboundDestinationConfigurationFactory.createBESConfiguration(
                    _autoStartEnabled, true, false);
          } else if (_configType == InboundDestinationConfiguration.CONFIG_TYPE_IPC) {
            config =
                InboundDestinationConfigurationFactory.createIPCConfiguration(
                    _autoStartEnabled, true, false);
          } else {
            throw new IllegalArgumentException(
                "Invalid InboundDestinationConfiguration type! Implemented support of IPC and BES only.");
          }

          blockRecvDest =
              DestinationFactory.createBlockingReceiverDestination(config, URI.create(_uriStr));
        }

        String alertString = "";
        _response = blockRecvDest.receive(_timeout * 1000);

        if (_response != null) {
          alertString = "RECEIVED[id: " + _response.getMessageId() + "]:";
          final String stringPayload = ((ByteMessage) _response).getStringPayload();
          if (stringPayload != null) {
            alertString += "\n" + stringPayload;
          }
        } else {
          // No response received
          alertString = "No message has been received during timeout of " + _timeout + " sec.";
        }

        alertDialog(alertString);
      } catch (final Exception e) {
        alertDialog(e.toString());
      }
    }
  /**
   * Sends message to the URI using FireAndForget destination
   *
   * @param uriSenderStr Sender destination URI
   */
  public void sendFireForget(final String uriSenderStr) {
    FireAndForgetDestination fireForgetDest = null;
    try {
      fireForgetDest =
          (FireAndForgetDestination)
              DestinationFactory.getSenderDestination(_context.getName(), URI.create(uriSenderStr));

      if (fireForgetDest == null) {
        fireForgetDest =
            DestinationFactory.createFireAndForgetDestination(_context, URI.create(uriSenderStr));
      }
      final int msgId = fireForgetDest.sendNoResponse();

      alertDialog("Message [id:" + msgId + "] has been sent!");
    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /** Sets the destination. Used by message cancellation test. */
  public void setNonBlockingSenderDestination(final String uriStr) {
    final MessageListener responseListener = new DestinationListener("Cancellation Listener", true);

    try {
      final URI uri = URI.create(uriStr);
      SenderDestination destination =
          DestinationFactory.getSenderDestination(_context.getName(), uri);
      if (destination == null) {
        // Destination not registered yet
        destination =
            DestinationFactory.createNonBlockingSenderDestination(_context, uri, responseListener);
      }
      _cancellationDest = (NonBlockingSenderDestination) destination;

    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /**
   * Sends get request message using non-blocking destination and listens for the response in the
   * created listener.
   *
   * @param uriStr Uri where the request is sent to
   * @param releaseDestination Release destination on completion of the method
   * @param callback Callback object responsible for updating UI upon message delivery / request
   *     timeout
   */
  public void sendNonBlocking(
      final String uriStr, final boolean releaseDestination, final ResponseCallback callback) {
    MonitoredDestinationListener responseListener;

    try {
      final URI uri = URI.create(uriStr);

      responseListener =
          new MonitoredDestinationListener(
              "SendNonBlocking MessageListener [id: " + _listenerId++ + "]");
      final SenderDestination senderDestination =
          DestinationFactory.createNonBlockingSenderDestination(_context, uri, responseListener);

      final TimeoutMonitor timeoutThread =
          new TimeoutMonitor(senderDestination, releaseDestination, callback, responseListener);
      final Thread t1 = new Thread(timeoutThread, "monitor");
      t1.start();

    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /**
   * Uploads data in the form of streams to a server
   *
   * @param callback Callback object responsible for updating UI upon message delivery / request
   *     timeout
   */
  public void uploadStream(final String uploadUri, final ResponseCallback callback) {

    MonitoredDestinationListener responseListener;

    try {
      final URI uri = URI.create(uploadUri + ";deviceSide=true");

      responseListener =
          new MonitoredDestinationListener(
              "StreamData MessageListener [id: " + _listenerId++ + "]");
      final SenderDestination senderDestination =
          DestinationFactory.createNonBlockingSenderDestination(_context, uri, responseListener);

      // Create a byte array of size 10000
      final byte[] input = new byte[10000];
      for (int i = 0; i < input.length; i++) {
        input[i] = '5';
      }

      final ByteArrayInputStream bais = new ByteArrayInputStream(input);

      final StreamMessage message = senderDestination.createStreamMessage();
      ((HttpMessage) message).setMethod(HttpMessage.POST);

      message.setStreamPayload(bais);
      message.setPriority(2);
      message.setTransportHeader("Transfer-Encoding", "chunked");

      final TimeoutMonitor timeoutThread =
          new TimeoutMonitor(senderDestination, true, callback, responseListener, message);
      final Thread t1 = new Thread(timeoutThread, "monitor");

      t1.start();

    } catch (final Exception e) {
      alertDialog(e.toString());
    }
  }
  /**
   * Gets response from a URI which requires credentials
   *
   * @param callback Callback object responsible for updating UI upon message delivery / request
   *     timeout
   */
  public void authenticate(
      final String uriStr,
      final String username,
      final String password,
      final ResponseCallback callback) {
    MonitoredDestinationListener responseListener;

    try {
      final URI uri = URI.create(uriStr);
      final String user = username;
      final String pass = password;

      final CredentialsCollector credentialsCollector =
          new CredentialsCollector() {
            public UsernamePasswordCredentials getBasicAuthenticationCredentials(
                final String authenticatedEntityID, final Hashtable properties) {
              return new UsernamePasswordCredentials(user, pass);
            }
          };

      final Context context = new Context("Authenticate", credentialsCollector);

      responseListener =
          new MonitoredDestinationListener(
              "Authentification MessageListener [id: " + _listenerId++ + "]");
      final SenderDestination senderDestination =
          DestinationFactory.createNonBlockingSenderDestination(context, uri, responseListener);

      final TimeoutMonitor timeoutThread =
          new TimeoutMonitor(senderDestination, true, callback, responseListener);
      final Thread t1 = new Thread(timeoutThread, "monitor");
      t1.start();

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