Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Interazione con il dispositivo tramite Appium
Dopo aver [creato una sessione di accesso remoto](how-to-create-session.md), il dispositivo sarà disponibile per i test di Appium. Per l'intera durata della sessione di accesso remoto, puoi eseguire tutte le sessioni Appium che desideri sul dispositivo, senza limiti ai client che utilizzi. Ad esempio, puoi iniziare eseguendo un test utilizzando il codice Appium locale dal tuo IDE, quindi passare all'utilizzo di Appium Inspector per risolvere eventuali problemi riscontrati. La sessione può durare fino a [150 minuti](limits.md#service-limits), tuttavia, se non vi è alcuna attività per più di 5 minuti (tramite la console interattiva o tramite l'endpoint Appium), la sessione scadrà.
## Utilizzo delle app per i test con la sessione Appium
Device Farm ti consente di utilizzare le tue app come parte della richiesta di creazione di una sessione di accesso remoto o di installare app durante la sessione di accesso remoto stessa. Queste app vengono installate automaticamente sul dispositivo in esame e vengono inserite come funzionalità predefinite per qualsiasi richiesta di sessione Appium. Quando crei una sessione di accesso remoto, hai la possibilità di passare un'app ARN, che verrà utilizzata di default come `appium:app` funzionalità per tutte le sessioni Appium successive, nonché un'app ausiliaria ARNs, che verrà utilizzata come funzionalità. `appium:otherApps`
Ad esempio, se crei una sessione di accesso remoto utilizzando un'app `com.aws.devicefarm.sample` come app e `com.aws.devicefarm.other.sample` come una delle tue app ausiliarie, quando vai a creare una sessione Appium, avrà funzionalità simili alle seguenti:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
...
}
}
}
```
Durante la sessione, puoi installare app aggiuntive (all'interno della console o utilizzando l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html)API). Queste sostituiranno tutte le app esistenti utilizzate in precedenza come `appium:app` funzionalità. Se le app utilizzate in precedenza hanno un nome di pacchetto distinto, rimarranno sul dispositivo e verranno utilizzate come parte della `appium:otherApps` funzionalità.
Ad esempio, se inizialmente utilizzi un'app `com.aws.devicefarm.sample` durante la creazione della sessione di accesso remoto, ma poi installi una nuova app denominata `com.aws.devicefarm.other.sample` durante la sessione, le sessioni di Appium avranno funzionalità simili alle seguenti:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.other.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
...
}
}
}
```
Se preferisci, puoi specificare in modo esplicito le funzionalità della tua app utilizzando il nome dell'app (utilizzando le `appium:bundleId` funzionalità `appium:appPackage` o rispettivamente per Android e iOS).
Se stai testando un'app web, specifica la `browserName` funzionalità per la tua richiesta di creazione di sessioni Appium. Il `Chrome` browser è disponibile su tutti i dispositivi Android e il `Safari` browser è disponibile su tutti i dispositivi iOS.
Device Farm non supporta il passaggio di un URL remoto o di un percorso di file system locale `appium:app` durante una sessione di accesso remoto. Carica le app su Device Farm e includile invece nella sessione.
**Nota**
Per ulteriori informazioni sul caricamento automatico delle app come parte della sessione di accesso remoto, consulta la sezione [Automatizzazione dei caricamenti delle app](api-ref.md#upload-example).
## Come usare l'endpoint Appium
Ecco i passaggi per accedere all'endpoint Appium della sessione dalla console, dal e dal. AWS CLI AWS SDKs Questi passaggi includono come iniziare a eseguire i test utilizzando vari framework di test dei client Appium:
------
#### [ Console ]
1. Apri la pagina della sessione di accesso remoto nel tuo browser web:
![\[\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint.png)
1. Per eseguire una sessione utilizzando Appium Inspector, procedi come segue:
1. **Fai clic sul pulsante Setup Appium session**
1. Segui le istruzioni sulla pagina per iniziare una sessione utilizzando Appium Inspector.
1. Per eseguire un test Appium dal tuo IDE locale, procedi come segue:
1. Fai clic sull'icona «copia» accanto al testo **Appium** endpoint URL
1. Incolla questo URL nel codice Appium locale ovunque tu specifichi attualmente il tuo indirizzo remoto o l'esecutore di comandi. Per esempi specifici della lingua, fai clic su una delle schede in questa finestra di esempio per la lingua che preferisci.
------
#### [ AWS CLI ]
Innanzitutto, verifica che la tua versione CLI di AWS sia disponibile up-to-date [scaricando e installando la versione più recente](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Importante**
Il campo endpoint Appium non è disponibile nelle versioni precedenti dell'interfaccia a riga di comando di AWS.
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato `remoteDriverEndpoint` nella risposta a una chiamata all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
$ aws devicefarm get-remote-access-session \
--arn "arn:aws:devicefarm:us-west-2:123456789876:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
```
Questo mostrerà un output come il seguente:
```
{
"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": "RUNNING",
"endpoints": {
"remoteDriverEndpoint": "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234...",
...
}
```
È possibile utilizzare questo URL nel codice Appium locale ovunque si specifichi attualmente l'indirizzo remoto o l'esecutore di comandi. Per esempi specifici della lingua, fai clic su una delle schede in questa finestra di esempio per la lingua che preferisci.
Per un esempio di come interagire con l'endpoint direttamente dalla riga di comando, puoi usare lo [strumento](https://curl.se/) da riga di comando curl per chiamare direttamente un endpoint: WebDriver
```
$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"
```
Questo mostrerà un output come il seguente:
```
{
"value":
{
"ready": true,
"message": "The server is ready to accept new connections",
"build":
{
"version": "2.5.1"
}
}
}
```
------
#### [ Python ]
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato `remoteDriverEndpoint` nella risposta a una chiamata all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# To get the URL
import sys
import boto3
from botocore.exceptions import ClientError
def get_appium_endpoint() -> str:
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
device_farm_client = boto3.client("devicefarm", region_name="us-west-2")
try:
resp = device_farm_client.get_remote_access_session(arn=session_arn)
except ClientError as exc:
sys.exit(f"Failed to call Device Farm: {exc}")
remote_access_session = resp.get("remoteAccessSession", {})
endpoints = remote_access_session.get("endpoints", {})
endpoint = endpoints.get("remoteDriverEndpoint")
if not endpoint:
sys.exit("Device Farm response did not include endpoints.remoteDriverEndpoint")
return endpoint
# To use the URL
from appium import webdriver
from appium.options.android import UiAutomator2Options
opts = UiAutomator2Options()
driver = webdriver.Remote(get_appium_endpoint(), options=opts)
# ...
driver.quit()
```
------
#### [ Java ]
*Nota: questo esempio utilizza l' AWS SDK for Java v2 ed è compatibile con le versioni JDK 11 e successive.*
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato `remoteDriverEndpoint` nella risposta a una chiamata all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
public class AppiumEndpointBuilder {
public static String getAppiumEndpoint() throws Exception {
String session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.credentialsProvider(DefaultCredentialsProvider.create())
.build()) {
GetRemoteAccessSessionResponse resp = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(session_arn).build()
);
String endpoint = resp.remoteAccessSession().endpoints().remoteDriverEndpoint();
if (endpoint == null || endpoint.isEmpty()) {
throw new IllegalStateException("remoteDriverEndpoint missing from response");
}
return endpoint;
}
}
}
// To use the URL
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URL;
public class ExampleTest {
public static void main(String[] args) throws Exception {
String endpoint = AppiumEndpointBuilder.getAppiumEndpoint();
UiAutomator2Options options = new UiAutomator2Options();
AndroidDriver driver = new AndroidDriver(new URL(endpoint), options);
try {
// ... your test ...
} finally {
driver.quit();
}
}
}
```
------
#### [ JavaScript ]
*Nota: questo esempio utilizza AWS SDK per JavaScript v3 e WebDriveRio v8\$1 utilizzando Node 18\$1.*
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato nella risposta a una chiamata `remoteDriverEndpoint` all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm";
export async function getAppiumEndpoint() {
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
const client = new DeviceFarmClient({ region: "us-west-2" });
const resp = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const endpoint = resp?.remoteAccessSession?.endpoints?.remoteDriverEndpoint;
if (!endpoint) throw new Error("remoteDriverEndpoint missing from response");
return endpoint;
}
// To use the URL with WebdriverIO
import { remote } from "webdriverio";
(async () => {
const endpoint = await getAppiumEndpoint();
const u = new URL(endpoint);
const driver = await remote({
protocol: u.protocol.replace(":", ""),
hostname: u.hostname,
port: u.port ? Number(u.port) : (u.protocol === "https:" ? 443 : 80),
path: u.pathname + u.search,
capabilities: {
platformName: "Android",
"appium:automationName": "UiAutomator2",
// ...other caps...
},
});
try {
// ... your test ...
} finally {
await driver.deleteSession();
}
})();
```
------
#### [ C\$1 ]
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato `remoteDriverEndpoint` nella risposta a una chiamata all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
using System;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
public static class AppiumEndpointBuilder
{
public static async Task GetAppiumEndpointAsync()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
var config = new AmazonDeviceFarmConfig
{
RegionEndpoint = RegionEndpoint.USWest2
};
using var client = new AmazonDeviceFarmClient(config);
var resp = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var endpoint = resp?.RemoteAccessSession?.Endpoints?.RemoteDriverEndpoint;
if (string.IsNullOrWhiteSpace(endpoint))
throw new InvalidOperationException("RemoteDriverEndpoint missing from response");
return endpoint;
}
}
// To use the URL
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;
class Example
{
static async Task Main()
{
var endpoint = await AppiumEndpointBuilder.GetAppiumEndpointAsync();
var options = new AppiumOptions();
options.PlatformName = "Android";
options.AutomationName = "UiAutomator2";
using var driver = new AndroidDriver(new Uri(endpoint), options);
try
{
// ... your test ...
}
finally
{
driver.Quit();
}
}
}
```
------
#### [ Ruby ]
Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato `remoteDriverEndpoint` nella risposta a una chiamata all'API: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# To get the URL
require 'aws-sdk-devicefarm'
def get_appium_endpoint
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
resp = client.get_remote_access_session(arn: session_arn)
endpoint = resp.remote_access_session.endpoints.remote_driver_endpoint
raise "remote_driver_endpoint missing from response" if endpoint.nil? || endpoint.empty?
endpoint
end
# To use the URL
require 'appium_lib_core'
endpoint = get_appium_endpoint
opts = {
server_url: endpoint,
capabilities: {
'platformName' => 'Android',
'appium:automationName' => 'UiAutomator2'
}
}
driver = Appium::Core.for(opts).start_driver
begin
# ... your test ...
ensure
driver.quit
end
```
------