/** add a ServiceListener to this ServiceBroker Context * */
public void addServiceListener(final ServiceListener sl) {
if (sl == null) throw new IllegalArgumentException("Add of null ServiceListener");
ServiceListener slp;
if (sl instanceof ServiceAvailableListener) {
slp =
new ServiceAvailableListener() {
public void serviceAvailable(ServiceAvailableEvent ae) {
((ServiceAvailableListener) sl)
.serviceAvailable(
new ServiceAvailableEvent(DelegatingServiceBroker.this, ae.getService()));
}
};
} else if (sl instanceof ServiceRevokedListener) {
slp =
new ServiceRevokedListener() {
public void serviceRevoked(ServiceRevokedEvent ae) {
((ServiceRevokedListener) sl)
.serviceRevoked(
new ServiceRevokedEvent(DelegatingServiceBroker.this, ae.getService()));
}
};
} else {
throw new IllegalArgumentException(
"DelegatingServiceBroker cannot delegate this listener: " + sl);
}
synchronized (listeners) {
listeners.put(sl, slp);
}
delegate.addServiceListener(slp);
}
public void updateNotification() {
if (!Preferences.isNotificationEnabled() || !playServicesAvailable) return;
String title = null;
String subtitle = null;
long time = 0;
if ((this.lastPublishedLocation != null) && Preferences.isNotificationLocationEnabled()) {
time = this.lastPublishedLocationTime.getTime();
if ((this.lastPublishedLocation.getGeocoder() != null)
&& Preferences.isNotificationGeocoderEnabled()) {
title = this.lastPublishedLocation.toString();
} else {
title = this.lastPublishedLocation.toLatLonString();
}
} else {
title = this.context.getString(R.string.app_name);
}
subtitle =
ServiceLocator.getStateAsString(this.context)
+ " | "
+ ServiceBroker.getStateAsString(this.context);
notificationBuilder.setContentTitle(title);
notificationBuilder
.setSmallIcon(R.drawable.ic_notification)
.setContentText(subtitle)
.setPriority(android.support.v4.app.NotificationCompat.PRIORITY_MIN);
if (time != 0) notificationBuilder.setWhen(this.lastPublishedLocationTime.getTime());
this.notification = notificationBuilder.build();
this.context.startForeground(Defaults.NOTIFCATION_ID, this.notification);
}
/** remove a services listener * */
public void removeServiceListener(ServiceListener sl) {
if (sl == null) throw new IllegalArgumentException("Remove of null ServiceListener");
ServiceListener slp;
synchronized (listeners) {
slp = (ServiceListener) listeners.get(sl);
if (slp != null) {
listeners.remove(sl);
}
}
if (slp != null) {
delegate.removeServiceListener(slp);
}
}
public void revokeService(
Class serviceClass,
ServiceProvider serviceProvider,
int providerId,
ComponentDescription providerDesc) {
if (delegate instanceof ExtendedServiceBroker) {
ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
esb.revokeService(
serviceClass, serviceProvider,
providerId, providerDesc);
} else {
delegate.revokeService(serviceClass, serviceProvider);
}
}
public boolean addService(
Class serviceClass,
ServiceProvider serviceProvider,
int providerId,
ComponentDescription providerDesc) {
if (delegate instanceof ExtendedServiceBroker) {
ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
return esb.addService(
serviceClass, serviceProvider,
providerId, providerDesc);
} else {
return delegate.addService(serviceClass, serviceProvider);
}
}
public List<?> fullText(RestSearchKey restSearchKey)
throws InvalidCriteriaException, NoDataFoundException, ServiceNotFoundException {
if (ftSearchType == null) throw new ServiceNotFoundException("Null Full Text Search Type");
SearchDao searchDao = serviceBroker.findBean(ftSearchType, SearchDao.class);
List<?> result = searchDao.read(restSearchKey, modelClass);
if (result == null || result.size() == 0)
throw new NoDataFoundException("Nothing matches your key");
return result;
}
public void releaseService(
int requestorId,
ComponentDescription requestorDesc,
Object requestor,
Class serviceClass,
Object service,
boolean recordInView) {
if (delegate instanceof ExtendedServiceBroker) {
ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
esb.releaseService(
requestorId, requestorDesc, requestor, serviceClass, service, recordInView);
} else {
delegate.releaseService(requestor, serviceClass, service);
}
}
public ServiceResult getService(
int requestorId,
ComponentDescription requestorDesc,
Object requestor,
Class serviceClass,
ServiceRevokedListener srl,
boolean recordInView) {
if (delegate instanceof ExtendedServiceBroker) {
ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
return esb.getService(requestorId, requestorDesc, requestor, serviceClass, srl, recordInView);
} else {
Object service = delegate.getService(requestor, serviceClass, srl);
return (service == null ? (null) : new ServiceResult(0, null, service));
}
}
public void BrokerRouterConstruct() {
// attributes
double available = 60; // available time for broker
double startTime = 0.5;
double bandwidth = 10; // bandwidth for the network or router
// Ceate an unique component
Broker = new ServiceBroker("Broker", available, startTime);
Router = new ServiceRouter("Router Link", bandwidth);
Broker.setBackgroundColor(Color.YELLOW);
Router.setBackgroundColor(Color.PINK);
BrokerList.add(Broker);
RouterList.add(Router);
}
public void releaseService(Object requestor, Class serviceClass, Object service) {
delegate.releaseService(requestor, serviceClass, service);
}
/**
* get an instance of the requested service from a service provider associated with this context.
*/
public <T> T getService(
Object requestor, final Class<T> serviceClass, final ServiceRevokedListener srl) {
return delegate.getService(requestor, serviceClass, srl);
}
/**
* gets the currently available services for this context. This version copies the keyset to keep
* the iterator safe.
*/
public Iterator getCurrentServiceClasses() {
return delegate.getCurrentServiceClasses();
}
/** is the service currently available? * */
public boolean hasService(Class serviceClass) {
return delegate.hasService(serviceClass);
}
