/** 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());
}
}
/** 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 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());
}
}
/**
* 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());
}
}