/**
* 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.io;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.microedition.io.Connection;
import javax.microedition.io.ConnectionNotFoundException;
import javax.microedition.io.Connector;
import javax.microedition.io.InputConnection;
import javax.microedition.io.OutputConnection;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.service.io.ConnectionFactory;
import org.osgi.service.io.ConnectorService;
import org.osgi.util.tracker.ServiceTracker;
/**
* <p>
* The Connector Service should be called to create and open <code>javax.microedition.io.Connection</code> objects.
* </p>
*
* @see ConnectorService
* @version $Rev$ $Date$
*/
public class ConnectorServiceImpl implements ConnectorService
{
ServiceTracker m_connFactoryTracker;
/**
* Constructs new ConnectorService.
*
* @param context
* bundleContext @see {@link BundleContext}.
*/
public ConnectorServiceImpl(BundleContext context)
{
this.m_connFactoryTracker = new ServiceTracker(context, ConnectionFactory.class.getName(), null);
m_connFactoryTracker.open();
}
/**
* Stops ConnectorService. This method closes {@link ConnectionFactory} serviceTracker.
*
* @see ServiceTracker#close()
*/
public void stop()
{
m_connFactoryTracker.close();
}
/**
* @see org.osgi.service.io.ConnectorService#openDataInputStream(java.lang.String)
*/
public DataInputStream openDataInputStream(String name) throws IOException
{
Connection connection = open(name, READ, false);
if (!(connection instanceof InputConnection))
{
try
{
connection.close();
} catch (IOException ioex)
{
}
throw new IOException("Connection doesn't implement InputConnection" + connection.getClass());
}
return ((InputConnection) connection).openDataInputStream();
}
/**
* @see org.osgi.service.io.ConnectorService#openDataOutputStream(java.lang.String)
*/
public DataOutputStream openDataOutputStream(String name) throws IOException
{
Connection connection = open(name, WRITE, false);
if (!(connection instanceof OutputConnection))
{
try
{
connection.close();
} catch (IOException ioex)
{
}
throw new IOException("Connection doesn't implement OutputConnection" + connection.getClass());
}
return ((OutputConnection) connection).openDataOutputStream();
}
/**
* @see org.osgi.service.io.ConnectorService#openInputStream(java.lang.String)
*/
public InputStream openInputStream(String name) throws IOException
{
Connection connection = open(name, READ, false);
if (!(connection instanceof InputConnection))
{
try
{
connection.close();
} catch (IOException ioex)
{
}
throw new IOException("Connection doesn't implement InputConnection" + connection.getClass());
}
return ((InputConnection) connection).openInputStream();
}
/**
* @see org.osgi.service.io.ConnectorService#openOutputStream(java.lang.String)
*/
public OutputStream openOutputStream(String name) throws IOException
{
Connection connection = open(name, WRITE, false);
if (!(connection instanceof OutputConnection))
{
try
{
connection.close();
} catch (IOException ioex)
{
}
throw new IOException("Connection doesn't implement OutputConnection" + connection.getClass());
}
return ((OutputConnection) connection).openOutputStream();
}
/**
* @see org.osgi.service.io.ConnectorService#open(String)
*/
public Connection open(String name) throws IOException
{
return open(name, READ_WRITE, false);
}
/**
* @see org.osgi.service.io.ConnectorService#open(String, int)
*/
public Connection open(String name, int mode) throws IOException
{
return open(name, mode, false);
}
/**
* @see org.osgi.service.io.ConnectorService#open(String, int, boolean)
*/
public Connection open(String name, int mode, boolean timeouts) throws IOException
{
if (name == null)
{
throw new IllegalArgumentException("URI for the connection can't be null!");
}
// resolving scheme name
int index = name.indexOf(":");
if (index == -1)
{
throw new IllegalArgumentException("Can't resolve scheme name");
}
String scheme = name.substring(0, index);
ConnectionFactory connFactory = resolveConnectionFactory(scheme);
Connection connection = null;
if (connFactory != null)
{
connection = connFactory.createConnection(name, mode, timeouts);
}
// if connection is not provided go to javax.microedition.io.Connector
if (connection == null)
{
try
{
connection = Connector.open(name, mode, timeouts);
} catch (Exception ex)
{
}
} else
{
return connection;
}
throw new ConnectionNotFoundException("Failed to create connection " + name);
}
/**
* <p>
* Resolves {@link ConnectionFactory} based on IO scheme name. If multiple ConnectionFactory services register with
* the same scheme, method select the ConnectionFactory with highest value for service.ranking service registration
* property or if more than one ConnectionFactory service has the highest value, the ConnectionFactory service with
* the lowest service.id is selected.
* </p>
*
* @param scheme
* name of IO scheme.
* @return {@link ConnectionFactory} which matched provided scheme.
*/
private ConnectionFactory resolveConnectionFactory(String scheme)
{
ServiceReference[] references = m_connFactoryTracker.getServiceReferences();
if (references == null || references.length == 0)
{
return null;
}
ServiceReference matchingRef = null;
for (int i = 0; i < references.length; i++)
{
if (containsScheme(references[i], scheme))
{
if (matchingRef != null)
{
int matchRanking = getServiceRanking(matchingRef);
int foundRanking = getServiceRanking(references[i]);
if (foundRanking > matchRanking)
{
matchingRef = references[i];
} else if (foundRanking == matchRanking && compareServiceId(references[i], matchingRef))
{
matchingRef = references[i];
}
} else
{
matchingRef = references[i];
}
}
}
if (matchingRef != null)
{
return (ConnectionFactory) m_connFactoryTracker.getService(matchingRef);
}
return null;
}
/**
* Checks if provided {@link ServiceReference} contains in its service properties provided scheme name.
*
* @param ref
* {@link ServiceReference}.
* @param scheme
* name of IO scheme.
* @return true if contains scheme name, false if not.
*/
private boolean containsScheme(ServiceReference ref, String scheme)
{
Object property = ref.getProperty(ConnectionFactory.IO_SCHEME);
if (property != null && property.equals(scheme))
{
return true;
} else
{
if (property != null && property instanceof String[])
{
String[] schemes = (String[]) property;
for (int index = 0; index < schemes.length; index++)
{
if (schemes[index].equals(scheme))
{
return true;
}
}
}
}
return false;
}
/**
* Compare service.id of two {@link ServiceReference}'s.
*
* @param foundRef
* {@link ServiceReference}.
* @param prevRef
* {@link ServiceReference}.
* @return true if first reference has lowest service.id than second, false if not.
*/
private boolean compareServiceId(ServiceReference foundRef, ServiceReference prevRef)
{
Long foundServiceId = (Long) foundRef.getProperty(Constants.SERVICE_ID);
Long prevServiceId = (Long) prevRef.getProperty(Constants.SERVICE_ID);
if (foundServiceId.longValue() < prevServiceId.longValue())
{
return true;
}
return false;
}
/**
* Gets service.ranking from provided {@link ServiceReference}.
*
* @param ref
* {@link ServiceReference}.
* @return service.ranking property value.
*/
private int getServiceRanking(ServiceReference ref)
{
Object property = ref.getProperty(Constants.SERVICE_RANKING);
if (property == null || !(property instanceof Integer))
{
return 0;
} else
{
return ((Integer) property).intValue();
}
}
}