# HG changeset patch # User fturovic # Date 1265658802 21600 # Node ID c9573e1f3013f41743b22b6c63deca4c802a65b3 # Parent 53470a491c0bbb1de650ad999897ef39bcaa71be# Parent 3a0c0b389d0d2bd9de5fd1a675b7d20a1c5cc788 daily merge diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService.java Mon Feb 08 13:53:22 2010 -0600 @@ -34,6 +34,9 @@ import java.util.HashMap; import java.util.Map; +/** + @deprecated use AbstractConnectedService2 + */ public abstract class AbstractConnectedService implements IConnectedService2 { public final static int TIMEOUT = 2000; diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService2.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService2.java Mon Feb 08 13:53:22 2010 -0600 @@ -0,0 +1,223 @@ +/* +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ +package com.nokia.carbide.remoteconnections.interfaces; + +import java.lang.reflect.InvocationTargetException; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.jface.operation.IRunnableContext; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.jface.wizard.WizardDialog; +import org.eclipse.swt.widgets.Display; + +import com.nokia.carbide.remoteconnections.Messages; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus.EStatus; +import com.nokia.carbide.remoteconnections.internal.ServiceTester; +import com.nokia.carbide.remoteconnections.internal.api.IConnectedService2; +import com.nokia.cpp.internal.api.utils.core.Check; +import com.nokia.cpp.internal.api.utils.core.ListenerList; +import com.nokia.cpp.internal.api.utils.core.ObjectUtils; + +/** + * @since 2.5 + */ +public abstract class AbstractConnectedService2 implements IConnectedService2 { + + public final static int TIMEOUT = 2000; + + public static class ConnectionFailException extends Exception { + public ConnectionFailException(String string) { + super(string); + } + + private static final long serialVersionUID = -5438012263174866437L; + } + + public class Status implements IStatus { + private volatile EStatus estatus; + private String shortDescription; + private String longDescription; + + public IConnectedService getConnectedService() { + return AbstractConnectedService2.this; + } + + public EStatus getEStatus() { + return internalGetEStatus(); + } + + protected EStatus internalGetEStatus() { + if (estatus == null) + estatus = EStatus.UNKNOWN; + return estatus; + } + + public String getLongDescription() { + return longDescription; + } + + public String getShortDescription() { + return shortDescription; + } + + public void setEStatus(EStatus estatus, String shortDescription, String longDescription) { + // if everything is the same don't fire status changed + if (estatus.equals(this.estatus) && + ObjectUtils.equals(shortDescription, this.shortDescription) && + ObjectUtils.equals(longDescription, this.longDescription)) + return; + this.estatus = estatus; + this.shortDescription = shortDescription; + this.longDescription = longDescription; + fireStatusChanged(); + } + } + + public static class TestResult { + public TestResult(EStatus estatus, String shortDescription, String longDescription) { + this.estatus = estatus; + this.shortDescription = shortDescription; + this.longDescription = longDescription; + } + private EStatus estatus; + private String shortDescription; + private String longDescription; + } + + protected abstract TestResult runTestStatus(IProgressMonitor monitor); + + protected IService service; + protected AbstractSynchronizedConnection connection; + private ListenerList listeners; + protected IRunnableContext runnableContext; + protected Status currentStatus; + protected boolean externalTesting; + private Map properties; + + public AbstractConnectedService2(IService service, AbstractSynchronizedConnection connection) { + this.service = service; + this.connection = connection; + properties = new HashMap(); + } + + public void setRunnableContext(IRunnableContext runnableContext) { + this.runnableContext = runnableContext; + } + + public void addStatusChangedListener(IStatusChangedListener listener) { + if (listeners == null) + listeners = new ListenerList(); + listeners.add(listener); + } + + public void dispose() { + if (listeners != null) { + for (IStatusChangedListener listener : listeners) { + listeners.remove(listener); + } + } + ServiceTester.getInstance().unregister(this); + } + + public IService getService() { + return service; + } + + protected void fireStatusChanged() { + if (listeners != null) { + for (IStatusChangedListener listener : listeners) { + listener.statusChanged(getStatus()); + } + } + } + + public void removeStatusChangedListener(IStatusChangedListener listener) { + if (listeners != null) + listeners.remove(listener); + } + + public IConnection getConnection() { + return connection; + } + + public void testStatus() { + if (!(isEnabled() || externalTesting)) + return; + + final TestResult result[] = { null }; + if (runnableContext != null && (!(runnableContext instanceof WizardDialog) || ((WizardDialog) runnableContext).getShell() != null)) { + Display.getDefault().syncExec(new Runnable() { + public void run() { + try { + runnableContext.run(true, false, new IRunnableWithProgress() { + public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { + result[0] = runTestStatus(monitor); + } + }); + } catch (InvocationTargetException e) { + } catch (InterruptedException e) { + } + } + }); + } + else { + result[0] = runTestStatus(new NullProgressMonitor()); + } + + if (!(isEnabled() || externalTesting)) // could be waiting for response past when service testing was disabled + return; + if (result[0].shortDescription != null && result[0].longDescription != null) { + currentStatus.setEStatus(result[0].estatus, result[0].shortDescription, result[0].longDescription); + } + } + + public void setExternalTesting() { + externalTesting = true; + } + + public boolean isEnabled() { + return ServiceTester.getInstance().isRegistered(this); + } + + public void setEnabled(boolean enabled) { + if (!service.isTestable()) + return; + if (enabled && !isEnabled()) { + Check.checkState(connection.getSettings() != null); + ServiceTester.getInstance().register(this); + } + else if (!enabled && isEnabled()) { + ServiceTester.getInstance().unregister(this); + currentStatus.setEStatus(EStatus.UNKNOWN, + Messages.getString("AbstractConnectedService.NoTestingLabel"), //$NON-NLS-1$ + Messages.getString("AbstractConnectedService.UserDisabledMessage")); //$NON-NLS-1$ + } + } + + public Map getProperties() { + return properties; + } + + public void setStatus(Status status) { + if (currentStatus == null) + currentStatus = new Status(); + currentStatus.setEStatus(status.internalGetEStatus(), status.getShortDescription(), status.getLongDescription()); + } +} \ No newline at end of file diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractSynchronizedConnection.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractSynchronizedConnection.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractSynchronizedConnection.java Mon Feb 08 13:53:22 2010 -0600 @@ -100,4 +100,8 @@ } setInUse(use); } + + public Object getCurrentResource() { + return getCurrentResourceString(); + } } diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IClientServiceSiteUI2.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IClientServiceSiteUI2.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IClientServiceSiteUI2.java Mon Feb 08 13:53:22 2010 -0600 @@ -31,7 +31,7 @@ * the identifier manually by iterating the {@link IConnectionsManager#getConnections()}! * @noimplement * @noextend - * @since 3.0 + * @since 2.5 */ public interface IClientServiceSiteUI2 { diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IConnectionsManager.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IConnectionsManager.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/IConnectionsManager.java Mon Feb 08 13:53:22 2010 -0600 @@ -42,6 +42,14 @@ } /** + * Return value for IConnectionsManager.ensureConnection + */ + public interface ISelectedConnectionInfo { + IConnection getConnection(); + String getStorableId(); + } + + /** * Internal method for loading connections from persisted state * @deprecated */ @@ -56,7 +64,7 @@ /** * Listener interface for connections which are added, removed and set as current - * @since 3.0 + * @since 2.5 */ public interface IConnectionListener { void connectionAdded(IConnection connection); @@ -143,28 +151,28 @@ /** * Add new IConnectionListener * @param listener IConnectionListener - * @since 3.0 + * @since 2.5 */ void addConnectionListener(IConnectionListener listener); /** * Remove IConnectionListener * @param listener IConnectionListener - * @since 3.0 + * @since 2.5 */ void removeConnectionListener(IConnectionListener listener); /** * Sets the current connection. * @param connection IConnection - * @since 3.0 + * @since 2.5 */ void setCurrentConnection(IConnection connection); /** * Returns the current connection. * @return IConnection - * @since 3.0 + * @since 2.5 */ IConnection getCurrentConnection(); @@ -175,7 +183,7 @@ * when you use #ensureConenction(). * @param service IService * @return IClientServiceSiteUI2 - * @since 3.0 + * @since 2.5 */ IClientServiceSiteUI2 getClientSiteUI2(IService service); @@ -183,15 +191,18 @@ * Can be called by specific service implementors (e.g., debugger) to ensure some connection * exists and supports this service. If the connection does not exist or does not support * the service, a CoreException may be thrown after the framework attempts to allow the user - * to correct the situation. If an IConnection is returned, it is assumed to be - * a valid connection in the system that supports the service. + * to correct the situation by showing a connection selection dialog. + * If an ISelectedConnectionInfo is returned, {@link ISelectedConnectionInfo#getConnection()} + * is assumed to be a valid connection in the system that supports the service + * and {@link ISelectedConnectionInfo#getStorableId()} is the id that can + * be stored by the caller that represents the user's selection. * @param connectionId String * @param service IService - * @return IConnection + * @return ISelectedConnectionInfo * @throws CoreException - * @since 3.0 + * @since 2.5 */ - IConnection ensureConnection(String connectionId, IService service) throws CoreException; + ISelectedConnectionInfo ensureConnection(String connectionId, IService service) throws CoreException; /** * Returns a connection from an id (including the current connection id) or null if none found. @@ -199,7 +210,7 @@ * @param service IService * @return IConnection * @throws CoreException - * @since 3.0 + * @since 2.5 */ IConnection findConnection(String connectionId); @@ -209,7 +220,7 @@ * is in use by some client service, and is eventually removed from the system once it is * no longer in use. * @param connection IConnection2 - * @since 3.0 + * @since 2.5 */ void disconnect(IConnection2 connection); @@ -218,7 +229,7 @@ * If the connection has not been removed from the system, and is still in-use, * it will be restored. Returns true if successful in restoring the connection. * @param connection IConnection2 - * @since 3.0 + * @since 2.5 */ boolean reconnect(IConnection2 connection); } \ No newline at end of file diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/ServiceTester.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/ServiceTester.java Mon Feb 08 13:53:22 2010 -0600 @@ -0,0 +1,198 @@ +/** +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +package com.nokia.carbide.remoteconnections.internal; + +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService2; +import com.nokia.carbide.remoteconnections.interfaces.AbstractSynchronizedConnection; +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService2.Status; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus; + + +public class ServiceTester { + + public class TestRunner extends Thread { + private final Collection> connectedServicesSets; + + public TestRunner(Collection> connectedServicesSets) { + this.connectedServicesSets = connectedServicesSets; + } + + @Override + public void run() { + for (Set connectedServices : connectedServicesSets) { + // test first in the set and set status for others + Iterator iterator = connectedServices.iterator(); + AbstractConnectedService2 toTest = iterator.next(); + toTest.testStatus(); + IStatus status = toTest.getStatus(); + while (iterator.hasNext()) { + AbstractConnectedService2 next = iterator.next(); + next.setStatus((Status) status); + } + } + unregisterThread(this); + } + + @Override + public synchronized void start() { + registerThread(this); + super.start(); + } + + public boolean contains(AbstractConnectedService2 connectedService) { + for (Set csSet : connectedServicesSets) { + if (csSet.contains(connectedService)) + return true; + } + + return false; + } + + } + + public interface IEquivalence { + Object getRelation(AbstractConnectedService2 cs); + } + + private static ServiceTester instance; + + private Set registry; + private Set runningThreads; + + public static ServiceTester getInstance() { + if (instance == null) + instance = new ServiceTester(); + return instance; + } + + private ServiceTester() { + registry = new HashSet(); + runningThreads = new HashSet(); + Thread t = new Thread(new Runnable() { + public void run() { + while (true) { + Collection> csSetsByResource = + createConnectedServiceSetsByResource(registry); + for (Set set : csSetsByResource) { + Collection> csSetsByService = + createConnectedServiceSetsByService(set); + runTests(csSetsByService); + } + try { + Thread.sleep(AbstractConnectedService2.TIMEOUT); + } catch (InterruptedException e) { + } + } + } + }); + t.start(); + } + + private void runTests(Collection> csSetsByResource) { + if (isRunningTest(csSetsByResource)) + return; + + if (csSetsByResource.isEmpty()) + return; + + TestRunner runner = new TestRunner(csSetsByResource); + runner.start(); + + } + + private Collection> partition( + Set connectedServices, IEquivalence equivalence) { + Map> collatedConnectedServiceSetMap = + new HashMap>(); + for (AbstractConnectedService2 cs : connectedServices) { + Object object = equivalence.getRelation(cs); + if (object == null) + continue; + if (!collatedConnectedServiceSetMap.containsKey(object)) + collatedConnectedServiceSetMap.put(object, new HashSet()); + collatedConnectedServiceSetMap.get(object).add(cs); + } + return collatedConnectedServiceSetMap.values(); + } + + private Collection> createConnectedServiceSetsByResource(Set connectedServices) { + return partition(connectedServices, new IEquivalence() { + public Object getRelation(AbstractConnectedService2 cs) { + AbstractSynchronizedConnection connection = (AbstractSynchronizedConnection) cs.getConnection(); + if (connection != null) + return connection.getCurrentResource(); + + return null; + } + }); + } + + protected Collection> createConnectedServiceSetsByService(Set connectedServices) { + return partition(connectedServices, new IEquivalence() { + public Object getRelation(AbstractConnectedService2 cs) { + return cs.getService(); + } + }); + } + + public void register(AbstractConnectedService2 connectedService) { + registry.add(connectedService); + } + + public boolean isRegistered(AbstractConnectedService2 connectedService) { + return registry.contains(connectedService); + } + + public void unregister(AbstractConnectedService2 connectedService) { + registry.remove(connectedService); + } + + public synchronized void registerThread(TestRunner testRunner) { + runningThreads.add(testRunner); + } + + public synchronized void unregisterThread(TestRunner testRunner) { + runningThreads.remove(testRunner); + } + + public synchronized boolean isRunningTest(Collection> csSetsByResource) { + for (Set set : csSetsByResource) { + for (AbstractConnectedService2 cs : set) { + if (isRunningTest(cs)) + return true; + } + } + return false; + } + + private boolean isRunningTest(AbstractConnectedService2 cs) { + for (TestRunner runner : runningThreads) { + if (runner.contains(cs)) + return true; + } + + return false; + } +} diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnectedService2.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnectedService2.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnectedService2.java Mon Feb 08 13:53:22 2010 -0600 @@ -23,7 +23,7 @@ /** * An extended interface to a connected service - * @since 3.0 + * @since 2.5 */ public interface IConnectedService2 extends IConnectedService { diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnection2.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnection2.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IConnection2.java Mon Feb 08 13:53:22 2010 -0600 @@ -23,7 +23,7 @@ /** * An extended interface to a connection - * @since 3.0 + * @since 2.5 */ public interface IConnection2 extends IConnection { diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IDeviceDiscoveryAgent.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IDeviceDiscoveryAgent.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/api/IDeviceDiscoveryAgent.java Mon Feb 08 13:53:22 2010 -0600 @@ -23,7 +23,7 @@ /** * An interface to a device discovery agent - * @since 3.0 + * @since 2.5 */ public interface IDeviceDiscoveryAgent { diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/registry/Registry.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/registry/Registry.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/internal/registry/Registry.java Mon Feb 08 13:53:22 2010 -0600 @@ -515,21 +515,30 @@ } } - public IConnection ensureConnection(String id, IService service) throws CoreException { + public ISelectedConnectionInfo ensureConnection(String id, IService service) throws CoreException { Check.checkArg(service); - IConnection connection = findConnection(id); - if (!isCompatibleConnection(connection, service)) { - connection = getCompatibleConnectionFromUser(service); - if (connection == null) { + final IConnection[] connectionHolder = { findConnection(id) }; + final String[] storableIdHolder = { id }; + if (!isCompatibleConnection(connectionHolder[0], service)) { + connectionHolder[0] = getCompatibleConnectionFromUser(service, storableIdHolder); + if (connectionHolder[0] == null) { throw new CoreException( Logging.newStatus(RemoteConnectionsActivator.getDefault(), IStatus.ERROR, Messages.getString("Registry.NoCompatibleConnectionMsg"))); //$NON-NLS-1$ } } - return connection; + return new ISelectedConnectionInfo() { + public String getStorableId() { + return storableIdHolder[0]; + } + + public IConnection getConnection() { + return connectionHolder[0]; + } + }; } - private IConnection getCompatibleConnectionFromUser(final IService service) { + private IConnection getCompatibleConnectionFromUser(final IService service, final String[] storableIdHolder) { final IConnection[] connectionHolder = { null }; if (!WorkbenchUtils.isJUnitRunning()) { Display.getDefault().syncExec(new Runnable() { @@ -589,8 +598,10 @@ } }; dialog.setBlockOnOpen(true); - if (dialog.open() == Dialog.OK) - connectionHolder[0] = findConnection(ui.getSelectedConnection()); + if (dialog.open() == Dialog.OK) { + storableIdHolder[0] = ui.getSelectedConnection(); + connectionHolder[0] = findConnection(storableIdHolder[0]); + } } }); } diff -r 53470a491c0b -r c9573e1f3013 connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/settings/ui/ConnectionSettingsPage.java --- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/settings/ui/ConnectionSettingsPage.java Mon Feb 08 13:52:37 2010 -0600 +++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/settings/ui/ConnectionSettingsPage.java Mon Feb 08 13:53:22 2010 -0600 @@ -78,7 +78,7 @@ import com.nokia.carbide.remoteconnections.Messages; import com.nokia.carbide.remoteconnections.RemoteConnectionsActivator; -import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService; +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService2; import com.nokia.carbide.remoteconnections.interfaces.IConnectedService; import com.nokia.carbide.remoteconnections.interfaces.IConnection; import com.nokia.carbide.remoteconnections.interfaces.IConnectionFactory; @@ -105,12 +105,12 @@ public final class Tester extends Thread { @Override public void run() { - ((AbstractConnectedService) connectedService).setManualTesting(); + ((AbstractConnectedService2) connectedService).setExternalTesting(); for (int i = 0; i < 3 && connectedService != null; i++) { connectedService.testStatus(); try { if (i < 2) - sleep(AbstractConnectedService.TIMEOUT); + sleep(AbstractConnectedService2.TIMEOUT); } catch (InterruptedException e) { break; } @@ -678,8 +678,8 @@ }); } }); - if (connectedService instanceof AbstractConnectedService) { - ((AbstractConnectedService) connectedService).setRunnableContext(getContainer()); + if (connectedService instanceof AbstractConnectedService2) { + ((AbstractConnectedService2) connectedService).setRunnableContext(getContainer()); tester = new Tester(); tester.start(); } diff -r 53470a491c0b -r c9573e1f3013 debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/ConnectedServiceFactory.java --- a/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/ConnectedServiceFactory.java Mon Feb 08 13:52:37 2010 -0600 +++ b/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/ConnectedServiceFactory.java Mon Feb 08 13:53:22 2010 -0600 @@ -18,12 +18,20 @@ package com.nokia.carbide.trk.support.service; -import com.nokia.carbide.remoteconnections.interfaces.*; -import com.nokia.carbide.trk.support.connection.*; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; + +import com.nokia.carbide.remoteconnections.interfaces.AbstractSynchronizedConnection; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedServiceFactory; +import com.nokia.carbide.remoteconnections.interfaces.IConnection; +import com.nokia.carbide.remoteconnections.interfaces.IService; +import com.nokia.carbide.trk.support.connection.SerialBTConnectionType; +import com.nokia.carbide.trk.support.connection.SerialConnectionType; +import com.nokia.carbide.trk.support.connection.USBConnectionType; import com.nokia.cpp.internal.api.utils.core.HostOS; -import java.util.*; - /** * */ diff -r 53470a491c0b -r c9573e1f3013 debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TRKConnectedService.java --- a/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TRKConnectedService.java Mon Feb 08 13:52:37 2010 -0600 +++ b/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TRKConnectedService.java Mon Feb 08 13:53:22 2010 -0600 @@ -27,7 +27,7 @@ import org.osgi.framework.Version; import com.freescale.cdt.debug.cw.core.SerialConnectionSettings; -import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService; +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService2; import com.nokia.carbide.remoteconnections.interfaces.AbstractSynchronizedConnection; import com.nokia.carbide.remoteconnections.interfaces.IConnectionType; import com.nokia.carbide.remoteconnections.interfaces.IService; @@ -51,7 +51,7 @@ /** * */ -public class TRKConnectedService extends AbstractConnectedService { +public class TRKConnectedService extends AbstractConnectedService2 { public static final String PROP_SYS_TRK = "is-system-trk"; //$NON-NLS-1$ diff -r 53470a491c0b -r c9573e1f3013 debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TracingConnectedService.java --- a/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TracingConnectedService.java Mon Feb 08 13:52:37 2010 -0600 +++ b/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/TracingConnectedService.java Mon Feb 08 13:53:22 2010 -0600 @@ -18,22 +18,33 @@ package com.nokia.carbide.trk.support.service; -import com.freescale.cdt.debug.cw.core.SerialConnectionSettings; -import com.nokia.carbide.remoteconnections.interfaces.*; -import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus.EStatus; -import com.nokia.carbide.trk.support.Messages; -import com.nokia.carbide.trk.support.connection.*; -import com.nokia.cpp.internal.api.utils.core.Check; -import com.nokia.tcf.api.*; +import java.io.IOException; +import java.text.MessageFormat; +import java.util.Arrays; import org.eclipse.core.runtime.IProgressMonitor; import org.osgi.framework.Version; -import java.io.IOException; -import java.text.MessageFormat; -import java.util.Arrays; +import com.freescale.cdt.debug.cw.core.SerialConnectionSettings; +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService2; +import com.nokia.carbide.remoteconnections.interfaces.AbstractSynchronizedConnection; +import com.nokia.carbide.remoteconnections.interfaces.IConnectionType; +import com.nokia.carbide.remoteconnections.interfaces.IService; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus.EStatus; +import com.nokia.carbide.trk.support.Messages; +import com.nokia.carbide.trk.support.connection.TCPIPConnectionFactory; +import com.nokia.carbide.trk.support.connection.TCPIPConnectionType; +import com.nokia.carbide.trk.support.connection.USBConnectionType; +import com.nokia.cpp.internal.api.utils.core.Check; +import com.nokia.tcf.api.ITCAPIConnection; +import com.nokia.tcf.api.ITCConnection; +import com.nokia.tcf.api.ITCMessage; +import com.nokia.tcf.api.ITCMessageIds; +import com.nokia.tcf.api.ITCMessageInputStream; +import com.nokia.tcf.api.ITCMessageOptions; +import com.nokia.tcf.api.TCFClassFactory; -public class TracingConnectedService extends AbstractConnectedService { +public class TracingConnectedService extends AbstractConnectedService2 { private static final String OK_STATUS = Messages.getString("TracingConnectedService.OKStatus"); //$NON-NLS-1$