com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService.java Source code

Introduction

Here is the source code for com.nokia.carbide.remoteconnections.interfaces.AbstractConnectedService.java

Source

/*
* Copyright (c) 2009 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 com.nokia.carbide.remoteconnections.Messages;
import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus.EStatus;
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;

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 java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

/**
 @deprecated use AbstractConnectedService2
 */
public abstract class AbstractConnectedService 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 = -5438012263174866433L;
    }

    public final class Tester extends Thread {
        private volatile boolean run = true;

        @Override
        public void run() {
            while (run) {
                testStatus();
                try {
                    if (run)
                        sleep(TIMEOUT);
                } catch (InterruptedException e) {
                    stopRunning();
                }
            }
        }

        public void stopRunning() {
            run = false;
        }
    }

    public class Status implements IStatus {
        private volatile EStatus estatus;
        private String shortDescription;
        private String longDescription;

        public IConnectedService getConnectedService() {
            return AbstractConnectedService.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<IStatusChangedListener> listeners;
    protected IRunnableContext runnableContext;
    protected Status currentStatus;
    protected Tester tester;
    protected boolean manualTesting;
    private Map<String, String> properties;

    public AbstractConnectedService(IService service, AbstractSynchronizedConnection connection) {
        this.service = service;
        this.connection = connection;
        properties = new HashMap<String, String>();
    }

    public void setRunnableContext(IRunnableContext runnableContext) {
        this.runnableContext = runnableContext;
    }

    public void addStatusChangedListener(IStatusChangedListener listener) {
        if (listeners == null)
            listeners = new ListenerList<IStatusChangedListener>();
        listeners.add(listener);
    }

    public void dispose() {
        if (tester != null) {
            tester.stopRunning();
            tester = null;
        }

        if (listeners != null) {
            for (IStatusChangedListener listener : listeners) {
                listeners.remove(listener);
            }
        }
    }

    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() || manualTesting))
            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() || manualTesting)) // 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 setManualTesting() {
        manualTesting = true;
    }

    public boolean isEnabled() {
        return tester != null;
    }

    public void setEnabled(boolean enabled) {
        if (!service.isTestable())
            return;
        if (enabled && tester == null) {
            Check.checkState(connection.getSettings() != null);
            tester = new Tester();
            tester.start();
        } else if (!enabled && tester != null) {
            tester.stopRunning();
            tester = null;
            currentStatus.setEStatus(EStatus.UNKNOWN, Messages.getString("AbstractConnectedService.NoTestingLabel"), //$NON-NLS-1$
                    Messages.getString("AbstractConnectedService.UserDisabledMessage")); //$NON-NLS-1$
        }
    }

    public Map<String, String> getProperties() {
        return properties;
    }
}