学步园

/**
 * A simple demo service.
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public interface Demo {

    /**
     * Add two integers and return the result.
     * @param a
     * @param b
     * @return 
     */
    public int add(int a, int b);
}

/**
 * <b>Another</b> very simple demo service API.
 * <p>
 * The intentions of this interface class is to show that different bundles
 * will get different instances of a service, by the means of a 
 * ServiceFactory.
 * </p>
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public interface DemoFactory {

    /**
     * Say hello.
     */
    void hello();
}

import secondosgi.service.demo.Demo;

/**
 * Implementation of the Demo service.
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public class DemoImpl implements Demo {

    public int add(int a, int b) {
        return a + b;
    }
}

import secondosgi.service.demo.DemoFactory;
import org.osgi.framework.Bundle;

/**
 * Implementation of the DemoFactory service. The intentions of this
 * class is to show that different bundles will get different instances
 * of a service, by the means of a ServiceFactory.
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public class DemoFactoryImpl implements DemoFactory {

    private Bundle b;

    /**
     * Constructor with argument.
     * @param b a <code>Bundle</code> 
     */
    public DemoFactoryImpl(Bundle b) {
        this.b = b;
    }

    public void hello() {
        System.out.println("Hello bundle #" + b.getBundleId());
    }
}

import secondosgi.service.demo.Demo;
import secondosgi.service.demo.DemoFactory;
import java.util.Hashtable;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceFactory;
import org.osgi.framework.ServiceRegistration;

/**
 * Activator which creates and registers a Demo1 service.
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public class Activator implements BundleActivator {

    private Demo demo;

    public void start(BundleContext bc) {
        System.out.println("start " + getClass().getName());
        demo = new DemoImpl();
        bc.registerService(Demo.class.getName(),
                demo,
                new Hashtable());

        // Create a service factory for DemoFactory implementations
        ServiceFactory factory = new ServiceFactory() {

            Hashtable services = new Hashtable();
            // Will get called when a bundle request a service
            @SuppressWarnings("unchecked")
            public Object getService(Bundle b,
                    ServiceRegistration reg) {
                System.out.println("get from " + b.getBundleId());

                // Create when necessary
                DemoFactory impl = (DemoFactory) services.get(b);
                if (impl == null) {
                    impl = new DemoFactoryImpl(b);
                    services.put(b, impl);
                }
                return impl;
            }

            // will get called when a bundle ungets a service or stops
            public void ungetService(Bundle b,
                    ServiceRegistration reg,
                    Object service) {
                System.out.println("unget from " + b.getBundleId());
                services.remove(b);
            }
        };

        // Note how factory only implements ServiceFactory, 
        // but we still register as DemoFactory1 service
        bc.registerService(DemoFactory.class.getName(),
                factory,
                new Hashtable());
    }

    public void stop(BundleContext bc) {
        System.out.println("stop " + getClass().getName());

        demo = null;
    }
}

import secondosgi.service.demo.Demo;
import secondosgi.service.demo.DemoFactory;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;

/**
 * Activator which registers a listener for, and test, any Demo service.
 * @author 88250
 * @version 1.0.0.0, Feb 14, 2008
 */
public class Activator implements BundleActivator, ServiceListener {

    private static BundleContext bc;

    private ServiceListener listener;

    public void start(BundleContext bc) {
        System.out.println("start " + getClass().getName());
        Activator.bc = bc;

        try {
            // Filter that matches all Demo services
            String filter = "(objectclass=" + Demo.class.getName() + ")";

            // Fetch all registered Demo services
            // and test them manually
            ServiceReference[] srl =
                    bc.getServiceReferences(Demo.class.getName(), filter);
            for (int i = 0; srl != null && i < srl.length; i++) {
                testService(srl[i]);
            }

            // ...and catch all newly registed ones too.
            bc.addServiceListener(listener, filter);
        } catch (Exception e) {
            // sounds unlikely, but filter syntax errors are easy to write.
            e.printStackTrace();
        }

        testServiceFactory();
    }

    void testServiceFactory() {
        // Try to get a reference to the service produced by a factory
        ServiceReference factorySR = bc.getServiceReference(DemoFactory.class.getName());
        if (factorySR != null) {
            DemoFactory df = (DemoFactory) bc.getService(factorySR);
            if (df != null) {
                // Different bundles will get different printouts
                df.hello();
            }
        }
    }

    void testService(ServiceReference sr) {
        Demo demo = (Demo) bc.getService(sr);
        int r = demo.add(140, 1);

        System.out.println("Testing " + demo + ", result=" + r);

        // ..return the object to be nice
        bc.ungetService(sr);
    }

    public void stop(BundleContext bc) {
        System.out.println("stop " + getClass().getName());
        Activator.bc = null;
    }

    public void serviceChanged(ServiceEvent event) {
        ServiceReference sr = event.getServiceReference();

        // just print some info and call testService() on
        // all registered Demo services
        switch (event.getType()) {
            case ServiceEvent.REGISTERED:
                System.out.println("Got Demo service");
                testService(sr);
                break;
            case ServiceEvent.UNREGISTERING:
                System.out.println("Lost Demo service");
                break;
            case ServiceEvent.MODIFIED:
                System.out.println("Modified Demo service");
                break;
            default:
                break;
        }
    }
}