/*
 * Copyright (C) 2010 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.android.tradefed.device;

import com.android.ddmlib.AndroidDebugBridge;
import com.android.tradefed.command.remote.DeviceDescriptor;
import com.android.tradefed.util.CommandResult;
import com.android.tradefed.util.IRunUtil;

import java.io.PrintWriter;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Interface for managing the set of available devices for testing.
 */
public interface IDeviceManager {
    /**
     * A listener for fastboot state changes.
     */
    public static interface IFastbootListener {
        /**
         * Callback when fastboot state has been updated for all devices.
         */
        public void stateUpdated();
    }

    /**
     * Initialize the device manager. This must be called once and only once before any other
     * methods are called.
     */
    public void init();

    /**
     * Initialize the device manager with a device filter. This filter can be used to instruct
     * the DeviceManager to ignore certain connected devices.
     *
     * @param globalDeviceFilter the device filter
     */
    public void init(IDeviceSelection globalDeviceFilter, List<IDeviceMonitor> deviceMonitors);

    /**
     * Request a physical device for testing
     *
     * @return a {@link ITestDevice} for testing, or <code>null</code> if one is not available
     */
    public ITestDevice allocateDevice();

    /**
     * Request a device for testing that meets certain criteria.
     *
     * @param options the {@link IDeviceSelection} the device should meet.
     * @return a {@link ITestDevice} for testing, or <code>null</code> if one
     *         is not available
     */
    public ITestDevice allocateDevice(IDeviceSelection options);

    /**
     * Request a device for testing that meets certain criteria.
     *
     * @param options the {@link IDeviceSelection} the device should meet.
     * @param isTemporary whether or not a temporary NullDevice should be created.
     * @return a {@link ITestDevice} for testing, or <code>null</code> if one is not available
     */
    public ITestDevice allocateDevice(IDeviceSelection options, boolean isTemporary);

    /**
     * Rudely allocate a device, even if its not currently available.
     * <p/>
     * Will have no effect if device is already allocated.
     *
     * @param serial the device serial to allocate
     * @return the {@link ITestDevice}, or <code>null</code> if it could not be allocated
     */
    public ITestDevice forceAllocateDevice(String serial);

    /**
     * Return a device to the pool
     * <p/>
     * Attempts to return a device that hasn't been previously allocated will be ignored.
     *
     * @param device the {@link ITestDevice} to free
     * @param state the {@link com.android.tradefed.device.FreeDeviceState}. Used to control if
     *        device is returned to available device pool.
     */
    public void freeDevice(ITestDevice device, FreeDeviceState state);

    /**
     * A helper method to execute shell command on available device.
     *
     * @param serial The device serial.
     * @param command The shell command.
     * @param timeout The amount of time for the command to complete.
     * @param timeUnit The unit for the timeout.
     * @return A {@link CommandResult}.
     */
    public CommandResult executeCmdOnAvailableDevice(
            String serial, String command, long timeout, TimeUnit timeUnit);

    /**
     * Helper method to launch emulator.
     * <p/>
     * Will launch the emulator as specified by the caller
     *
     * @param device the placeholder {@link ITestDevice} representing allocated emulator device
     * @param bootTimeout the time in ms to wait for the emulator to boot
     * @param runUtil
     * @param emulatorArgs command line arguments to launch the emulator
     * @throws DeviceNotAvailableException if emulator fails to boot or come online
     */
    void launchEmulator(ITestDevice device, long bootTimeout, IRunUtil runUtil,
            List<String> emulatorArgs) throws DeviceNotAvailableException;

    /**
     * Shut down the given emulator.
     * <p/>
     * Blocks until emulator disappears from adb. Will have no effect if emulator is already not
     * available.
     *
     * @param device the {@link ITestDevice} representing emulator to shut down
     * @throws DeviceNotAvailableException if emulator fails to shut down
     */
    public void killEmulator(ITestDevice device) throws DeviceNotAvailableException;

    /**
     * Connect to a device with adb-over-tcp
     * <p/>
     * This method allocates a new device, which should eventually be freed via
     * {@link #disconnectFromTcpDevice(ITestDevice)}
     * <p/>
     * The returned {@link ITestDevice} will be online, but may not be responsive.
     * <p/>
     * Note that performing action such as a reboot on a tcp connected device, will sever the
     * tcp connection to the device, and result in a {@link DeviceNotAvailableException}
     *
     * @param ipAndPort the original ip address and port of the device to connect to
     * @return the {@link ITestDevice} or <code>null</code> if a tcp connection could not be formed
     */
    public ITestDevice connectToTcpDevice(String ipAndPort);

    /**
     * Disconnect from an adb-over-tcp connected device.
     * <p/>
     * Switches the device back to usb mode, and frees it.
     *
     * @param tcpDevice the device currently in tcp mode, previously allocated via
     *            {@link #connectToTcpDevice(String)}
     * @return <code>true</code> if switch to usb mode was successful
     */
    public boolean disconnectFromTcpDevice(ITestDevice tcpDevice);

    /**
     * A helper method that switches the given usb device to adb-over-tcp mode, and then connects to
     * it via {@link #connectToTcpDevice(String)}.
     *
     * @param usbDevice the device currently in usb mode
     * @return the newly allocated {@link ITestDevice} in tcp mode or <code>null</code> if a tcp
     *         connection could not be formed
     * @throws DeviceNotAvailableException if the connection with <var>usbDevice</var> was lost and
     *         could not be recovered
     */
    public ITestDevice reconnectDeviceToTcp(ITestDevice usbDevice)
            throws DeviceNotAvailableException;

    /**
     * Stops device monitoring services, and terminates the ddm library.
     * <p/>
     * This must be called upon application termination.
     *
     * @see AndroidDebugBridge#terminate()
     */
    public void terminate();

    /** Stops the device recovery thread. */
    public void terminateDeviceRecovery();

    /** Stop the Device Monitors. */
    public void terminateDeviceMonitor();

    /** Like {@link #terminate()}, but attempts to forcefully shut down adb as well. */
    public void terminateHard();

    /**
     * Like {@link #terminateHard()}.
     *
     * @param reason optional reason given for the termination.
     */
    public default void terminateHard(String reason) {
        terminateHard();
    }

    /** Stop adb bridge and services depend on adb connections. */
    public void stopAdbBridge();

    /**
     * Restart (if {@link #stopAdbBridge()} was called) adb bridge and services depend on adb
     * connections.
     */
    public void restartAdbBridge();

    /**
     * Returns a list of DeviceDescriptors for all known devices
     *
     * @return a list of {@link DeviceDescriptor} for all known devices
     */
    public List<DeviceDescriptor> listAllDevices();

    /**
     * Returns a list of DeviceDescriptors for all known devices
     *
     * @param shortDescriptor whether to limit descriptors to minimum info
     * @return a list of {@link DeviceDescriptor} for all known devices
     */
    public List<DeviceDescriptor> listAllDevices(boolean shortDescriptor);

    /**
     * Returns the DeviceDescriptor with the given serial.
     *
     * @param serial serial number for the device to get
     * @return the {@link DeviceDescriptor} for the selected device, or null if the serial does not
     *     match a known device.
     */
    public DeviceDescriptor getDeviceDescriptor(String serial);

    /**
     * Output a user-friendly description containing list of known devices, their state, and values
     * for commonly used {@link IDeviceSelection} options.
     *
     * @param printWriter the {@link PrintWriter} to output the description to
     * @param includeStub Whether or not to display stub devices too.
     */
    public void displayDevicesInfo(PrintWriter printWriter, boolean includeStub);

    /**
     * Informs the manager that a listener is interested in fastboot state changes.
     * <p/>
     * Currently a {@link IDeviceManager} will only monitor devices in fastboot if there are one or
     * more active listeners.
     * <p/>
     * TODO: this is a bit of a hack - find a better solution
     *
     * @param listener
     */
    public void addFastbootListener(IFastbootListener listener);

    /**
     * Informs the manager that a listener is no longer interested in fastboot state changes.
     * @param listener
     */
    public void removeFastbootListener(IFastbootListener listener);

    /**
     * Determine if given serial represents a null device
     */
    public boolean isNullDevice(String serial);

    /**
     * Determine if given serial represents a emulator
     */
    public boolean isEmulator(String serial);

    /**
     * Adds a {@link IDeviceMonitor}
     */
    public void addDeviceMonitor(IDeviceMonitor mon);

    /**
     * Removes a previously added {@link IDeviceMonitor}. Has no effect if mon has not been added.
     */
    public void removeDeviceMonitor(IDeviceMonitor mon);

    /** Returns the path to the adb binary to use. */
    public String getAdbPath();

    /** Returns the path to the fastboot binary to use. */
    public String getFastbootPath();

    /**
     * Wait until a first physical device is connected. If a device was connected before, it
     * returns directly True. If no device was added, it returns false after timeout.
     *
     * @param timeout time to wait in millisecond before returning false.
     */
    public boolean waitForFirstDeviceAdded(long timeout);

    /** Get the adb version currently in use by the device manager. */
    public String getAdbVersion();

    /**
     * Add a device to fastboot monitor. The fastboot monitor will use 'fastboot_serial' to
     * communicate with the device.
     *
     * @param serial the device's serial number.
     * @param fastboot_serial the device's fastboot mode serial number.
     */
    public void addMonitoringTcpFastbootDevice(String serial, String fastboot_serial);

    /**
     * Returns whether or not we should check in {@link NativeDeviceStateMonitor} the file system is
     * mounted properly.
     */
    public default boolean isFileSystemMountCheckEnabled() {
        return false;
    }
}