src/plugins/remote.device/src/com/motorola/studio/android/remote/ui/wireless/runnables/SwitchFromUSBAndConnectToWirelessRunnable.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.motorola.studio.android.remote.ui.wireless.runnables;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.sequoyah.device.common.utilities.exception.SequoyahException;
import org.eclipse.sequoyah.device.framework.DevicePlugin;
import org.eclipse.sequoyah.device.framework.factory.InstanceRegistry;
import org.eclipse.sequoyah.device.framework.manager.InstanceManager;
import org.eclipse.sequoyah.device.framework.model.IInstance;

import com.motorola.studio.android.AndroidPlugin;
import com.motorola.studio.android.adt.DDMSFacade;
import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.remote.i18n.RemoteDeviceNLS;
import com.motorola.studio.android.remote.instance.RemoteDeviceInstance;
import com.motorola.studio.android.remote.ui.wireless.WirelessWizard;

/**
 * Service which switches the device to TCP/IP, add it as a remote
 * device to the Device Management and connect to it via the wireless
 * network.
 */
public class SwitchFromUSBAndConnectToWirelessRunnable implements IRunnableWithProgress
{

    private final WirelessWizard wirelessWizard;

    /**
     * Constructor which passes the {@link Wizard} page.
     * 
     * @param wirelessWizard Wizard paged
     */
    public SwitchFromUSBAndConnectToWirelessRunnable(WirelessWizard wirelessWizard)
    {
        this.wirelessWizard = wirelessWizard;
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
     */
    public void run(IProgressMonitor monitor) throws InvocationTargetException,
            InterruptedException
    {
        boolean isInstanceCreated = false;
        SubMonitor subMonitor = SubMonitor.convert(monitor, 1000);
        subMonitor
                .beginTask(
                        RemoteDeviceNLS.SwitchFromUSBAndConnectToWirelessRunnable_MsgCreatingWirelessRemoteDevice,
                        1000);

        RemoteDeviceInstance remoteDeviceInstance = null;
        IStatus status = Status.OK_STATUS;

        // get connection timeout 
        int connectionTimeout =
                Integer.valueOf(this.wirelessWizard.getProperties().getProperty(
                        RemoteDeviceInstance.PROPERTY_TIMEOUT));

        try
        {
            subMonitor.worked(100);

            if (!subMonitor.isCanceled())
            {
                // switch device connection from USB to TCP/IP
                try
                {
                    status =
                            DDMSFacade.switchUSBtoTcpIp(this.wirelessWizard.getInstance()
                                    .getDeviceName(), this.wirelessWizard.getInstance()
                                    .getSerialNumber(), this.wirelessWizard.getProperties()
                                    .getProperty(RemoteDeviceInstance.PROPERTY_PORT),
                                    connectionTimeout, subMonitor.newChild(300));
                }
                catch (IOException se)
                {
                    // log error, adjust the status and throw the exception
                    status = handleStatusAndLogDuringException(se);
                    throw new InvocationTargetException(se, se.getMessage());
                }
            }

            remoteDeviceInstance = null;
            if (!(status.getSeverity() == IStatus.ERROR) && !subMonitor.isCanceled())
            {
                subMonitor
                        .setTaskName(RemoteDeviceNLS.SwitchFromUSBAndConnectToWirelessRunnable_CreatingRemoteDeviceInstance);

                // verify if there already is an instance created with the same name
                List<IInstance> instanceByName =
                        InstanceRegistry.getInstance().getInstancesByName(
                                this.wirelessWizard.getDeviceName());

                if ((instanceByName != null) && (!instanceByName.isEmpty()))
                {
                    remoteDeviceInstance = (RemoteDeviceInstance) instanceByName.get(0);
                }
                else
                {
                    // create the new remote device instance
                    try
                    {
                        remoteDeviceInstance =
                                (RemoteDeviceInstance) InstanceManager.createInstance(
                                        this.wirelessWizard.getDeviceName(), //$NON-NLS-1$
                                        "com.motorola.studio.android.remote.androidRemoteDevice", //$NON-NLS-1$
                                        DevicePlugin.SEQUOYAH_STATUS_OFF,
                                        this.wirelessWizard.getProperties());
                    }
                    catch (SequoyahException se)
                    {
                        // log error, adjust the status and throw the exception
                        status = handleStatusAndLogDuringException(se);
                        throw new InvocationTargetException(se, se.getMessage());
                    }

                    if (!subMonitor.isCanceled())
                    {
                        // add instance to the DDMS and set the flag
                        InstanceRegistry.getInstance().addInstance(remoteDeviceInstance);
                        isInstanceCreated = true;
                    }
                }
                subMonitor.worked(300);
            }

            if (!subMonitor.isCanceled())
            {
                subMonitor
                        .setTaskName(RemoteDeviceNLS.SwitchFromUSBAndConnectToWirelessRunnable_ConnectingToWifiDevice);

                int timeoutAux = (connectionTimeout > 60) ? connectionTimeout : 60;

                long timeoutLimit = System.currentTimeMillis() + (timeoutAux * 1000);

                // after the adb mode is switched to tcpip the handset takes a while to
                // be available for connection, that is why this while exists
                while ((!DDMSFacade.isDeviceOnline(remoteDeviceInstance.getSerialNumber()))
                        && (System.currentTimeMillis() < timeoutLimit))
                {
                    // connect the remote device via TCP/IP
                    try
                    {
                        status =
                                DDMSFacade.connectTcpIp(
                                        remoteDeviceInstance,
                                        this.wirelessWizard.getProperties().getProperty(
                                                RemoteDeviceInstance.PROPERTY_HOST),
                                        this.wirelessWizard.getProperties().getProperty(
                                                RemoteDeviceInstance.PROPERTY_PORT),
                                        connectionTimeout, subMonitor.newChild(300));
                    }
                    catch (IOException ioe)
                    {
                        status = handleStatusAndLogDuringException(ioe);
                        throw new InvocationTargetException(ioe, ioe.getMessage());
                    }
                }
            }
            // in case the status has errors, throw InvocationTargetException
            if ((status != null) && (status.getSeverity() == IStatus.ERROR)
                    && (!subMonitor.isCanceled()))
            {
                if (status.getException() != null)
                {
                    throw new InvocationTargetException(status.getException());
                }
                else
                {
                    throw new InvocationTargetException(
                            new Exception(
                                    RemoteDeviceNLS.SwitchFromUSBAndConnectToWirelessRunnable_MsgNotPossibleToConvertUSBToTCPIP));
                }
            }

            // treat the case where the monitor is canceled - throw InterruptedException as stated in this method
            if (monitor.isCanceled())
            {
                throw new InterruptedException(
                        "The switching to TCP/IP connection mode was canceled by the user.");
            }
        }
        finally
        {
            // remove the device in case it exists and was added to the Device Management View
            if ((remoteDeviceInstance != null) && (isInstanceCreated)
                    && ((status.getSeverity() == IStatus.ERROR) || (subMonitor.isCanceled())))
            {
                InstanceRegistry.getInstance().removeInstance(remoteDeviceInstance);
            }
        }
    }

    /*
     * Log the exception and get the error status.
     * 
     * @param exception The exception to be treated.
     * 
     * @return Returns the Error status.
     */
    private IStatus handleStatusAndLogDuringException(Exception exception)
    {
        StudioLogger.error(this.getClass(), exception.getMessage(), exception);
        return new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, exception.getMessage());
    }
}