Dynamic Service Layer

import MyService from "./MyService";

export default class {
    start(bundleContext){
      // create the service instance
      let serviceInstance = new MyService();

      // define service metadata properties, usable to filter service instances
      let serviceProperties = {
        // because of some speed tests
        // now this service reacts on function calls in ~100ms
        "averageSpeedInMilliSeconds": 100
      };

      // the interface names provided by the service
      // you can also consider this as the names under which the service can be found in the registry
      let interfaces = ["interfacenamespace.MyServiceInterface"];

     this._serviceregistration = bundleContext.registerService(interfaces, serviceInstance, serviceProperties);
    }
}

export default class {
     ...
    stop(bundleContext){
      // get ServiceRegistration object (stored during service registration)
      let registration = this._serviceregistration;
      // clear the reference
      this._serviceregistration = null;
      // call unregister
      registration.unregister();
    }
}

export default class {
    ...
    amethod: function(){
      // get ServiceRegistration object (stored during service registration)
      let registration = this._serviceregistration;

      // update properties
      registration.setProperties({
        // some statistic calculations say here is a slow connection
        "averageSpeedInMilliSeconds": 1000
      });
    }
    ...
}

export default class {
    ...
    start(bundleContext){
      let matchingServiceReferences = bundleContext.getServiceReferences("interfacenamespace.MyServiceInterface");
      matchingServiceReferences.forEach((serviceReference)=>{
        console.debug("find service: " + serviceReference);
      });
    }
}

export default class {
    start(bundleContext){
      // look for MyServiceInterface providers, which react faster than 200 milliseconds
      var matchingServiceReferences = bundleContext.getServiceReferences("interfacenamespace.MyServiceInterface", "(averageSpeedInMilliSeconds<200)");
    }
}

export default class {
    start(bundleContext){
      let matchingServiceReferences = bundleContext.getServiceReferences("interfacenamespace.MyServiceInterface");
      matchingServiceReferences.forEach((serviceReference)=>{

        // access single property
        let speed = serviceReference.getProperty("averageSpeedInMilliSeconds");

        console.debug("find service: " + serviceReference + " it is very fast around: " + speed);

        // get property keys as array
        let keys = serviceReference.getPropertyKeys();

        // get all properties as object
        let props = serviceReference.getProperties();

        keys.forEach((key)=>{
          console.debug("key: " +key + " value: " + props[key]);
        });

        // get the bundle providing the service
        let serviceProviderBundle = serviceReference.getBundle();
        ...
      });
    }
}

export default class {
    start(bundleContext){
      // find possible service references
      let matchingServiceReferences = bundleContext.getServiceReferences("interfacenamespace.MyServiceInterface");

      // get first service reference
      let serviceReference = matchingServiceReferences[0];

      try{
        // get service instance
        let service = bundleContext.getService(serviceReference);
        // do something with the service
        ...
      }finally{
        // unget the service if it is no longer used
        bundleContext.ungetService(serviceReference);
      }
    }
}

import ServiceEvent from "apprt/ServiceEvent";
export default class {
    start(bundleContext){
      // register event listener function
      // without a filter it listens for any service event in the runtime
      this._serviceEventListenerHandle = bundleContext.addServiceListener(null,this._onServiceEvent,this);
    },
    stop : function(bundleContext){
      // unregister event listener
      bundleContext.removeServiceListener(this._serviceEventListenerHandle);
      this._serviceEventListenerHandle= null;
    },
    _onServiceEvent: function(evt){
      var types = ServiceEvent.types;
      var serviceReference = evt.getServiceReference();
      switch (evt.getType()){
        case types.REGISTERED:
        ...
        break;
        case types.UNREGISTERING:
        ...
        break;
        case types.MODIFIED:
        ...
        break;
      }
    }
}

export default class {
    start(bundleContext){
      // registers only for events of services with interface 'interfacenamespace.MyServiceInterface'
      this._serviceEventListenerHandle = bundleContext.addServiceListener("(objectClass=interfacenamespace.MyServiceInterface)",this._onServiceEvent,this);
    }
    _onServiceEvent(evt){
      ...
    }
}

import MyService from "./MyService";

export default class {
    start(bundleContext){
      ...
      // sample of registration of an inlined service factory
      this._serviceregistration = bundleContext.registerService(["my.Interface"], {

        getService(usingBundle,serviceregistration){
          // do something with the bundle information...
          // a MyService is created for each using bundle
          return new MyService();
        },

        ungetService(usingBundle,serviceregistration,instance){
          // do something with the bundle information...
          // clean up the instance resources
        }
      }
    }
}