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