Application - AgentBay: Central de Documentação do Alibaba Cloud

Descrição

A classe Application gerencia aplicativos no ambiente de nuvem AgentBay. Ela permite listar aplicativos instalados, iniciar aplicativos e interromper processos em execução.

Método	Descrição	Ambiente
Método	Descrição	Linux Computer Use	Windows Computer Use	Browser Use	Mobile Use	Code Space
`get_installed_apps`	Obtém os aplicativos instalados com filtragem opcional por menu Iniciar e atalhos da área de trabalho. Permite excluir aplicativos do sistema.	Não suportado	Suportado	Não suportado	Suportado	Não suportado
`list_visible_apps`	Lista todos os aplicativos com janelas visíveis.	Não suportado	Suportado	Não suportado	Não suportado	Não suportado
`start_app`	Inicia o aplicativo especificado com diretório de trabalho opcional. No Android, também permite especificar uma Activity.	Não suportado	Suportado	Não suportado	Suportado	Não suportado
`stop_app_by_pname`	Interrompe um aplicativo pelo nome do processo.	Não suportado	Suportado	Não suportado	Não suportado	Não suportado
`stop_app_by_pid`	Interrompe um aplicativo pelo ID do processo.	Não suportado	Suportado	Não suportado	Não suportado	Não suportado
`stop_app_by_cmd`	Interrompe um aplicativo executando um comando específico.	Não suportado	Suportado	Não suportado	Suportado	Não suportado

Propriedades

Propriedade	Descrição
Name	Nome do aplicativo.
StartCmd	Comando de inicialização.
StopCmd	(Opcional) Comando de encerramento.
WorkDirectory	(Opcional) Diretório de trabalho.
PName	Nome do processo.
PID	ID do processo.
CmdLine	(Opcional) Parâmetros de linha de comando.

Métodos

`GetInstalledApps` - Obter aplicativos instalados

Golang

func (am *ApplicationManager) GetInstalledApps(includeSystemApps bool, includeStoreApps bool, includeDesktopApps bool) (*InstalledAppsResult, error)

Parâmetros:

includeSystemApps (bool): Define se os aplicativos do sistema devem ser incluídos.
includeStoreApps (bool): Define se os aplicativos da loja devem ser incluídos.
includeDesktopApps (bool): Define se os aplicativos da área de trabalho devem ser incluídos.

Valores de retorno:

*InstalledAppsResult: Objeto de resultado que contém a lista de aplicativos instalados e o ID da solicitação.
error: Mensagem de erro retornada caso a operação falhe.

Estrutura InstalledAppsResult:

type InstalledAppsResult struct {
    RequestID string         // A unique request identifier for debugging.
    Apps      []*InstalledApp // An array of installed applications.
}

type InstalledApp struct {
    Name        string // The application name.
    Path        string // The application path.
    Version     string // The application version.
    Description string // The application description.
}

Python

def get_installed_apps(
    self,
    include_system_apps: bool = True,
    include_store_apps: bool = False,
    include_desktop_apps: bool = True
) -> List[InstalledApp]:

Parâmetros:

include_system_apps (bool, opcional): Define se os aplicativos do sistema devem ser incluídos. O padrão é True.
include_store_apps (bool, opcional): Define se os aplicativos da loja devem ser incluídos. O padrão é False.
include_desktop_apps (bool, opcional): Define se os aplicativos da área de trabalho devem ser incluídos. O padrão é True.

Valor de retorno:

List[InstalledApp]: Lista de aplicativos instalados.

Exceção:

ApplicationError: Lançada se a obtenção da lista de aplicativos instalados falhar.

TypeScript

async getInstalledApps(
    includeSystemApps: boolean = true,
    includeStoreApps: boolean = false,
    includeDesktopApps: boolean = true
): Promise<InstalledApp[]>

Parâmetros:

includeSystemApps (boolean, opcional): Define se os aplicativos do sistema devem ser incluídos. O padrão é true.
includeStoreApps (boolean, opcional): Define se os aplicativos da loja devem ser incluídos. O padrão é false.
includeDesktopApps (boolean, opcional): Define se os aplicativos da área de trabalho devem ser incluídos. O padrão é true.

Valor de retorno:

Promise<InstalledApp[]>: Promise resolvida com uma lista de aplicativos instalados.

Exceções:

APIError: Lançada se a obtenção da lista de aplicativos instalados falhar.

`StartApp` - Iniciar um aplicativo

Golang

func (am *ApplicationManager) StartApp(startCmd string, workDirectory string) (string, error)

Parâmetros:

startCmd (string): Comando para iniciar o aplicativo.
workDirectory (string): Diretório de trabalho do aplicativo.

Valores de retorno:

string: String JSON que contém a lista de processos iniciados.
error: Mensagem de erro retornada caso a operação falhe.

Python

def start_app(self, start_cmd: str, work_directory: str = "") -> List[Process]:

Parâmetros:

start_cmd (str): Comando para iniciar o aplicativo.
work_directory (str, opcional): Diretório de trabalho do aplicativo. O padrão é uma string vazia.

Valor de retorno:

List[Process]: Lista de processos iniciados.

Exceções:

ApplicationError: Lançada se a inicialização do aplicativo falhar.

TypeScript

async startApp(startCmd: string, workDirectory: string = ""): Promise<Process[]>

Parâmetros:

startCmd (string): Comando para iniciar o aplicativo.
workDirectory (string, opcional): Diretório de trabalho do aplicativo. O padrão é uma string vazia.

Valor de retorno:

Promise<Process[]>: Promise resolvida com uma lista de processos iniciados.

Exceções:

APIError: Lançada se a inicialização do aplicativo falhar.

`StopAppByPName` - Interromper um aplicativo pelo nome do processo

Golang

func (am *ApplicationManager) StopAppByPName(pname string) (string, error)

Parâmetro:

pname (string): Nome do processo a ser interrompido.

Valores de retorno:

string: Mensagem indicando sucesso da operação.
error: Mensagem de erro retornada caso a operação falhe.

Python

def stop_app_by_pname(self, pname: str) -> bool:

Parâmetros:

pname (str): Nome do processo a ser interrompido.

Valor de retorno:

bool: Retorna True se a operação for bem-sucedida. Caso contrário, retorna False.

Exceções:

ApplicationError: Lançada se a interrupção do aplicativo falhar.

TypeScript

async stopAppByPName(pname: string): Promise<boolean>

Parâmetro:

pname (string): Nome do processo a ser interrompido.

Valor de retorno:

Promise<boolean>: Retorna true se a operação for bem-sucedida ou false caso contrário.

Exceção:

APIError: Lançada se a interrupção do aplicativo falhar.

`StopAppByPID` - Interromper um aplicativo pelo ID do processo

Golang

func (am *ApplicationManager) StopAppByPID(pid int) (string, error)

Parâmetros:

pid (int): ID do processo a ser interrompido.

Valores de retorno:

string: Mensagem indicando sucesso da operação.
error: Mensagem de erro retornada caso a operação falhe.

Python

def stop_app_by_pid(self, pid: int) -> bool:

Parâmetros:

pid (int): ID do processo a ser interrompido.

Valor de retorno:

bool: Retorna True se a operação for bem-sucedida. Caso contrário, retorna False.

Exceções:

ApplicationError: Lançada se a interrupção do aplicativo falhar.

TypeScript

async stopAppByPid(pid: number): Promise<boolean>

Parâmetros:

pid (number): ID do processo a ser interrompido.

Valor de retorno:

Promise<boolean>: Promise resolvida com true se a operação for bem-sucedida ou false caso contrário.

Exceções:

APIError: Lançada se a interrupção do aplicativo falhar.

`StopAppByCmd` - Interromper um aplicativo por comando de encerramento

Golang

func (am *ApplicationManager) StopAppByCmd(stopCmd string) (string, error)

Parâmetros:

stopCmd (string): Comando utilizado para interromper o aplicativo.

Valores de retorno:

string: Mensagem indicando sucesso da operação.
error: Mensagem de erro retornada caso a operação falhe.

Python

def stop_app_by_cmd(self, stop_cmd: str) -> bool:

Parâmetros:

stop_cmd (str): Comando utilizado para interromper o aplicativo.

Valor de retorno:

bool: Retorna True se a operação for bem-sucedida. Caso contrário, retorna False.

Exceções:

ApplicationError: Lançada se a interrupção do aplicativo falhar.

TypeScript

async stopAppByCmd(stopCmd: string): Promise<boolean>

Parâmetros:

stopCmd (string): Comando utilizado para interromper o aplicativo.

Valor de retorno:

Promise<boolean>: Promise resolvida com true se a operação for bem-sucedida ou false caso contrário.

Exceções:

APIError: Lançada se a interrupção do aplicativo falhar.

ListVisibleApps - Listar aplicativos visíveis

Golang

func (am *ApplicationManager) ListVisibleApps() (*VisibleAppsResult, error)

Valores de retorno:

*VisibleAppsResult: Objeto de resultado que contém a lista de processos visíveis e o ID da solicitação.
error: Mensagem de erro retornada caso a operação falhe.

Estrutura VisibleAppsResult:

type VisibleAppsResult struct {
    RequestID string     // A unique request identifier for debugging.
    Processes []*Process // An array of visible processes.
}

type Process struct {
    PName string // The process name.
    PID   int    // The process ID.
}

Python

def list_visible_apps(self) -> List[Process]:

Valor de retorno:

List[Process]: Lista de processos visíveis.

Exceções:

ApplicationError: Lançada se a listagem de aplicativos visíveis falhar.

TypeScript

async listVisibleApps(): Promise<Process[]>

Valor de retorno:

Promise<Process[]>: Promise resolvida com uma lista de processos visíveis.

Exceções:

APIError: Lançada se a listagem de aplicativos visíveis falhar.

Exemplos de gerenciamento de aplicativos

Golang

package main

import (
    "fmt"
    "log"
)

func main() {
    // Create a session
    agentBay := agentbay.NewAgentBay("your-api-key")
    sessionResult, err := agentBay.Create(nil)
    if err != nil {
        log.Fatal(err)
    }
    session := sessionResult.Session

    // Get installed applications
    appsResult, err := session.Application.GetInstalledApps(true, false, true)
    if err != nil {
        log.Printf("Error getting installed applications: %v", err)
    } else {
        for _, app := range appsResult.Apps {
            fmt.Printf("Application: %s\n", app.Name)
        }
    }

    // Start an application
    processesResult, err := session.Application.StartApp("/usr/bin/google-chrome-stable", "")
    if err != nil {
        log.Printf("Error starting application: %v", err)
    } else {
        var processes []Process
        _ = json.Unmarshal([]byte(processesResult), &processes)
        for _, process := range processes {
            fmt.Printf("Started process: %s (PID: %d)\n", process.PName, process.PID)
        }
    }

    // List visible applications
    visibleResult, err := session.Application.ListVisibleApps()
    if err != nil {
        log.Printf("Error listing visible applications: %v", err)
    } else {
        for _, app := range visibleResult.Processes {
            fmt.Printf("Visible application: %s (PID: %d)\n", app.PName, app.PID)
        }
    }

    // Stop the application by PID
    if len(processes) > 0 {
        success, err := session.Application.StopAppByPID(processes[0].PID)
        if err != nil {
            log.Printf("Error stopping application: %v", err)
        } else {
            fmt.Printf("Application stopped: %s\n", success)
        }
    }
}

TypeScript

import { AgentBay } from 'wuying-agentbay-sdk';

// Initialize the SDK
const agentBay = new AgentBay({ apiKey: 'your_api_key' });

// Get installed applications
async function getApplications() {
  try {
    const apps = await agentBay.application.getInstalledApps();
    console.log(`Found ${apps.length} applications:`);
    apps.forEach(app => {
      console.log(`Name: ${app.name}, Start Cmd: ${app.start_cmd}`);
    });
  } catch (error) {
    console.error('Error retrieving applications:', error);
  }
}

// Start an application
async function startApplication() {
  try {
    const processes = await agentBay.application.startApp('/usr/bin/google-chrome-stable');
    console.log(`Started ${processes.length} processes:`);
    processes.forEach(p => {
      console.log(`Process Name: ${p.pname}, PID: ${p.pid}`);
    });
  } catch (error) {
    console.error('Error starting application:', error);
  }
}

// Stop an application by PID
async function stopApplicationByPID() {
  try {
    const success = await agentBay.application.stopAppByPid(12345);
    if (success) {
      console.log('Application stopped successfully.');
    } else {
      console.log('Failed to stop application.');
    }
  } catch (error) {
    console.error('Error stopping application:', error);
  }
}

// List visible applications
async function listVisibleApplications() {
  try {
    const visibleApps = await agentBay.application.listVisibleApps();
    console.log(`Visible applications: ${visibleApps.length}`);
    visibleApps.forEach(app => {
      console.log(`Name: ${app.pname}, PID: ${app.pid}`);
    });
  } catch (error) {
    console.error('Error listing visible applications:', error);
  }
}

Descrição

Propriedades

Métodos

GetInstalledApps - Obter aplicativos instalados

Golang

Parâmetros:

Valores de retorno:

Estrutura InstalledAppsResult:

Python

Parâmetros:

Valor de retorno:

Exceção:

TypeScript

Parâmetros:

Valor de retorno:

Exceções:

StartApp - Iniciar um aplicativo

Golang

Parâmetros:

Valores de retorno:

Python

Parâmetros:

Valor de retorno:

Exceções:

TypeScript

Parâmetros:

Valor de retorno:

Exceções:

StopAppByPName - Interromper um aplicativo pelo nome do processo

Golang

Parâmetro:

Valores de retorno:

Python

Parâmetros:

Valor de retorno:

Exceções:

TypeScript

Parâmetro:

Valor de retorno:

Exceção:

StopAppByPID - Interromper um aplicativo pelo ID do processo

Golang

Parâmetros:

Valores de retorno:

Python

Parâmetros:

Valor de retorno:

Exceções:

TypeScript

Parâmetros:

Valor de retorno:

Exceções:

StopAppByCmd - Interromper um aplicativo por comando de encerramento

Golang

Parâmetros:

Valores de retorno:

Python

Parâmetros:

Valor de retorno:

Exceções:

TypeScript

Parâmetros:

Valor de retorno:

Exceções:

ListVisibleApps - Listar aplicativos visíveis

Golang

Valores de retorno:

Estrutura VisibleAppsResult:

Python

Valor de retorno:

Exceções:

TypeScript

Valor de retorno:

Exceções:

Exemplos de gerenciamento de aplicativos

Golang

TypeScript

`GetInstalledApps` - Obter aplicativos instalados

`StartApp` - Iniciar um aplicativo

`StopAppByPName` - Interromper um aplicativo pelo nome do processo

`StopAppByPID` - Interromper um aplicativo pelo ID do processo

`StopAppByCmd` - Interromper um aplicativo por comando de encerramento