本文提供火山引擎的 Java SDK、Python SDK 以及 Golang SDK 调用云手机服务端 OpenAPI 的示例代码供您参考。

Java

1. 在项目中引入火山引擎 Java SDK 依赖。
   了解火山引擎 Java SDK，请参见 Volcengine SDK for Java。

   <!-- https://mvnrepository.com/artifact/com.volcengine/volcengine-java-sdk-core -->
   <dependency>
       <groupId>com.volcengine</groupId>
       <artifactId>volcengine-java-sdk-core</artifactId>
       <version>1.0.75</version>
   </dependency>
   

2. 调用 OpenAPI。
   示例代码如下，代码中使用 UniversalApi 确定请求类型，支持传入以下参数：

   • ak/sk：火山引擎账号的 API 访问秘钥（Access Key），获取方式请参见 Access Key（密钥）管理。
   • Region：保持默认 Region 即可。
   • ServiceName：具体的服务名称，云手机的服务名称为 ACEP。
   • Action：OpenAPI 名称，可从相应 API 文档中的 请求参数 Query > Action 字段 获取。
   • Version：OpenAPI 版本号，可从相应 API 文档中的 请求参数 Query > Version 字段 获取。
   • HttpMethod：OpenAPI 的请求方式（Get 或 POST），可从相应 API 文档中的 请求说明 > 请求方式 获取。
   • ContentType：请求时如果 Body 里有参数，则需要设置为 application/json。

   import com.volcengine.*;
   import com.volcengine.sign.Credentials;
   
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Objects;
   
   public class Main {
   
       public static void main(String[] args) throws ApiException {
           String ak = System.getenv("VOLC_ACCESSKEY");
           String sk = System.getenv("VOLC_SECRETKEY");
   
           ApiClient apiClient = new ApiClient()
                   .setCredentials(Credentials.getCredentials(ak, sk))
                   .setRegion("cn-north-1");
   
           UniversalApi universalApi = new UniversalApi(apiClient);
   
           UniversalRequest req = new UniversalRequest();
           req.setServiceName("ACEP");
           req.setAction("DetailPod");
           req.setVersion("2023-10-30");
           req.setHttpMethod(HttpMethod.GET);
           //req.setContentType(ContentType.ApplicationJSON);
   
           DetailPodInput input = new DetailPodInput();
           input.ProductID = "123****";
           input.PodID = "456****";
           Map<String, Object> output=  universalApi.doCall(req, input.toMap());
   
           System.out.println(output);
       }
   }
   
   class DetailPodInput{
       String ProductID;
       String PodID;
   
       public Map<String, Object> toMap() {
           Gson gson = new Gson();
           Type type = new TypeToken<Map<String, Object>>() {
           }.getType();
       
           return gson.fromJson(gson.toJson(this), type);
       }
   }
   

Python

1. 在项目中安装火山引擎 Python SDK 依赖。
   了解火山引擎 Python SDK，请参见 Volcengine SDK for Python。

   pip install volcengine-python-sdk
   

2. 调用 OpenAPI。
   示例代码如下，代码中使用 UniversalApi 构建请求对象，使用 UniversalInfo 确定请求类型，支持传入以下参数：

   • ak/sk：火山引擎账号的 API 访问秘钥（Access Key），获取方式请参见 Access Key（密钥）管理。
   • region：保持默认 region 即可。
   • method：OpenAPI 的请求方式（Get 或 POST），可从相应 API 文档中的 请求说明 > 请求方式 获取。
   • action：OpenAPI 名称，可从相应 API 文档中的 请求参数 Query > Action 字段 获取。
   • service：具体的服务名称，云手机的服务名称为 ACEP。
   • version：OpenAPI 版本号，可从相应 API 文档中的 请求参数 Query > Version 字段 获取。
   • content_type：请求时如果 Body 里有参数，则需要设置为 application/json。

   POST 请求示例代码：

   import os
   import volcenginesdkcore
   from volcenginesdkcore.rest import ApiException
   
   if __name__ == '__main__':
       ak = os.environ.get("VOLC_ACCESSKEY")
       sk = os.environ.get("VOLC_SECRETKEY")
       configuration = volcenginesdkcore.Configuration()
       configuration.ak = ak
       configuration.sk = sk
       configuration.region = "cn-north-1"
   
       # 使用配置，创建自定义GET请求客户端
       api_instance = volcenginesdkcore.UniversalApi(volcenginesdkcore.ApiClient(configuration))
       try:
           # 构建请求参数
           body = volcenginesdkcore.Flatten(
               {
                   "ProductId": "19106188145637xxxx",
                   "PodId": "7491992683733xxxx",
                   "RoundId": "uyx9x",
               }
           ).flat()
           # 发起请求并处理返回或异常
           resp = api_instance.do_call(volcenginesdkcore.UniversalInfo(
               method="POST", action="ScreenShot", service = "ACEP", version = "2023-10-30", content_type="application/json"
           ), body)
           print(resp)
       except ApiException as e:
           print("Exception when call ACEPApi:ScreenShot: %s\n" % e)
   

   GET 请求示例代码：

   import os
   import volcenginesdkcore
   from volcenginesdkcore.rest import ApiException
   
   if __name__ == '__main__':
       ak = os.environ.get("VOLC_ACCESSKEY")
       sk = os.environ.get("VOLC_SECRETKEY")
       configuration = volcenginesdkcore.Configuration()
       configuration.ak = ak
       configuration.sk = sk
       configuration.region = "cn-north-1"
   
       # 使用配置，创建自定义GET请求客户端
       api_instance = volcenginesdkcore.UniversalApi(volcenginesdkcore.ApiClient(configuration))
       try:
           # 构建请求参数
           body = volcenginesdkcore.Flatten(
               {
                   "ProductId": "123****",
                   "PodId": "456****"
               }
           ).flat()
           # 发起请求并处理返回或异常
           resp = api_instance.do_call(volcenginesdkcore.UniversalInfo(
               method="GET", action="DetailPod", service = "ACEP", version = "2023-10-30", content_type="application/json"
           ), body)
           print(resp)
       except ApiException as e:
           print("Exception when call ACEPApi:DetailPod: %s\n" % e)
   

Golang

火山引擎 Golang SDK 的详细说明，请参见 Volcengine SDK for Go。示例代码及参数说明如下：

• ak/sk：火山引擎账号的 API 访问秘钥（Access Key），获取方式请参见 Access Key（密钥）管理。
• region：保持默认 region 即可。
• Action：OpenAPI 名称，可从相应 API 文档中的 请求参数 Query > Action 字段 获取。
• Version：OpenAPI 版本号，可从相应 API 文档中的 请求参数 Query > Version 字段 获取。
• ServiceName：具体的服务名称，云手机的服务名称为 ACEP。
• HttpMethod：OpenAPI 的请求方式（Get 或 POST），可从相应 API 文档中的 请求说明 > 请求方式 获取。
• ContentType：请求时如果 Body 里有参数，则需要设置为 application/json。

import (
    "encoding/json"
    "fmt"
    "os"
    "testing"

    "github.com/volcengine/volcengine-go-sdk/volcengine"
    "github.com/volcengine/volcengine-go-sdk/volcengine/response"
    "github.com/volcengine/volcengine-go-sdk/volcengine/session"
    "github.com/volcengine/volcengine-go-sdk/volcengine/universal"
)

type DetailPodReq struct {
    // 业务 ID
    ProductId string `json:"ProductId"`
    
    // 实例 ID
    PodId string `json:"PodId"`
}

type ResResponseMetadata struct {
    // REQUIRED; 接口名称，与具体的接口相关，表示要执行的操作
    Action string `json:"Action"`

    // REQUIRED; 服务区域
    Region string `json:"Region"`

    // REQUIRED; 请求 ID
    RequestID string `json:"RequestId"`

    // REQUIRED; 服务名称
    Service string `json:"Service"`

    // REQUIRED; 接口版本
    Version string               `json:"Version"`
    Error   *ResResponseMetadata `json:"Error,omitempty"`
}

type DetailPodResResultRowItem struct {
    // ADB 地址，空表示未开启 ADB，例如： 123.33.123.12:1234
    Adb *string `json:"Adb,omitempty"`

    // ADB 过期时间（小于等于0为无过期时间）
    AdbExpireTime *int64 `json:"AdbExpireTime,omitempty"`

    // 代表实例 ADB 开启状态：1（开启）、0（关闭）
    AdbStatus *int32 `json:"AdbStatus,omitempty"`

    // 实例镜像版本
    AospVersion *string `json:"AospVersion,omitempty"`

    // 实例授权运维过期时间
    AuthorityExpireTime *int64 `json:"AuthorityExpireTime,omitempty"`

    // 实例授权运维状态： - 1（未授权） - 2（已授权）
    AuthorityStatus *int32 `json:"AuthorityStatus,omitempty"`

    // 实例创建时间
    CreateAt *int64 `json:"CreateAt,omitempty"`

    // 创建实例的用户存储分区大小，即 data 分区容量大小，可选的容量如下：
    // * 4Gi
    // * 8Gi
    // * 16Gi
    // * 32Gi
    // * 64Gi
    // * 128Gi
    // * 256Gi
    DataSize *string `json:"DataSize,omitempty"`

    // 屏幕布局 ID
    DisplayLayoutID *string `json:"DisplayLayoutId,omitempty"`

    // 屏幕推流状态（key 为屏幕 ID；value 为推流状态，参考以下 Status 定义） 注：通过 DetailPod 接口查询时返回；通过 DetailPod 接口查询时返回的值无实际意义，可忽略
    DisplayStatus map[string]*int32 `json:"DisplayStatus,omitempty"`

    // 实例下行带宽上限（单位：Mbps）
    DownBandwidthLimit *int32 `json:"DownBandwidthLimit,omitempty"`

    // 云机ID
    HostID *string `json:"HostId,omitempty"`

    // 镜像 ID
    ImageID *string `json:"ImageId,omitempty"`

    // 镜像名称
    ImageName *string `json:"ImageName,omitempty"`

    // 实例的内网 IP
    IntranetIP *string `json:"IntranetIP,omitempty"`

    // 实例在线状态： - 0（开机中） - 1（运行中） - 2（已关机） - 3（关机中） - 4（重启中）
    Online *int32 `json:"Online,omitempty"`

    // 实例 ID
    PodID *string `json:"PodId,omitempty"`

    // 实例上行带宽上限（单位：Mbps）
    UpBandwidthLimit *int32 `json:"UpBandwidthLimit,omitempty"`
}

type DetailPodResResult struct {
    Metadata *response.ResponseMetadata
    // 列表行信息
    Row []*DetailPodResResultRowItem `json:"Row,omitempty"`

    // 总数
    Total *int64 `json:"Total,omitempty"`
}

func TestVolcEngine(t *testing.T) {
    var err error
    sess := getSess()

    volcCli := universal.New(sess)

    res := DetailPodResResult{}

    err = volcCli.DoCallWithType(universal.RequestUniversal{
       Action:      "DetailPod",
       Version:     "2023-10-30",
       ServiceName: "ACEP",
       HttpMethod:  universal.GET,
    }, &DetailPodReq{
       ProductId: "18446317912****",
       PodId: "7235890322201****",
    }, &res)

    if err != nil {
       panic(err)
    }

    data, _ := json.Marshal(res)

    fmt.Printf("res: %s \n", data)

}

func getSess() *session.Session {
    var (
       akStr  string
       skStr  string
       region string
       config *volcengine.Config
       sess   *session.Session

       err error
    )
    akStr = os.Getenv("VOLC_ACCESSKEY")
    skStr = os.Getenv("VOLC_SECRETKEY")
    region = "cn-north-1"
    config = volcengine.NewConfig().
       WithAkSk(akStr, skStr).
       WithRegion(region)

    sess, err = session.NewSession(config)
    if err != nil {
       panic(err)
    }
    return sess
}