| /* |
| * 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.devices; |
| |
| import java.util.Collection; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.TreeSet; |
| |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.sequoyah.device.common.utilities.exception.SequoyahException; |
| import org.eclipse.sequoyah.device.framework.DeviceUtils; |
| import org.eclipse.sequoyah.device.framework.factory.DeviceTypeRegistry; |
| import org.eclipse.sequoyah.device.framework.factory.InstanceRegistry; |
| import org.eclipse.sequoyah.device.framework.manager.InstanceManager; |
| import org.eclipse.sequoyah.device.framework.model.IDeviceType; |
| import org.eclipse.sequoyah.device.framework.model.IInstance; |
| import org.eclipse.sequoyah.device.framework.model.IInstanceBuilder; |
| import org.eclipse.sequoyah.device.framework.model.IService; |
| import org.eclipse.sequoyah.device.framework.model.handler.IServiceHandler; |
| |
| import com.motorola.studio.android.adt.DDMSFacade; |
| import com.motorola.studio.android.adt.ISerialNumbered; |
| |
| /** |
| * This manager provides information about device instances |
| * It shall work with TmL to be able to provide these information |
| */ |
| public class DevicesManager |
| { |
| |
| // instance |
| private static DevicesManager instance; |
| |
| /** |
| * Singleton |
| * |
| * @return a unique DevicesManager instance |
| */ |
| public static DevicesManager getInstance() |
| { |
| if (instance == null) |
| { |
| instance = new DevicesManager(); |
| } |
| return instance; |
| } |
| |
| /** |
| * Get all devices registered in TmL |
| * |
| * @return all devices registered in TmL |
| */ |
| public Collection<ISerialNumbered> getAllDevices() |
| { |
| Collection<ISerialNumbered> devicesCollection = new LinkedHashSet<ISerialNumbered>(); |
| |
| List<IInstance> tmlDevices = InstanceRegistry.getInstance().getInstances(); |
| |
| for (IInstance tmlInstance : tmlDevices) |
| { |
| if (tmlInstance instanceof ISerialNumbered) |
| { |
| devicesCollection.add((ISerialNumbered) tmlInstance); |
| } |
| } |
| return devicesCollection; |
| } |
| |
| /** |
| * Get all devices registered in TmL, sorted using the comparator passed as a parameter |
| * |
| * @param comparator the comparator that will be used to sort the devices list |
| * @return all devices registered in TmL, sorted using the comparator passed as a parameter |
| */ |
| public Collection<ISerialNumbered> getAllDevices(Comparator<ISerialNumbered> comparator) |
| { |
| Collection<ISerialNumbered> sortedDevices = new TreeSet<ISerialNumbered>(comparator); |
| sortedDevices.addAll(getAllDevices()); |
| return sortedDevices; |
| } |
| |
| /** |
| * Get all devices registered in TmL, sorted using the default comparator |
| * |
| * @return all devices registered in TmL, sorted using the default comparator |
| */ |
| public Collection<ISerialNumbered> getAllDevicesSorted() |
| { |
| return getAllDevices(getDefaultComparator()); |
| } |
| |
| /** |
| * Get the device, given its name |
| * |
| * @param name the device name |
| * @return a device instance |
| */ |
| public ISerialNumbered getDeviceByName(String name) |
| { |
| ISerialNumbered instanceToReturn = null; |
| |
| for (ISerialNumbered device : getAllDevices()) |
| { |
| if (device.getDeviceName().equals(name)) |
| { |
| instanceToReturn = device; |
| break; |
| } |
| } |
| return instanceToReturn; |
| |
| } |
| |
| /** |
| * Get the device, given its serial number |
| * |
| * @param serial the device serial name |
| * @return a device instance |
| */ |
| public ISerialNumbered getDeviceBySerialNumber(String serial) |
| { |
| ISerialNumbered instanceToReturn = null; |
| |
| String serialNumber = ""; |
| for (ISerialNumbered device : getAllDevices()) |
| { |
| if ((serialNumber = device.getSerialNumber()) != null) |
| { |
| if (serialNumber.equals(serial)) |
| { |
| instanceToReturn = device; |
| break; |
| } |
| } |
| } |
| return instanceToReturn; |
| |
| } |
| |
| /** |
| * Get all devices of certain type |
| * |
| * @param type the device type |
| * @return all devices of the device passed as a parameter |
| */ |
| @SuppressWarnings("unchecked") |
| public Collection<ISerialNumbered> getInstancesByType(Class type) |
| { |
| Collection<ISerialNumbered> instancesToReturn = new LinkedHashSet<ISerialNumbered>(); |
| |
| for (ISerialNumbered device : getAllDevices()) |
| { |
| if (device.getClass().equals(type)) |
| { |
| instancesToReturn.add(device); |
| } |
| } |
| return instancesToReturn; |
| |
| } |
| |
| /** |
| * Get all online devices of certain type |
| * |
| * @param type the device type |
| * @return all online devices of the device passed as a parameter |
| */ |
| @SuppressWarnings("unchecked") |
| public Collection<ISerialNumbered> getOnlineDevicesByType(Class type) |
| { |
| Collection<ISerialNumbered> instancesToReturn = new HashSet<ISerialNumbered>(); |
| |
| String serialNumber = null; |
| for (ISerialNumbered device : getInstancesByType(type)) |
| { |
| if (((serialNumber = device.getSerialNumber()) != null) |
| && (DDMSFacade.isDeviceOnline(serialNumber))) |
| { |
| instancesToReturn.add(device); |
| } |
| } |
| return instancesToReturn; |
| |
| } |
| |
| /** |
| * The default comparator to be used to sort ISerialNumbered instances |
| * It considers if the devices are online and after that it compares their names |
| * Online devices shall be placed in the beginning of the list |
| * |
| * @return a Comparator instance |
| */ |
| public static Comparator<ISerialNumbered> getDefaultComparator() |
| { |
| return new Comparator<ISerialNumbered>() |
| { |
| public int compare(ISerialNumbered serial1, ISerialNumbered serial2) |
| { |
| int compareResult; |
| |
| String name1 = serial1.getDeviceName(); |
| String name2 = serial2.getDeviceName(); |
| boolean dev1online = serial1.getSerialNumber() != null; |
| boolean dev2online = serial2.getSerialNumber() != null; |
| |
| if ((dev1online && dev2online) || (!dev1online && !dev2online)) |
| { |
| compareResult = name1.compareToIgnoreCase(name2); |
| } |
| else if (dev1online) |
| { |
| compareResult = -1; |
| } |
| else |
| // dev2online |
| { |
| compareResult = 1; |
| } |
| |
| return compareResult; |
| } |
| }; |
| } |
| |
| /** |
| * Creates a TmL instance |
| * |
| * @param serialNumber The serial number of the device to create a TmL instance for |
| * @throws TmLException |
| */ |
| public void createInstanceForDevice(String serialNumber, String deviceTypeID, |
| IInstanceBuilder instanceBuilder, String initServiceID) throws SequoyahException |
| { |
| |
| ISerialNumbered instance = getDeviceBySerialNumber(serialNumber); |
| if (instance == null) |
| { |
| IDeviceType tmlDeviceType = |
| DeviceTypeRegistry.getInstance().getDeviceTypeById(deviceTypeID); |
| |
| InstanceManager |
| .createProject(tmlDeviceType, instanceBuilder, new NullProgressMonitor()); |
| |
| IInstance newInstance = (IInstance) getDeviceBySerialNumber(serialNumber); |
| IService service = DeviceUtils.getServiceById(tmlDeviceType, initServiceID); |
| IServiceHandler handler = service.getHandler(); |
| handler.run(newInstance); |
| } |
| |
| } |
| |
| /** |
| * Destroys the TmL instance |
| * |
| * @param device The device to delete the correspondent TmL instance |
| */ |
| public void deleteInstanceOfDevice(String serialNumber) |
| { |
| |
| IInstance instanceToDelete = (IInstance) getDeviceBySerialNumber(serialNumber); |
| if (instanceToDelete != null) |
| { |
| InstanceManager.deleteInstance(instanceToDelete); |
| } |
| |
| } |
| |
| } |