Java DeviceAllocationInformation.getDeviceId方法代码示例

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
public void releaseDevice(DeviceAllocationInformation allocatedDeviceDescriptor)
    throws InvalidPasskeyException,
        DeviceNotFoundException {
    String deviceId = allocatedDeviceDescriptor.getDeviceId();
    long currentPasskey = allocatedDeviceDescriptor.getProxyPasskey();

    PasskeyAuthority.validatePasskey(currentPasskey, deviceId);

    try {
        IDevice device = devicePoolDao.getDevice(deviceId);

        if (device != null) {
            releaseDevice(device, currentPasskey);
        }
    } catch (DevicePoolDaoException e) {
        String errorMessage = String.format("Failed to release device with ID %s.", deviceId);
        LOGGER.fatal(errorMessage);
    }
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
/**
 * Releases an allocated device. Removes all cached sessions associated to the device.
 *
 * @param deviceDescriptor
 *        - the {@link DeviceAllocationInformation} corresponding to the device which should be released
 */
void releaseDevice(RequestMessage requestMessage, Session session) {
    DeviceAllocationInformation deviceDescriptor = (DeviceAllocationInformation) requestMessage.getArguments()[0];

    String deviceId = deviceDescriptor.getDeviceId();
    removeCachedSessionByDeviceId(deviceId);

    try {
        poolManager.releaseDevice(deviceDescriptor);
        ResponseMessage releseResponse = new ResponseMessage(MessageAction.RELEASE_DEVICE, null, null);
        releseResponse.setSessionId(requestMessage.getSessionId());

        sendText(jsonUtil.serialize(releseResponse), session);
    } catch (InvalidPasskeyException | DeviceNotFoundException ex) {
        sendErrorResponseMessage(ex, session, requestMessage.getSessionId());
        LOGGER.error("Failed to release a device with id " + deviceId, ex);
    }
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceFirstTestTwo() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().deviceType(DeviceType.EMULATOR_PREFERRED)
                                                                       .screenHeight(600)
                                                                       .screenWidth(800);
    DeviceSelector deviceSelector = selectorBuilder.build();

    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(firstDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(firstDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(FIRST_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceFirstTestThree() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().ramCapacity(128);
    DeviceSelector deviceSelector = selectorBuilder.build();

    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(firstDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(firstDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(FIRST_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceSecond() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().screenDpi(240);
    DeviceSelector deviceSelector = selectorBuilder.build();

    List<IDevice> deviceList = Arrays.asList(secondDevice);
    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(secondDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(secondDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(SECOND_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceThird() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().ramCapacity(512)
                                                                       .deviceType(DeviceType.DEVICE_ONLY);
    DeviceSelector deviceSelector = selectorBuilder.build();

    List<IDevice> deviceList = Arrays.asList(thirdDevice);
    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(thirdDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(thirdDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(THIRD_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceFourth() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().deviceType(DeviceType.EMULATOR_ONLY)
                                                                       .screenDpi(180);
    DeviceSelector deviceSelector = selectorBuilder.build();

    List<IDevice> deviceList = Arrays.asList(fourthDevice);
    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(fourthDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(fourthDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(FOURTH_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceWithCamera() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().deviceType(DeviceType.EMULATOR_ONLY)
                                                                       .isCameraAvailable(true);
    DeviceSelector deviceSelector = selectorBuilder.build();

    List<IDevice> deviceList = Arrays.asList(fourthDevice);
    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(fourthDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(fourthDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(FOURTH_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceWithoutCamera() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().isCameraAvailable(false);
    DeviceSelector deviceSelector = selectorBuilder.build();

    List<IDevice> deviceList = Arrays.asList(fifthDevice);
    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(fifthDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(fifthDevice);

    poolManager.releaseDevice(deviceId);

    assertCorrectDeviceFetched(FIFTH_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
@Test
public void getPresentDeviceFirstTestOne() throws Exception {
    DeviceSelectorBuilder selectorBuilder = new DeviceSelectorBuilder().ramCapacity(128);
    DeviceSelector deviceSelector = selectorBuilder.build();

    when(devicePoolDao.getDevices(eq(deviceSelector), eq(false))).thenReturn(deviceList);
    DeviceAllocationInformation deviceDescriptor = poolManager.allocateDevice(deviceSelector);
    String deviceId = deviceDescriptor.getDeviceId();

    doNothing().when(devicePoolDao).update(firstDevice);
    when(devicePoolDao.getDevice(eq(deviceId))).thenReturn(firstDevice);

    poolManager.releaseDevice(deviceId);
    assertCorrectDeviceFetched(FIRST_DEVICE_SERIAL_NUMBER, deviceDescriptor);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
private void assertCorrectDeviceFetched(String expectedDeviceSerialNumber,
                                        DeviceAllocationInformation allocatedDeviceInformation) {
    String deviceId = allocatedDeviceInformation.getDeviceId();
    assertEquals("Failed to receive the ID of the correct device.",
                 String.format(DEVICE_ID_FORMAT, expectedDeviceSerialNumber),
                 deviceId);
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
/**
 * Gets a {@link Device Device} instance with the given {@link DeviceSelector device characteristics}.
 *
 * @param deviceSelector
 *        - required {@link DeviceSelector parameters} needed to construct new {@link Device Device} instance.
 * @return a {@link Device Device} instance with the given device parameters.
 */
public Device getDevice(DeviceSelector deviceSelector) {
    try {
        DeviceAllocationInformation deviceDescriptor = dispatcher.getDeviceDescriptor(deviceSelector,
                                                                                      allocateDeviceRetryCount);

        final String deviceId = deviceDescriptor.getDeviceId();
        LOGGER.info(String.format("Fetched device with ID: %s .", deviceId));

        long passkey = deviceDescriptor.getProxyPasskey();

        Device device = new Device(passkey, deviceId);
        deviceToDescriptor.put(device, deviceDescriptor);

        if (this.screenRecordingproperties.isEnabled()) {
            int duration = this.screenRecordingproperties.getDuration();
            device.startScreenRecording(duration, false);
        }
        if (this.logcatAnnotationProperties.isEnabled()) {
            device.clearLogcat();
        }

        ConfigurationPropertiesLoader.loadImplicitWait();

        return device;
    } catch (NoAvailableDeviceFoundException e) {
        String message = "No devices matching the requested parameters were found";
        LOGGER.error(message, e);
        throw new NoAvailableDeviceFoundException(message, e);
    }
}
 

import com.musala.atmosphere.commons.cs.clientbuilder.DeviceAllocationInformation; //导入方法依赖的package包/类
/**
 * Releases a given device.
 *
 * @param device
 *        - device to be released.
 * @throws DeviceNotFoundException
 *         if failed to find the device
 */
public void releaseDevice(Device device) throws DeviceNotFoundException {
    DeviceAllocationInformation deviceDescriptor = deviceToDescriptor.get(device);
    String deviceId = deviceDescriptor.getDeviceId();

    deviceToDescriptor.remove(device);

    if (this.screenRecordingproperties.isEnabled()) {
        device.stopScreenRecording();
    }
    if (this.logcatAnnotationProperties.isEnabled()) {
        device.getDeviceLog(logcatAnnotationProperties);
    }
    device.release();
    try {
        dispatcher.releaseDevice(deviceDescriptor);
    } catch (Exception e) {
        if (e instanceof InvalidPasskeyException) {
            // We did not have the correct passkey. The device most likely timed out and got freed to be used by
            // someone else. So nothing to do here.
        } else if (e instanceof DeviceNotFoundException) {
            throw (DeviceNotFoundException) e;
        } else if (e instanceof ServerConnectionFailedException) {
            String message = "Could not release Device (connection failure).";
            LOGGER.error(message, e);
            throw new ServerConnectionFailedException(message, e);
        }
    }

    String messageReleasedDevice = String.format("Released device with ID: %s .", deviceId);
    LOGGER.info(messageReleasedDevice);
}