diff --git a/dependencymanager/runtime/doc/changelog.txt b/dependencymanager/runtime/doc/changelog.txt
index 7f3eb61..e52d2fb 100644
--- a/dependencymanager/runtime/doc/changelog.txt
+++ b/dependencymanager/runtime/doc/changelog.txt
@@ -6,6 +6,8 @@
 ** Improvement
     * Removed root changelog.txt
     * [FELIX-2954 ] - annotated component factory does not allow to provide a component instance explicitly
+    * [FELIX-2966] - Annotations should automatically generate Import-Service/Export-Service headers
+    * [FELIX-2965] - Annotations should allow to enable or disable auto-configuration mode.
 
 Initial Release 3.0.0
 ---------------------
diff --git a/dependencymanager/runtime/pom.xml b/dependencymanager/runtime/pom.xml
index 3dbe065..ffe4a27 100644
--- a/dependencymanager/runtime/pom.xml
+++ b/dependencymanager/runtime/pom.xml
@@ -27,7 +27,7 @@
     </properties>
     <name>Apache Felix Dependency Manager Runtime</name>
     <artifactId>org.apache.felix.dependencymanager.runtime</artifactId>
-    <version>3.0.1-SNAPSHOT</version>
+    <version>3.1.0-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <dependencies>
         <dependency>
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
index 5c6d453..2127c8e 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AbstractBuilder.java
@@ -18,12 +18,16 @@
  */
 package org.apache.felix.dm.runtime;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 
 import org.apache.felix.dm.Component;
+import org.apache.felix.dm.ComponentStateListener;
 import org.apache.felix.dm.Dependency;
 import org.apache.felix.dm.DependencyManager;
 import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
 
 /**
  * Base class for all kind of DM component builders (for Component, Aspect, Adapters ...).
@@ -49,18 +53,51 @@
     /**
      * Sets common Service parameters, if provided from our Component descriptor
      */
-    protected void setCommonServiceParams(Component service, MetaData serviceMetaData)
+    protected void setCommonServiceParams(Component c, MetaData srvMeta)
         throws Exception
     {
-        String init = serviceMetaData.getString(Params.init, null);
-        String start = serviceMetaData.getString(Params.start, null);
-        String stop = serviceMetaData.getString(Params.stop, null);
-        String destroy = serviceMetaData.getString(Params.destroy, null);
-        service.setCallbacks(init, start, stop, destroy);
-        String composition = serviceMetaData.getString(Params.composition, null);
-        if (composition != null)
+        // Set auto configured component fields.
+        DependencyManager dm = c.getDependencyManager();
+        boolean autoConfigureComponents =
+                "true".equals(dm.getBundleContext().getProperty(Activator.CONF_ENABLE_AUTOCONFIG));
+
+        if (!autoConfigureComponents)
         {
-            service.setComposition(composition);
+            c.setAutoConfig(BundleContext.class, Boolean.FALSE);
+            c.setAutoConfig(ServiceRegistration.class, Boolean.FALSE);
+            c.setAutoConfig(DependencyManager.class, Boolean.FALSE);
+            c.setAutoConfig(Component.class, Boolean.FALSE);
+        }
+
+        // See if BundleContext must be auto configured.
+        String bundleContextField = srvMeta.getString(Params.bundleContextField, null);
+        if (bundleContextField != null)
+        {
+            c.setAutoConfig(BundleContext.class, bundleContextField);
+        }
+
+        // See if DependencyManager must be auto configured.
+        String dependencyManagerField = srvMeta.getString(Params.dependencyManagerField, null);
+        if (dependencyManagerField != null)
+        {
+            c.setAutoConfig(DependencyManager.class, dependencyManagerField);
+        }
+
+        // See if Component must be auto configured.
+        String componentField = srvMeta.getString(Params.componentField, null);
+        if (componentField != null)
+        {
+            c.setAutoConfig(Component.class, componentField);
+        }
+        
+        // Now, if the component has a @Started annotation, then add our component state listener,
+        // which will callback the corresponding annotated method, once the component is started.
+        String registered = srvMeta.getString(Params.registered, null);
+        String unregistered = srvMeta.getString(Params.unregistered, null);
+
+        if (registered != null || unregistered != null)
+        {
+            c.addStateListener(new RegistrationListener(registered, unregistered));
         }
     }
     
@@ -85,4 +122,68 @@
             }
         }
     }
+    
+    static class RegistrationListener implements ComponentStateListener
+    {
+        private final String m_registered;
+        private String m_unregistered;
+
+        RegistrationListener(String registered, String unregistered)
+        {
+            m_registered = registered;
+            m_unregistered = unregistered;
+        }
+        
+        public void starting(Component c)
+        {
+            // No need to invoke any callback here, since it is the ServiceLifecycleHandler
+            // that will invoke the method annotated with @Start
+        }
+
+        public void started(Component c)
+        {
+            if (m_registered != null)
+            {
+                Object instance = c.getService();
+                try
+                {
+                    InvocationUtil
+                        .invokeCallbackMethod(instance,
+                                              m_registered, 
+                                              new Class[][]  {{ ServiceRegistration.class },  {}},
+                                              new Object[][] {{ c.getServiceRegistration() }, {}});
+                }
+                catch (Throwable t)
+                {
+                    Log.instance().error("Exception caught while invoking method %s on component %s", t, m_registered, instance);
+                }
+            }
+        }
+
+        public void stopping(Component c)
+        {
+            // No need to invoke any callback here, since it is the ServiceLifecycleHandler
+            // that will invoke the method annotated with @Stop
+        }
+
+        public void stopped(Component c)
+        {
+            if (m_unregistered != null)
+            {
+                Object instance = c.getService();
+                try
+                {
+                    InvocationUtil
+                        .invokeCallbackMethod(instance,
+                                              m_unregistered, 
+                                              new Class[][]  {{}},
+                                              new Object[][] {{}});
+                }
+                catch (Throwable t)
+                {
+                    Log.instance().error("Exception caught while invoking method %s on component %s", t, m_registered, instance);
+                }
+            }
+        }
+    }
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
index 0ee0bc3..26fe7ef 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Activator.java
@@ -35,7 +35,17 @@
  */
 public class Activator extends DependencyActivatorBase
 {
-    private final static String CONF_LOG = "dm.runtime.log";
+    /**
+     * Name of bundle context property telling if log service is required or not.
+     * (default = false)
+     */
+    final static String CONF_LOG = "dm.runtime.log";
+    
+    /**
+     * Name of bundle context property telling if Components must be auto configured
+     * with BundleContext/ServiceRegistration etc .. (default = false) 
+     */
+    final static String CONF_ENABLE_AUTOCONFIG = "dm.runtime.autoconfig";
     
     /**
      * Initialize our DependencyManager Runtime service.
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
index 2c6a9d5..3b9f807 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AdapterServiceBuilder.java
@@ -64,42 +64,43 @@
             throw new IllegalArgumentException("missing added callback");
         }
         
-        Component service;
+        Component c;
         
         if (field != null)
         {
-            service = dm.createAdapterService(adapteeService, adapteeFilter, field);
+            c = dm.createAdapterService(adapteeService, adapteeFilter, field);
         }
         else
         {
             if (added != null)
             {
-                service = dm.createAdapterService(adapteeService, adapteeFilter, added, changed, removed);
+                c = dm.createAdapterService(adapteeService, adapteeFilter, added, changed, removed);
 
             }
             else
             {
-                service = dm.createAdapterService(adapteeService, adapteeFilter);
+                c = dm.createAdapterService(adapteeService, adapteeFilter);
             }
         }
         
-        service.setInterface(provides, adapterProperties);
+        setCommonServiceParams(c, srvMeta);
+        c.setInterface(provides, adapterProperties);
         
         String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
         if (factoryMethod == null)
         {
-            service.setImplementation(adapterImplClass);
+            c.setImplementation(adapterImplClass);
         } 
         else
         {
-            service.setFactory(adapterImplClass, factoryMethod);
+            c.setFactory(adapterImplClass, factoryMethod);
         }
-        service.setComposition(srvMeta.getString(Params.composition, null));
-        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
+        c.setComposition(srvMeta.getString(Params.composition, null));
+        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
         // The dependencies will be plugged by our lifecycle handler.
-        service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+        c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
         // Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
-        addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
-        dm.add(service);
+        addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+        dm.add(c);
     }
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
index f73099a..de4520b 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/AspectServiceBuilder.java
@@ -69,47 +69,45 @@
             throw new IllegalArgumentException("missing added callback");
         }
 
-        Component service;
+        Component c;
         if (field != null)
         {
-            service =
-                    dm.createAspectService(serviceInterface, serviceFilter, ranking, field)
-                            .setServiceProperties(aspectProperties);
+            c = dm.createAspectService(serviceInterface, serviceFilter, ranking, field)
+                  .setServiceProperties(aspectProperties);
         } 
         else
         {
             if (added != null)
             {
-                service =
-                    dm.createAspectService(serviceInterface, serviceFilter, ranking, added, changed, removed)
-                        .setServiceProperties(aspectProperties);
+                c = dm.createAspectService(serviceInterface, serviceFilter, ranking, added, changed, removed)
+                      .setServiceProperties(aspectProperties);
             } 
             else
             {
-                service =
-                    dm.createAspectService(serviceInterface, serviceFilter, ranking)
-                        .setServiceProperties(aspectProperties);
+                c = dm.createAspectService(serviceInterface, serviceFilter, ranking)
+                      .setServiceProperties(aspectProperties);
             }
  
         }
         
+        setCommonServiceParams(c, srvMeta);
         String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
         if (factoryMethod == null)
         {
-            service.setImplementation(implClass);
+            c.setImplementation(implClass);
         }
         else
         {
-            service.setFactory(implClass, factoryMethod);
+            c.setFactory(implClass, factoryMethod);
         }
 
-        service.setComposition(srvMeta.getString(Params.composition, null));
-        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
+        c.setComposition(srvMeta.getString(Params.composition, null));
+        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
         // The dependencies will be plugged by our lifecycle handler.
-        service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+        c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
         // Adds dependencies (except named dependencies, which are managed by the lifecycle
         // handler).
-        addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
-        dm.add(service);
+        addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+        dm.add(c);
     }
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
index a093c01..94f8e62 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/BundleAdapterServiceBuilder.java
@@ -51,24 +51,25 @@
         String[] provides = srvMeta.getStrings(Params.provides, null);
         Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
         boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
-        Component srv = dm.createBundleAdapterService(stateMask, filter, propagate);
-        srv.setInterface(provides, properties);
+        Component c = dm.createBundleAdapterService(stateMask, filter, propagate);
+        c.setInterface(provides, properties);
         String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
         if (factoryMethod == null)
         {
-            srv.setImplementation(adapterImplClass);
+            c.setImplementation(adapterImplClass);
         } 
         else
         {
-            srv.setFactory(adapterImplClass, factoryMethod);
+            c.setFactory(adapterImplClass, factoryMethod);
         }
 
-        srv.setComposition(srvMeta.getString(Params.composition, null));
-        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+        setCommonServiceParams(c, srvMeta);
+        c.setComposition(srvMeta.getString(Params.composition, null));
+        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
         // The dependencies will be plugged by our lifecycle handler.
-        srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+        c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
         // Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
-        addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
-        dm.add(srv);
+        addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+        dm.add(c);
     }    
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
index 9068005..aa0d60f 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ComponentBuilder.java
@@ -26,6 +26,8 @@
 import org.apache.felix.dm.Component;
 import org.apache.felix.dm.DependencyManager;
 import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
 
 /**
  * Builds a DependencyManager Component.
@@ -47,10 +49,13 @@
     public void build(MetaData srvMeta, List<MetaData> depsMeta, Bundle b, DependencyManager dm)
         throws Exception
     {
-        Component service = dm.createComponent();
+        Component c = dm.createComponent();
         String factory = srvMeta.getString(Params.factorySet, null);
 
-        // Check if we must provide a Set Factory.
+        // Setup Component auto config fields
+        setCommonServiceParams(c, srvMeta);
+        
+        // Check if we must provide a Component factory set.
         if (factory == null)
         {
             Log.instance().info("ComponentBuilder: building service %s with dependencies %s",
@@ -62,26 +67,26 @@
             String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
             if (factoryMethod == null)
             {
-                service.setImplementation(b.loadClass(impl));
+                c.setImplementation(b.loadClass(impl));
             }
             else
             {
-                service.setFactory(b.loadClass(impl), factoryMethod);
+                c.setFactory(b.loadClass(impl), factoryMethod);
             }
-            service.setComposition(composition);
+            c.setComposition(composition);
 
             // Adds dependencies (except named dependencies, which are managed by the lifecycle
             // handler).
-            addUnamedDependencies(b, dm, service, srvMeta, depsMeta);
+            addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
             // Creates a ServiceHandler, which will filter all service lifecycle callbacks.
             ServiceLifecycleHandler lfcleHandler =
-                    new ServiceLifecycleHandler(service, b, dm, srvMeta, depsMeta);
-            service.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+                    new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
+            c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
 
             // Set the provided services
             Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
             String[] services = srvMeta.getStrings(Params.provides, null);
-            service.setInterface(services, properties);
+            c.setInterface(services, properties);
         }
         else
         {
@@ -94,13 +99,13 @@
             // This Set will act as a factory and another component may registers some
             // service configurations into it in order to fire some service instantiations.
             FactorySet factorySet = new FactorySet(b, srvMeta, depsMeta);
-            service.setImplementation(factorySet);
-            service.setCallbacks(null, "start", "stop", null);
+            c.setImplementation(factorySet);
+            c.setCallbacks(null, "start", "stop", null);
             Hashtable<String, String> props = new Hashtable<String, String>();
             props.put(DM_FACTORY_NAME, factory);
-            service.setInterface(Set.class.getName(), props);
+            c.setInterface(Set.class.getName(), props);
         }
 
-        dm.add(service);
+        dm.add(c);
     }
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
index 2576c75..0f4eb09 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactoryConfigurationAdapterServiceBuilder.java
@@ -51,23 +51,24 @@
         String[] provides = srvMeta.getStrings(Params.provides, null);
         Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
         boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
-        Component srv = dm.createFactoryConfigurationAdapterService(factoryPid, updated, propagate);
-        srv.setInterface(provides, properties);
+        Component c = dm.createFactoryConfigurationAdapterService(factoryPid, updated, propagate);
+        c.setInterface(provides, properties);
         String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
         if (factoryMethod == null)
         {
-            srv.setImplementation(implClass);
+            c.setImplementation(implClass);
         } 
         else
         {
-            srv.setFactory(implClass, factoryMethod);
+            c.setFactory(implClass, factoryMethod);
         }
-        srv.setComposition(srvMeta.getString(Params.composition, null));
-        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+        setCommonServiceParams(c, srvMeta);
+        c.setComposition(srvMeta.getString(Params.composition, null));
+        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
         // The dependencies will be plugged by our lifecycle handler.
-        srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+        c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
         // Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
-        addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
-        dm.add(srv);
+        addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+        dm.add(c);
     }    
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
index a035c1e..8241b6d 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/FactorySet.java
@@ -81,9 +81,9 @@
     private List<MetaData> m_depsMeta;
 
     /**
-     * The DependencyManager (injected by reflection), which is used to create Service instances.
+     * The DependencyManager which is used to create Service instances.
      */
-    private DependencyManager m_dm; // Injected
+    private DependencyManager m_dm;
 
     /**
      * This class is used to serialize concurrent method calls, and allow to leave our methods unsynchronized.
@@ -173,9 +173,10 @@
     /**
      * Our Service is starting. 
      */
-    public void start()
+    public void start(Component c)
     {
         m_active = true;
+        m_dm = c.getDependencyManager();
     }
 
     /**
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
index 5cee9d6..7f0637f 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/Params.java
@@ -57,5 +57,10 @@
     name,
     field,
     starter,
-    stopper
+    stopper, 
+    bundleContextField, 
+    dependencyManagerField, 
+    componentField,
+    registered, 
+    unregistered
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
index 2e99dd2..7174396 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ResourceAdapterServiceBuilder.java
@@ -51,23 +51,24 @@
         Dictionary<String, Object> properties = srvMeta.getDictionary(Params.properties, null);
         boolean propagate = "true".equals(srvMeta.getString(Params.propagate, "false"));
         String changed = srvMeta.getString(Params.changed, null /* no change callback if not specified explicitly */);
-        Component srv = dm.createResourceAdapterService(filter, propagate, null, changed);
-        srv.setInterface(provides, properties);
+        Component c = dm.createResourceAdapterService(filter, propagate, null, changed);
+        c.setInterface(provides, properties);
         String factoryMethod = srvMeta.getString(Params.factoryMethod, null);
         if (factoryMethod == null)
         {
-            srv.setImplementation(implClass);
+            c.setImplementation(implClass);
         } 
         else
         {
-            srv.setFactory(implClass, factoryMethod);
+            c.setFactory(implClass, factoryMethod);
         }
-        srv.setComposition(srvMeta.getString(Params.composition, null));
-        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(srv, b, dm, srvMeta, depsMeta);
+        setCommonServiceParams(c, srvMeta);
+        c.setComposition(srvMeta.getString(Params.composition, null));
+        ServiceLifecycleHandler lfcleHandler = new ServiceLifecycleHandler(c, b, dm, srvMeta, depsMeta);
         // The dependencies will be plugged by our lifecycle handler.
-        srv.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
+        c.setCallbacks(lfcleHandler, "init", "start", "stop", "destroy");
         // Adds dependencies (except named dependencies, which are managed by the lifecycle handler).
-        addUnamedDependencies(b, dm, srv, srvMeta, depsMeta);
-        dm.add(srv);
+        addUnamedDependencies(b, dm, c, srvMeta, depsMeta);
+        dm.add(c);
     }    
 }
diff --git a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
index b25485f..90ff707 100644
--- a/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
+++ b/dependencymanager/runtime/src/main/java/org/apache/felix/dm/runtime/ServiceLifecycleHandler.java
@@ -332,17 +332,16 @@
     /**
      * Invoke a callback on an Object instance.
      */
-    private Object invokeMethod(Object serviceInstance, String method, DependencyManager dm, Component service)
+    private Object invokeMethod(Object serviceInstance, String method, DependencyManager dm, Component c)
         throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
     {
         if (method != null)
         {
             try
             {
-                return InvocationUtil.invokeCallbackMethod(
-                                                           serviceInstance, method,
+                return InvocationUtil.invokeCallbackMethod(serviceInstance, method,
                                                            new Class[][] { { Component.class }, {} },
-                                                           new Object[][] { { service }, {} }
+                                                           new Object[][] { { c }, {} }
                     );
             }