本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# AWS Device Farm 中的远程访问
利用远程访问，您可以通过 Web 浏览器使用轻扫和手势功能，并实现与设备实时交互，以测试功能和重现客户问题。您可以通过与设备建立远程访问会话，与该特定设备进行交互。
Device Farm 中的会话是与托管在网络浏览器中的实际物理设备的实时互动。会话显示您在启动会话时选择的单台设备。用户一次可以启动多个会话，同时运行的设备总数受您拥有的设备槽数限制。您可以根据设备系列（例如，Android 或 iOS 设备）来购买设备槽。有关更多信息，请参阅 [Device Farm 定价](https://aws.amazon.com/device-farm/pricing/)。
Device Farm 目前提供一部分设备用于远程访问测试。我们一直继续向设备池添加新设备。
Device Farm 捕获每个远程访问会话的视频，并生成会话期间的活动的日志。这些结果包含您在会话期间提供的任何信息。
**注意**
出于安全考虑，建议您避免在远程访问会话期间提供或输入账号、个人登录信息和其他详细信息等敏感信息。如果可能，请使用专门为测试开发的替代方案，例如测试账户。
**Topics**
+ [在 AWS Device Farm 中创建远程访问会话](how-to-create-session.md)
+ [在 AWS Device Farm 中使用远程访问会话](how-to-use-session.md)
+ [在 AWS Device Farm 中检索远程访问会话的结果](how-to-access-session-results.md)
# 在 AWS Device Farm 中创建远程访问会话
有关远程访问会话的更多信息，请参阅[会话](sessions.md)。
+ [先决条件](#how-to-create-session-prerequisites)
+ [创建远程会话](#how-to-create-remote-session)
+ [后续步骤](#how-to-create-session-next-steps)
## 先决条件
+ 在 Device Farm 中创建项目。按照[在 AWS Device Farm 中创建项目](how-to-create-project.md)中的说明操作，然后返回此页。
## 创建远程会话
------
#### [ Console ]
1. 登录 DeviceFarm 控制台，网址为 [https://console.aws.amazon.com/devicef](https://console.aws.amazon.com/devicefarm) arm。
1. 在 Device Farm 导航面板上，选择**移动设备测试**，然后选择**项目**。
1. 如果您已有项目，请从列表中选择一个项目。否则，请按照 [在 AWS Device Farm 中创建项目](how-to-create-project.md) 中的说明创建项目。
1. 在 “**远程访问**” 选项卡上，选择 “**创建远程访问会话**”。
1. 为您的会话选择一个设备。您可以从可用设备列表中进行选择，或使用列表顶部的搜索栏搜索设备。
1. *（可选）*在会话中加入应用程序和辅助应用程序。这些可以是新上传的应用程序，也可以是过去 30 天内在此项目中上传的应用程序（30 天后，应用程序上传[将过期](data-protection.md#data-protection-retention)）。
1. 在 **Session name (会话名称)** 中输入会话名称。
1. 选择 **Confirm and start session (确认并启动会话)**。
------
#### [ AWS CLI ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
首先， up-to-date通过[下载并安装最新版本来验证您的 AWS CLI 版本是否为最新版本](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)。
**重要**
本文档中提到的某些命令在旧版本的 AWS CLI 中不可用。
然后，您可以确定要在哪台设备上进行测试：
```
$ aws devicefarm list-devices
```
这将显示如下输出：
```
{
"devices":
[
{
"arn": "arn:aws:devicefarm:us-west-2::device:DE5BD47FF3BD42C3A14BF7A6EFB1BFE7",
"name": "Google Pixel 8",
"remoteAccessEnabled": true,
"availability": "HIGHLY_AVAILABLE"
...
},
...
]
}
```
然后，您可以使用您选择的设备 ARN 创建远程访问会话：
```
$ aws devicefarm create-remote-access-session \
--project-arn arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef \
--device-arn arn:aws:devicefarm:us-west-2::device:DE5BD47FF3BD42C3A14BF7A6EFB1BFE7 \
--app-arn arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef \
--configuration '{
"auxiliaryApps": [
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
]
}'
```
这将显示如下输出：
```
{
"remoteAccessSession": {
"arn": "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000",
"name": "Google Pixel 8",
"status": "PENDING",
...
}
```
现在，我们可以选择投票并等待会话准备就绪：
```
$ POLL_INTERVAL=3
TIMEOUT=600
DEADLINE=$(( $(date +%s) + TIMEOUT ))
while [[ "$(date +%s)" -lt "$DEADLINE" ]]; do
STATUS=$(aws devicefarm get-remote-access-session \
--arn "$DEVICE_FARM_SESSION_ARN" \
--query 'remoteAccessSession.status' \
--output text)
case "$STATUS" in
RUNNING)
echo "Session is ready with status: $STATUS"
break
;;
STOPPING|COMPLETED)
echo "Session ended early with status: $STATUS"
exit 1
;;
esac
done
```
------
#### [ Python ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
此示例首先在 Device Farm 上找到所有可用的 Google Pixel 设备，然后使用该设备创建远程访问会话并等待会话运行。
```
import random
import time
import boto3
client = boto3.client("devicefarm", region_name="us-west-2")
# 1) Gather all matching devices via paginated ListDevices with filters
filters = [
{"attribute": "MODEL", "operator": "CONTAINS", "values": ["Pixel"]},
{"attribute": "AVAILABILITY", "operator": "EQUALS", "values": ["AVAILABLE"]},
]
matching_arns = []
next_token = None
while True:
args = {"filters": filters}
if next_token:
args["nextToken"] = next_token
page = client.list_devices(**args)
for d in page.get("devices", []):
matching_arns.append(d["arn"])
next_token = page.get("nextToken")
if not next_token:
break
if not matching_arns:
raise RuntimeError("No available Google Pixel device found.")
# Randomly select one device from the full matching set
device_arn = random.choice(matching_arns)
print("Selected device ARN:", device_arn)
# 2) Create remote access session and wait until RUNNING
resp = client.create_remote_access_session(
projectArn="arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
deviceArn=device_arn,
appArn="arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", # optional
configuration={
"auxiliaryApps": [ # optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1",
]
},
)
session_arn = resp["remoteAccessSession"]["arn"]
print(f"Created Remote Access Session: {session_arn}")
poll_interval = 3
timeout = 600
deadline = time.time() + timeout
terminal_states = ["STOPPING", "COMPLETED"]
while True:
out = client.get_remote_access_session(arn=session_arn)
status = out["remoteAccessSession"]["status"]
print(f"Current status: {status}")
if status == "RUNNING":
print(f"Session is ready with status: {status}")
break
if status in terminal_states:
raise RuntimeError(f"Session ended early with status: {status}")
if time.time() >= deadline:
raise RuntimeError("Timed out waiting for session to be ready.")
time.sleep(poll_interval)
```
------
#### [ Java ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
*注意：此示例使用适用于 Java 的 AWS 开发工具包 v2，并且与 JDK 版本 11 及更高版本兼容。*
此示例首先在 Device Farm 上找到所有可用的 Google Pixel 设备，然后使用该设备创建远程访问会话并等待会话运行。
```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionConfiguration;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionResponse;
import software.amazon.awssdk.services.devicefarm.model.Device;
import software.amazon.awssdk.services.devicefarm.model.DeviceFilter;
import software.amazon.awssdk.services.devicefarm.model.DeviceFilterAttribute;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
import software.amazon.awssdk.services.devicefarm.model.ListDevicesRequest;
import software.amazon.awssdk.services.devicefarm.model.ListDevicesResponse;
import software.amazon.awssdk.services.devicefarm.model.RuleOperator;
public class CreateRemoteAccessSession {
public static void main(String[] args) throws Exception {
DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.build();
String projectArn = "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef";
String appArn = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef";
String aux1 = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0";
String aux2 = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1";
// 1) Gather all matching devices via paginated ListDevices with filters
List filters = Arrays.asList(
DeviceFilter.builder()
.attribute(DeviceFilterAttribute.MODEL)
.operator(RuleOperator.CONTAINS)
.values("Pixel")
.build(),
DeviceFilter.builder()
.attribute(DeviceFilterAttribute.AVAILABILITY)
.operator(RuleOperator.EQUALS)
.values("AVAILABLE")
.build()
);
List matchingDeviceArns = new ArrayList<>();
String next = null;
do {
ListDevicesResponse page = client.listDevices(
ListDevicesRequest.builder().filters(filters).nextToken(next).build());
for (Device d : page.devices()) {
matchingDeviceArns.add(d.arn());
}
next = page.nextToken();
} while (next != null);
if (matchingDeviceArns.isEmpty()) {
throw new RuntimeException("No available Google Pixel device found.");
}
// Randomly select one device from the full matching set
String deviceArn = matchingDeviceArns.get(
ThreadLocalRandom.current().nextInt(matchingDeviceArns.size()));
System.out.println("Selected device ARN: " + deviceArn);
// 2) Create Remote Access session and wait until it is RUNNING
CreateRemoteAccessSessionConfiguration cfg = CreateRemoteAccessSessionConfiguration.builder()
.auxiliaryApps(Arrays.asList(aux1, aux2))
.build();
CreateRemoteAccessSessionResponse res = client.createRemoteAccessSession(
CreateRemoteAccessSessionRequest.builder()
.projectArn(projectArn)
.deviceArn(deviceArn)
.appArn(appArn) // optional
.configuration(cfg) // optional
.build());
String sessionArn = res.remoteAccessSession().arn();
System.out.println("Created Remote Access Session: " + sessionArn);
int pollIntervalMs = 3000;
long timeoutMs = 600_000L;
long deadline = System.currentTimeMillis() + timeoutMs;
while (true) {
GetRemoteAccessSessionResponse get = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(sessionArn).build());
String status = get.remoteAccessSession().statusAsString();
System.out.println("Current status: " + status);
if ("RUNNING".equals(status)) {
System.out.println("Session is ready with status: " + status);
break;
}
if ("STOPPING".equals(status) || "COMPLETED".equals(status)) {
throw new RuntimeException("Session ended early with status: " + status);
}
if (System.currentTimeMillis() >= deadline) {
throw new RuntimeException("Timed out waiting for session to be ready.");
}
Thread.sleep(pollIntervalMs);
}
}
}
```
------
#### [ JavaScript ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
*注意：此示例使用适用于 JavaScript v3 的 AWS 开发工具包。*
此示例首先在 Device Farm 上找到所有可用的 Google Pixel 设备，然后使用该设备创建远程访问会话并等待会话运行。
```
import {
DeviceFarmClient,
ListDevicesCommand,
CreateRemoteAccessSessionCommand,
GetRemoteAccessSessionCommand,
} from "@aws-sdk/client-device-farm";
const client = new DeviceFarmClient({ region: "us-west-2" });
// 1) Gather all matching devices via paginated ListDevices with filters
const filters = [
{ attribute: "MODEL", operator: "CONTAINS", values: ["Pixel"] },
{ attribute: "AVAILABILITY", operator: "EQUALS", values: ["AVAILABLE"] },
];
let nextToken;
const matching = [];
while (true) {
const page = await client.send(new ListDevicesCommand({ filters, nextToken }));
for (const d of page.devices ?? []) {
matching.push(d.arn);
}
nextToken = page.nextToken;
if (!nextToken) break;
}
if (matching.length === 0) {
throw new Error("No available Google Pixel device found.");
}
// Randomly select one device from the full matching set
const deviceArn = matching[Math.floor(Math.random() * matching.length)];
console.log("Selected device ARN:", deviceArn);
// 2) Create remote access session and wait until RUNNING
const out = await client.send(new CreateRemoteAccessSessionCommand({
projectArn: "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
deviceArn,
appArn: "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", // optional
configuration: {
auxiliaryApps: [ // optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1",
],
},
}));
const sessionArn = out.remoteAccessSession?.arn;
console.log("Created Remote Access Session:", sessionArn);
const pollIntervalMs = 3000;
const timeoutMs = 600000;
const deadline = Date.now() + timeoutMs;
while (true) {
const get = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const status = get.remoteAccessSession?.status;
console.log("Current status:", status);
if (status === "RUNNING") {
console.log("Session is ready with status:", status);
break;
}
if (status === "STOPPING" || status === "COMPLETED") {
throw new Error(`Session ended early with status: ${status}`);
}
if (Date.now() >= deadline) {
throw new Error("Timed out waiting for session to be ready.");
}
await new Promise((r) => setTimeout(r, pollIntervalMs));
}
```
------
#### [ C\$1 ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
此示例首先在 Device Farm 上找到所有可用的 Google Pixel 设备，然后使用该设备创建远程访问会话并等待会话运行。
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
class Program
{
static async Task Main()
{
var client = new AmazonDeviceFarmClient(RegionEndpoint.USWest2);
// 1) Gather all matching devices via paginated ListDevices with filters
var filters = new List
{
new DeviceFilter { Attribute = DeviceAttribute.MODEL, Operator = RuleOperator.CONTAINS, Values = new List{ "Pixel" } },
new DeviceFilter { Attribute = DeviceAttribute.AVAILABILITY, Operator = RuleOperator.EQUALS, Values = new List{ "AVAILABLE" } },
};
var matchingArns = new List();
string nextToken = null;
do
{
var list = await client.ListDevicesAsync(new ListDevicesRequest
{
Filters = filters,
NextToken = nextToken
});
foreach (var d in list.Devices)
matchingArns.Add(d.Arn);
nextToken = list.NextToken;
}
while (nextToken != null);
if (matchingArns.Count == 0)
throw new Exception("No available Google Pixel device found.");
// Randomly select one device from the full matching set
var rnd = new Random();
var deviceArn = matchingArns[rnd.Next(matchingArns.Count)];
Console.WriteLine($"Selected device ARN: {deviceArn}");
// 2) Create remote access session and wait until RUNNING
var request = new CreateRemoteAccessSessionRequest
{
ProjectArn = "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
DeviceArn = deviceArn,
AppArn = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", // optional
Configuration = new CreateRemoteAccessSessionConfiguration
{
AuxiliaryApps = new List
{
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
}
}
};
request.Configuration.AuxiliaryApps.RemoveAll(string.IsNullOrWhiteSpace);
var response = await client.CreateRemoteAccessSessionAsync(request);
var sessionArn = response.RemoteAccessSession.Arn;
Console.WriteLine($"Created Remote Access Session: {sessionArn}");
var pollIntervalMs = 3000;
var timeoutMs = 600000;
var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
while (true)
{
var get = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var status = get.RemoteAccessSession.Status.Value;
Console.WriteLine($"Current status: {status}");
if (status == "RUNNING")
{
Console.WriteLine($"Session is ready with status: {status}");
break;
}
if (status == "STOPPING" || status == "COMPLETED")
{
throw new Exception($"Session ended early with status: {status}");
}
if (DateTime.UtcNow >= deadline)
{
throw new TimeoutException("Timed out waiting for session to be ready.");
}
await Task.Delay(pollIntervalMs);
}
}
}
```
------
#### [ Ruby ]
*注意：这些说明仅侧重于创建远程访问会话。有关如何上传应用程序以便在会话期间使用的说明，请参阅[自动上传应用程序](api-ref.md#upload-example)。*
此示例首先在 Device Farm 上找到所有可用的 Google Pixel 设备，然后使用该设备创建远程访问会话并等待会话运行。
```
require 'aws-sdk-devicefarm'
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
# 1) Gather all matching devices via paginated ListDevices with filters
filters = [
{ attribute: 'MODEL', operator: 'CONTAINS', values: ['Pixel'] },
{ attribute: 'AVAILABILITY', operator: 'EQUALS', values: ['AVAILABLE'] },
]
matching_arns = []
next_token = nil
loop do
resp = client.list_devices(filters: filters, next_token: next_token)
resp.devices&.each { |d| matching_arns << d.arn }
next_token = resp.next_token
break unless next_token
end
abort "No available Google Pixel device found." if matching_arns.empty?
# Randomly select one device from the full matching set
device_arn = matching_arns.sample
puts "Selected device ARN: #{device_arn}"
# 2) Create remote access session and wait until RUNNING
resp = client.create_remote_access_session(
project_arn: "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
device_arn: device_arn,
app_arn: "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", # optional
configuration: {
auxiliary_apps: [ # optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
].compact
}
)
session_arn = resp.remote_access_session.arn
puts "Created Remote Access Session: #{session_arn}"
poll_interval = 3
timeout = 600
deadline = Time.now + timeout
terminal = %w[STOPPING COMPLETED]
loop do
get = client.get_remote_access_session(arn: session_arn)
status = get.remote_access_session.status
puts "Current status: #{status}"
if status == 'RUNNING'
puts "Session is ready with status: #{status}"
break
end
abort "Session ended early with status: #{status}" if terminal.include?(status)
abort "Timed out waiting for session to be ready." if Time.now >= deadline
sleep poll_interval
end
```
------
## 后续步骤
一旦请求的设备和基础设施可用，Device Farm 就会立即启动会话，通常在几分钟之内。将会显示**请求的设备**对话框，直到会话开始。要取消会话请求，请选择 **Cancel request (取消请求)**。
如果所选设备不可用或忙碌，则会话状态将显示为 “**待处理设备**”，这表示您可能需要等待一段时间才能使用该设备进行测试。
**如果您的账户已达到公共按流量计费或不按流量计费的设备的并发限制，则会话状态将显示为 “待定并发”。**对于不按流量计费的设备插槽，您可以通过[购买更多](how-to-purchase-device-slots.md)设备插槽来增加并发度。对于按流量计费的 pay-as-you-go设备，请通过支持请求与 AWS 联系，申请[增加服务配额](limits.md)。
**当会话设置开始时，当您的本地 Web 浏览器尝试打开与设备的远程**连接**时，会话设置首先显示为 “进行中” 状态，然后显示为 “正在连接” 状态。**
会话开始后，如果您关闭浏览器或浏览器选项卡而没有停止会话，或者浏览器和 Internet 之间的连接中断，那么在五分钟内会话将保持活动状态。之后，Device Farm 结束会话。但是，我们仍将针对空闲时间向您的账户收费。
会话开始后，您可以在 Web 浏览器中与设备进行交互，或者使用 [Appi](appium-endpoint.md) um 测试设备。
# 在 AWS Device Farm 中使用远程访问会话
有关通过远程访问会话对 Android 和 iOS 应用程序执行交互式测试的信息，请参阅 [会话](sessions.md)。
+ [先决条件](#how-to-use-session-prerequisites)
+ [在 Device Farm 控制台中使用会话](#how-to-use-session-console)
+ [后续步骤](#how-to-use-session-next-steps)
+ [提示与诀窍](#how-to-use-session-tips)
## 先决条件
+ 创建会话。按照[创建会话](how-to-create-session.md)中的说明操作，然后返回此页。
## 在 Device Farm 控制台中使用会话
一旦您为远程访问会话请求的设备变得可用，控制台将会显示该设备屏幕。会话的最大长度为 150 分钟。会话的剩余时间显示在设备名称旁边的**剩余时间**字段中。
### 安装应用程序
要在会话设备上安装应用程序，请在**安装应用程序**中选择**选择文件**，然后选择您要安装的 .apk 文件 (Android) 或 .ipa 文件 (iOS)。您在远程访问会话中运行的应用程序不需要任何测试设备或配置。
**注意**
在您上传应用程序时，有时可能需要等一段时间，应用程序才可用。将出现一条确认消息，告知您该应用程序是否已成功安装。
### 控制设备
您可以使用您的触摸式鼠标或可比设备和设备屏幕上的键盘与控制台中显示的设备交互，就像您与实际的物理设备交互一样。对于 Android 设备，**View controls (查看控件)** 中有一些按钮的功能与 Android 设备上的 **Home (主页)** 和 **Back (返回)** 按钮一样。对于 iOS 设备，**Home (主页)** 按钮的功能与 iOS 设备上的主页按钮一样。您还可以通过选择**近期使用的应用程序** 在设备上运行的应用程序之间切换。
### 在纵向和横向模式之间切换
您还可以在所使用的设备的纵向（垂直）和横向（水平）模式之间切换。
## 后续步骤
Device Farm 会继续会话，直到您手动停止它，或直到达到 150 分钟的时间限制。要结束会话，请选择**停止会话**按钮。会话停止后，您可以访问捕获的视频和生成的日志。有关更多信息，请参阅 [检索会话结果](how-to-access-session-results.md)。
## 提示与诀窍
在某些 AWS 区域，您可能会遇到远程访问会话的性能问题。这部分是由于一些区域中存在延迟。如果您遇到性能问题，请在再次与应用程序交互之前留出一些时间，以便远程访问会话跟上您的步伐。
# 在 AWS Device Farm 中检索远程访问会话的结果
有关会话的更多信息，请参阅[会话](sessions.md)。
+ [先决条件](#how-to-access-session-results-prerequisites)
+ [查看会话详细信息](#how-to-view-session-details)
+ [下载会话视频或日志](#how-to-access-session-files)
## 先决条件
+ 完成会话。按照[在 AWS Device Farm 中使用远程访问会话使用会话](how-to-use-session.md)中的说明操作，然后返回此页。
## 查看会话详细信息
当远程访问会话结束时，Device Farm 控制台会显示一个表，其中包含关于会话期间的活动的详细信息。有关更多信息，请参阅[分析日志信息](how-to-use-reports.md#how-to-use-reports-console-log)。
要想稍后返回到会话的详细信息：
1. 在 Device Farm 导航面板上，选择**移动设备测试**，然后选择**项目**。
1. 选择包含会话的项目。
1. 选择**远程访问**，然后从列表中选择要查看的会话。
## 下载会话视频或日志
当远程访问会话结束时，您可以通过 Device Farm 控制台访问会话的视频捕获和活动日志。在会话结果中，选择 **Files (文件)** 选项卡，以查看会话视频和日志的链接列表。您可以在浏览器中查看这些文件，或将其保存在本地。