/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.eventadmin.bridge.upnp;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventAdmin;
import org.osgi.service.event.EventConstants;
import org.osgi.service.event.EventHandler;
import org.osgi.service.upnp.UPnPDevice;
import org.osgi.service.upnp.UPnPEventListener;
import org.osgi.service.upnp.UPnPService;
/**
* This class registers itself as an UPnPEventListener service with the
* framework whenever both, at least one EventAdmin and at least one
* EventHandler is present and subsequently, bridges UPnPEvents received to the
* EventAdmin service. In order to track EventAdmin services this class
* registers a ServiceListener for EventAdmin services as well as a
* ServiceListener for EventHandlers in order to determine EventHandler
* availability.
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class UPnPEventToEventAdminBridge implements UPnPEventListener
{
private static final String EVENT_HANDLER_FILTER = "(&("
+ Constants.OBJECTCLASS + "=" + EventHandler.class.getName() + ")(|("
+ EventConstants.EVENT_TOPIC + "=\\*)(" + EventConstants.EVENT_TOPIC
+ "=org/\\*)(" + EventConstants.EVENT_TOPIC + "=org/osgi/\\*)("
+ EventConstants.EVENT_TOPIC + "=org/osgi/service/\\*)("
+ EventConstants.EVENT_TOPIC + "=org/osgi/service/upnp/\\*)("
+ EventConstants.EVENT_TOPIC + "=org/osgi/service/upnp/UPnPEvent)))";
final Object m_lock = new Object();
// The references to the EventAdmins
final Set m_adminRefs = new HashSet();
// The references to the EventHandlers
final Set m_handlerRefs = new HashSet();
private final BundleContext m_context;
private ServiceRegistration m_reg = null;
/**
* This class registers itself as an UPnPEventListener service with the
* framework whenever both, at least one EventAdmin and at least one
* EventHandler is present and subsequently, bridges UPnPEvents received to
* the EventAdmin service. In order to track EventAdmin services this class
* registers a ServiceListener for EventAdmin services as well as a
* ServiceListener for EventHandlers in order to determine EventHandler
* availability.
*
* @param context
* The context to register with.
*/
public UPnPEventToEventAdminBridge(final BundleContext context)
{
synchronized(m_lock)
{
m_context = context;
try
{
m_context.addServiceListener(new ServiceListener()
{
public void serviceChanged(final ServiceEvent event)
{
synchronized(m_lock)
{
switch(event.getType())
{
case ServiceEvent.REGISTERED:
m_adminRefs
.add(event.getServiceReference());
break;
case ServiceEvent.UNREGISTERING:
m_adminRefs.remove(event
.getServiceReference());
break;
}
check();
}
}
}, "(" + Constants.OBJECTCLASS + "="
+ EventAdmin.class.getName() + ")");
final ServiceReference[] adminRefs = m_context
.getServiceReferences(EventAdmin.class.getName(), null);
if(null != adminRefs)
{
for(int i = 0; i < adminRefs.length; i++)
{
m_adminRefs.add(adminRefs[i]);
}
}
m_context.addServiceListener(new ServiceListener()
{
public void serviceChanged(final ServiceEvent event)
{
synchronized(m_lock)
{
switch(event.getType())
{
case ServiceEvent.REGISTERED:
m_handlerRefs.add(event
.getServiceReference());
break;
case ServiceEvent.UNREGISTERING:
m_handlerRefs.remove(event
.getServiceReference());
break;
}
check();
}
}
}, EVENT_HANDLER_FILTER);
final ServiceReference[] handlerRefs = m_context
.getServiceReferences(EventHandler.class.getName(),
EVENT_HANDLER_FILTER);
if(null != handlerRefs)
{
for(int i = 0; i < handlerRefs.length; i++)
{
m_handlerRefs.add(handlerRefs[i]);
}
}
} catch(InvalidSyntaxException e)
{
// This will never happen
}
check();
}
}
// The set contains the last used filter parts. It will be null in case the
// last
// time we registered with a null property. It will be an empty HashSet in
// case we have been unregistered previously
private Set last = new HashSet();
// Registers itself as an UPnPEventListener with the framework in case there
// is both, at least one EventAdmin (i.e., !m_adminRefs.isEmpty()) and at
// least one EventHandler (i.e., !m_handlerRefs.isEmpty()) present and it is
// not already registers. Respectively, it unregisters itself in case one of
// the above is false.
void check()
{
// do we need to be registered?
if(m_adminRefs.isEmpty() || m_handlerRefs.isEmpty())
{
// no we don't but do we need to unregister?
if(null != m_reg)
{
// yes
m_reg.unregister();
m_reg = null;
last = new HashSet();
}
}
else
// yes we need to be registered
{
final Set parts = new HashSet();
final StringBuffer result = new StringBuffer().append("(|");
for(Iterator iter = m_handlerRefs.iterator(); iter.hasNext();)
{
final String filter = (String) ((ServiceReference) iter.next())
.getProperty(EventConstants.EVENT_FILTER);
// if any filter is not set we need to register with a null and
// can
// return
if(null == filter)
{
// but only if we are not currently registered with a null
if(last != null)
{
last = null;
change(null);
}
return;
}
// if we don't already have this filter part we need to check if
// it is a valid filter
if(!parts.contains(filter))
{
try
{
m_context.createFilter(filter);
parts.add(filter);
result.append(filter);
} catch(InvalidSyntaxException e)
{
// and it is not a valid filter - hence, drop it
e.printStackTrace();
}
}
}
// parts will only be empty if there is no handler with a valid
// filter and we only need to register with the new filter if it
// doesn't equals the last filter
if(!parts.isEmpty() && !parts.equals(last))
{
last = parts;
try
{
final Hashtable properties = new Hashtable();
properties.put(UPnPEventListener.UPNP_FILTER,
m_context.createFilter(replaceAll(replaceAll(
result.append(")").toString().toCharArray(),
serviceChars, UPnPService.ID).toCharArray(),
deviceChars, UPnPDevice.ID)));
change(properties);
} catch(InvalidSyntaxException e)
{
// This will never happen
e.printStackTrace();
}
}
}
}
private static final char[] serviceChars = new char[]{'u','p','n','p','.','s','e','r','v','i','c','e','i','d'};
private static final char[] deviceChars = new char[]{'u','p','n','p','.','d','e','v','i','c','e','i','d'};
private String replaceAll(final char[] source, final char[] pattern, final String target)
{
StringBuffer result = new StringBuffer();
int pos = 0, matchPos = 0;
while(true)
{
if(pattern[matchPos] == Character.toLowerCase(source[pos]))
{
matchPos++;
if(matchPos == pattern.length)
{
result.append(target);
matchPos = 0;
}
}
else if(matchPos > 0 )
{
result.append(source, pos - matchPos, matchPos + 1);
matchPos = 0;
}
else
{
result.append(source[pos]);
}
pos++;
if(pos >= source.length)
{
if(matchPos > 0)
{
result.append(source, pos - matchPos, matchPos);
}
break;
}
}
return result.toString();
}
private void change(final Dictionary filter)
{
if(null == m_reg)
{
m_reg = m_context.registerService(
UPnPEventListener.class.getName(), this, filter);
}
else
{
m_reg.setProperties(filter);
}
}
/**
* Bridge any event to the EventAdmin service.
*
* @param deviceId
* Bridged to <tt>upnp.deviceId</tt>
* @param serviceId
* Bridged to <tt>upnp.serviceId</tt>
* @param events
* Bridged to <tt>upnp.events</tt>
*
* @see org.osgi.service.upnp.UPnPEventListener#notifyUPnPEvent(java.lang.String,
* java.lang.String, java.util.Dictionary)
*/
public void notifyUPnPEvent(final String deviceId, final String serviceId,
final Dictionary events)
{
final ServiceReference ref = m_context
.getServiceReference(EventAdmin.class.getName());
if(null != ref)
{
final EventAdmin eventAdmin = (EventAdmin) m_context
.getService(ref);
if(null != eventAdmin)
{
final Dictionary immutableEvents = new Dictionary()
{
public int size()
{
return events.size();
}
public boolean isEmpty()
{
return events.isEmpty();
}
public Enumeration keys()
{
return events.keys();
}
public Enumeration elements()
{
return events.elements();
}
public Object get(Object arg0)
{
return events.get(arg0);
}
public Object put(Object arg0, Object arg1)
{
throw new IllegalStateException(
"Event Properties may not be changed");
}
public Object remove(Object arg0)
{
throw new IllegalStateException(
"Event Properties may not be changed");
}
public boolean equals(Object arg0)
{
return events.equals(arg0);
}
public int hashCode()
{
return events.hashCode();
}
public String toString()
{
return events.toString();
}
};
final Hashtable properties = new Hashtable();
properties.put(UPnPDevice.ID, deviceId);
properties.put(UPnPService.ID, serviceId);
properties.put("upnp.serviceId", serviceId);
properties.put("upnp.deviceId", deviceId);
properties.put("upnp.events", immutableEvents);
eventAdmin.postEvent(
new Event("org/osgi/service/upnp/UPnPEvent", properties));
m_context.ungetService(ref);
}
}
}
}