my client source code looks like this:
----------------------------------------------------------------------------------------------------------------------------------------------------------
package pt.hello.client;
import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerManager;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.remoteservice.IRemoteCall;
import org.eclipse.ecf.remoteservice.IRemoteCallListener;
import org.eclipse.ecf.remoteservice.IRemoteService;
import org.eclipse.ecf.remoteservice.IRemoteServiceContainerAdapter;
import org.eclipse.ecf.remoteservice.IRemoteServiceReference;
import org.eclipse.ecf.remoteservice.events.IRemoteCallCompleteEvent;
import org.eclipse.ecf.remoteservice.events.IRemoteCallEvent;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.util.tracker.ServiceTracker;
import pt.hello.IHello;
/**
 * The activator class controls the plug-in life cycle
 */
public class Activator implements BundleActivator {
    public static final String ROSGI_SERVICE_HOST = 
"r-osgi://localhost:9279";
    private BundleContext context;
    private ServiceTracker containerManagerServiceTracker;
    private IContainer container;
    /*
     * (non-Javadoc)
     *
     * @see
     * 
org.eclipse.core.runtime.Plugins#start(org.osgi.framework.BundleContext)
     */
    public void start(BundleContext context) throws Exception {
        this.context = context;
        // 1. Create R-OSGi Container
        IContainerManager containerManager = getContainerManagerService();
        container = 
containerManager.getContainerFactory().createContainer(
                "ecf.r_osgi.peer");
        // 2. Get remote service container adapter
        IRemoteServiceContainerAdapter containerAdapter = 
(IRemoteServiceContainerAdapter) container
                .getAdapter(IRemoteServiceContainerAdapter.class);
        // 3. Lookup IRemoteServiceReference
        IRemoteServiceReference[] helloReferences = containerAdapter
                
.getRemoteServiceReferences(IDFactory.getDefault().createID(
                        container.getConnectNamespace(), 
ROSGI_SERVICE_HOST),
                        IHello.class.getName(), null);
        Assert.isNotNull(helloReferences);
        Assert.isTrue(helloReferences.length > 0);
        // 4. Get remote service for reference
        IRemoteService remoteService = containerAdapter
                .getRemoteService(helloReferences[0]);
        // 5. Get the proxy
        IHello proxy = (IHello) remoteService.getProxy();
        // 6. Finally...call the proxy
        proxy.hello("RemoteService Consumer");
    }
    IRemoteCall createRemoteCall() {
        return new IRemoteCall() {
            public String getMethod() {
                return "hello";
            }
            public Object[] getParameters() {
                return new Object[] { "Asynch RemoteService Consumer" };
            }
            public long getTimeout() {
                return 0;
            }
        };
    }
    IRemoteCallListener createRemoteCallListener() {
        return new IRemoteCallListener() {
            public void handleEvent(IRemoteCallEvent event) {
                if (event instanceof IRemoteCallCompleteEvent) {
                    IRemoteCallCompleteEvent cce = 
(IRemoteCallCompleteEvent) event;
                    if (!cce.hadException())
                        System.out
                                .println("Remote call completed 
successfully!");
                    else
                        System.out
                                .println("Remote call completed with 
exception: "
                                        + cce.getException());
                }
            }
        };
    }
    /*
     * (non-Javadoc)
     *
     * @see
     * 
org.eclipse.core.runtime.Plugin#stop(org.osgi.framework.BundleContext)
     */
    public void stop(BundleContext context) throws Exception {
        if (container != null) {
            container.disconnect();
            container = null;
        }
        if (containerManagerServiceTracker != null) {
            containerManagerServiceTracker.close();
            containerManagerServiceTracker = null;
        }
        this.context = null;
    }
    private IContainerManager getContainerManagerService() {
        if (containerManagerServiceTracker == null) {
            containerManagerServiceTracker = new ServiceTracker(context,
                    IContainerManager.class.getName(), null);
            containerManagerServiceTracker.open();
        }
        return (IContainerManager) 
containerManagerServiceTracker.getService();
    }
}
----------------------------------------------------------------------------------------------------------------------------------------------------------
my server side source code looks like this:
----------------------------------------------------------------------------------------------------------------------------------------------------------
package pt.hello.service;
import java.util.Properties;
import org.eclipse.ecf.osgi.services.distribution.IDistributionConstants;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import pt.hello.IHello;
public class Activator implements BundleActivator{
    private static final String containerType = "ecf.r_osgi.peer";
    public static final String DEFAULT_CONTAINER_ID = 
"r-osgi://localhost:9279";
    private String containerId = DEFAULT_CONTAINER_ID;
    private ServiceRegistration helloRegistration;
    /*
     * (non-Javadoc)
     * @see 
org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
     */
    @Override
    public void start(BundleContext context) throws Exception{
        registerHelloRemoteService(context);
        System.out.println("IHello RemoteService registered");
    }
    void registerHelloRemoteService(BundleContext context) {
        // Setup properties for remote service distribution, as per 
OSGi 4.2
        // remote services
        // specification (chap 13 in compendium spec)
        Properties props = new Properties();
        // add OSGi service property indicated export of all 
interfaces exposed
        // by service (wildcard)
        props.put(IDistributionConstants.SERVICE_EXPORTED_INTERFACES,
                
IDistributionConstants.SERVICE_EXPORTED_INTERFACES_WILDCARD);
        // add OSGi service property specifying config
        props.put(IDistributionConstants.SERVICE_EXPORTED_CONFIGS,
                containerType);
        // add ECF service property specifying container factory args
        props.put(
                
IDistributionConstants.SERVICE_EXPORTED_CONTAINER_FACTORY_ARGUMENTS,
                containerId);
        // register remote service
        helloRegistration = context.registerService(
                IHello.class.getName(), new HelloImpl(), props);
        // tell everyone
        System.out.println("Host: Hello Service Registered");
    }
    void unregisterHelloRemoteService() {
        if (helloRegistration != null) {
            helloRegistration.unregister();
            helloRegistration = null;
        }
        // tell everyone
        System.out.println("Host: Hello Remote Service Unregistered");
    }
    /*
     * (non-Javadoc)
     * @see 
org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
     */
    @Override
    public void stop(BundleContext context) throws Exception{}
}
i guess i am missing somthing... can someone direct me what i am doing 
wrong?