feat: 支持shoots协议，新增UIAgent驱动接口

hrp/pkg/uixt/action.go

@@ -29,6 +29,7 @@ const (
 	ACTION_SetClipboard ActionMethod = "set_clipboard"
 	ACTION_GetClipboard ActionMethod = "get_clipboard"
 	ACTION_SetIme       ActionMethod = "set_ime"
+	ACTION_GetSource    ActionMethod = "get_source"
 
 	// UI validation
 	// selectors
@@ -616,6 +617,15 @@ func (dExt *DriverExt) DoAction(action MobileAction) (err error) {
 			}
 			return nil
 		}
+	case ACTION_GetSource:
+		if packageName, ok := action.Params.(string); ok {
+			source := NewSourceOption().WithProcessName(packageName)
+			_, err = dExt.Driver.Source(source)
+			if err != nil {
+				return errors.Wrap(err, "failed to set ime")
+			}
+			return nil
+		}
 	case ACTION_TapXY:
 		if location, ok := action.Params.([]interface{}); ok {
 			// relative x,y of window size: [0.5, 0.5]

hrp/pkg/uixt/android_adb_driver.go

@@ -3,6 +3,7 @@ package uixt
 import (
 	"bufio"
 	"bytes"
+	"encoding/json"
 	"encoding/xml"
 	"fmt"
 	"io/fs"
@@ -218,10 +219,18 @@ func (ad *adbDriver) Orientation() (orientation Orientation, err error) {
 }
 
 func (ad *adbDriver) Homescreen() (err error) {
-	return ad.PressKeyCode(KCHome, KMEmpty)
+	return ad.PressKeyCodes(KCHome, KMEmpty)
 }
 
-func (ad *adbDriver) PressKeyCode(keyCode KeyCode, metaState KeyMeta) (err error) {
+func (ad *adbDriver) Unlock() (err error) {
+	return ad.PressKeyCodes(KCMenu, KMEmpty)
+}
+
+func (ad *adbDriver) PressKeyCode(keyCode KeyCode) (err error) {
+	return ad.PressKeyCodes(keyCode, KMEmpty)
+}
+
+func (ad *adbDriver) PressKeyCodes(keyCode KeyCode, metaState KeyMeta) (err error) {
 	// adb shell input keyevent <keyCode>
 	_, err = ad.adbClient.RunShellCommand(
 		"input", "keyevent", fmt.Sprintf("%d", keyCode))
@@ -507,6 +516,10 @@ func (ad *adbDriver) Source(srcOpt ...SourceOption) (source string, err error) {
 	return
 }
 
+func (ad *adbDriver) LoginNoneUI(packageName, phoneNumber string, captcha string) error {
+	return errDriverNotImplemented
+}
+
 func (ad *adbDriver) sourceTree(srcOpt ...SourceOption) (sourceTree *Hierarchy, err error) {
 	source, err := ad.Source()
 	if err != nil {
@@ -693,51 +706,21 @@ func (ad *adbDriver) GetDriverResults() []*DriverResult {
 }
 
 func (ad *adbDriver) GetForegroundApp() (app AppInfo, err error) {
-	// adb shell dumpsys activity activities
-	output, err := ad.adbClient.RunShellCommand("dumpsys", "activity", "activities")
+	packageInfo, err := ad.adbClient.RunShellCommand("CLASSPATH=/data/local/tmp/eval_tool", "app_process", "/", "com.bytedance.iesqa.eval_process.PackageService")
 	if err != nil {
-		log.Error().Err(err).Msg("failed to dumpsys activities")
-		return AppInfo{}, errors.Wrap(err, "dumpsys activities failed")
+		return app, err
 	}
-
-	lines := strings.Split(string(output), "\n")
-	for _, line := range lines {
-		trimmedLine := strings.TrimSpace(line)
-		// grep mResumedActivity|ResumedActivity
-		if strings.HasPrefix(trimmedLine, "mResumedActivity:") || strings.HasPrefix(trimmedLine, "ResumedActivity:") {
-			// mResumedActivity: ActivityRecord{9656d74 u0 com.android.settings/.Settings t407}
-			// ResumedActivity: ActivityRecord{8265c25 u0 com.android.settings/.Settings t73}
-			strs := strings.Split(trimmedLine, " ")
-			for _, str := range strs {
-				if strings.Contains(str, "/") {
-					// com.android.settings/.Settings
-					s := strings.Split(str, "/")
-					app := AppInfo{
-						AppBaseInfo: AppBaseInfo{
-							PackageName: s[0],
-							Activity:    s[1],
-						},
-					}
-					return app, nil
-				}
-			}
-		}
-	}
-
-	return AppInfo{}, errors.Wrap(code.MobileUIAssertForegroundAppError, "get foreground app failed")
+	log.Info().Msg(packageInfo)
+	err = json.Unmarshal([]byte(strings.TrimSpace(packageInfo)), &app)
+	return
 }
 
 func (ad *adbDriver) GetFocusedPackage() (packageName string, err error) {
-	res, err := ad.adbClient.RunShellCommand("dumpsys", "window", "windows", "|", "grep", "-E", "'mCurrentFocus|mFocusedApp'")
+	res, err := ad.adbClient.RunShellCommand("dumpsys", "activity", "activities", "|", "grep", "-E", "'mResumedActivity'")
 	if err != nil {
 		return "", err
 	}
-	match := regexp.MustCompile("mCurrentFocus.+\\s([^\\s/}]+)/[^\\s/}]+(\\.[^\\s/}]+)}").FindStringSubmatch(res)
-	if len(match) > 1 {
-		packageName = match[1]
-		return
-	}
-	match = regexp.MustCompile("mFocusedApp.+Record\\{.*\\s([^\\s/}]+)/([^\\s/}]+)(\\s[^\\s/}]+)*}").FindStringSubmatch(res)
+	match := regexp.MustCompile(`mResumedActivity:.*? (\S+)/`).FindStringSubmatch(res)
 	if len(match) > 1 {
 		packageName = match[1]
 		return
@@ -778,7 +761,7 @@ func (ad *adbDriver) SetIme(imeRegx string) error {
 				currentPackage, err := ad.GetFocusedPackage()
 				log.Info().Str("beforeFocusedPackage", focusedPackage).Str("afterFocusedPackage", currentPackage).Msg("")
 				if err == nil && currentPackage != focusedPackage {
-					_ = ad.PressKeyCode(KCBack, KMEmpty)
+					_ = ad.PressKeyCodes(KCBack, KMEmpty)
 				}
 			}
 		}

hrp/pkg/uixt/android_device.go

@@ -4,9 +4,11 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"embed"
 	"fmt"
 	"os/exec"
 	"strings"
+	"time"
 
 	"github.com/httprunner/funplugin/myexec"
 	"github.com/pkg/errors"
@@ -25,6 +27,9 @@ var (
 	UIA2ServerPort = 6790
 )
 
+//go:embed eval_tool
+var evalTool embed.FS
+
 const forwardToPrefix = "forward-to-"
 
 type AndroidDeviceOption func(*AndroidDevice)
@@ -41,6 +46,12 @@ func WithUIA2(uia2On bool) AndroidDeviceOption {
 	}
 }
 
+func WithShoots(shootsOn bool) AndroidDeviceOption {
+	return func(device *AndroidDevice) {
+		device.SHOOTS = shootsOn
+	}
+}
+
 func WithUIA2IP(ip string) AndroidDeviceOption {
 	return func(device *AndroidDevice) {
 		device.UIA2IP = ip
@@ -109,7 +120,14 @@ func NewAndroidDevice(options ...AndroidDeviceOption) (device *AndroidDevice, er
 
 	device.d = dev
 	device.logcat = NewAdbLogcat(device.SerialNumber)
-
+	evalToolRaw, err := evalTool.ReadFile("eval_tool")
+	if err != nil {
+		return nil, errors.Wrap(code.LoadFileError, err.Error())
+	}
+	err = dev.Push(bytes.NewReader(evalToolRaw), "/data/local/tmp/eval_tool", time.Now())
+	if err != nil {
+		return nil, errors.Wrap(code.AndroidShellExecError, err.Error())
+	}
 	log.Info().Str("serial", device.SerialNumber).Msg("init android device")
 	return device, nil
 }
@@ -152,6 +170,7 @@ type AndroidDevice struct {
 	logcat       *AdbLogcat
 	SerialNumber string `json:"serial,omitempty" yaml:"serial,omitempty"`
 	UIA2         bool   `json:"uia2,omitempty" yaml:"uia2,omitempty"`           // use uiautomator2
+	SHOOTS       bool   `json:"shoots,omitempty" yaml:"uia2,omitempty"`         // use uiautomator2
 	UIA2IP       string `json:"uia2_ip,omitempty" yaml:"uia2_ip,omitempty"`     // uiautomator2 server ip
 	UIA2Port     int    `json:"uia2_port,omitempty" yaml:"uia2_port,omitempty"` // uiautomator2 server port
 	LogOn        bool   `json:"log_on,omitempty" yaml:"log_on,omitempty"`
@@ -174,7 +193,7 @@ func (dev *AndroidDevice) LogEnabled() bool {
 }
 
 func (dev *AndroidDevice) NewDriver(options ...DriverOption) (driverExt *DriverExt, err error) {
-	driverOptions := &DriverOptions{}
+	driverOptions := NewDriverOptions()
 	for _, option := range options {
 		option(driverOptions)
 	}
@@ -182,6 +201,8 @@ func (dev *AndroidDevice) NewDriver(options ...DriverOption) (driverExt *DriverE
 	var driver WebDriver
 	if dev.UIA2 || dev.LogOn {
 		driver, err = dev.NewUSBDriver(driverOptions.capabilities)
+	} else if dev.SHOOTS {
+		driver, err = dev.NewShootsDriver(driverOptions.capabilities)
 	} else {
 		driver, err = dev.NewAdbDriver()
 	}
@@ -189,7 +210,7 @@ func (dev *AndroidDevice) NewDriver(options ...DriverOption) (driverExt *DriverE
 		return nil, errors.Wrap(err, "failed to init UIA driver")
 	}
 
-	driverExt, err = newDriverExt(dev, driver, driverOptions.plugin)
+	driverExt, err = newDriverExt(dev, driver, options...)
 	if err != nil {
 		return nil, err
 	}
@@ -226,6 +247,25 @@ func (dev *AndroidDevice) NewUSBDriver(capabilities Capabilities) (driver WebDri
 	return uiaDriver, nil
 }
 
+func (dev *AndroidDevice) NewShootsDriver(capabilities Capabilities) (driver *ShootsAndroidDriver, err error) {
+	localPort, err := dev.d.Forward(ShootsSocketName)
+	if err != nil {
+		return nil, errors.Wrap(code.AndroidDeviceConnectionError,
+			fmt.Sprintf("forward port %d->%s failed: %v",
+				localPort, ShootsSocketName, err))
+	}
+
+	shootsDriver, err := newShootsAndroidDriver(fmt.Sprintf("127.0.0.1:%d", localPort))
+	if err != nil {
+		_ = dev.d.ForwardKill(localPort)
+		return nil, errors.Wrap(code.AndroidDeviceConnectionError, err.Error())
+	}
+	shootsDriver.adbClient = dev.d
+	shootsDriver.logcat = dev.logcat
+
+	return shootsDriver, nil
+}
+
 // NewHTTPDriver creates new remote HTTP client, this will also start a new session.
 func (dev *AndroidDevice) NewHTTPDriver(capabilities Capabilities) (driver WebDriver, err error) {
 	rawURL := fmt.Sprintf("http://%s:%d/wd/hub", dev.UIA2IP, dev.UIA2Port)

hrp/pkg/uixt/android_shoots_driver.go

@@ -0,0 +1,235 @@
+package uixt
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"time"
+
+	"github.com/rs/zerolog/log"
+
+	"github.com/httprunner/httprunner/v4/hrp/internal/json"
+)
+
+type ShootsAndroidDriver struct {
+	socket  net.Conn
+	seq     int
+	timeout time.Duration
+	adbDriver
+}
+
+const ShootsSocketName = "com.bytest.device"
+
+// newShootsAndroidDriver
+// 创建shoots Driver address为forward后的端口格式127.0.0.1:${port}
+func newShootsAndroidDriver(address string, readTimeout ...time.Duration) (*ShootsAndroidDriver, error) {
+	timeout := 10 * time.Second
+	if len(readTimeout) > 0 {
+		timeout = readTimeout[0]
+	}
+
+	conn, err := net.Dial("tcp", address)
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("failed to connect %s", address))
+		return nil, err
+	}
+
+	return &ShootsAndroidDriver{
+		socket:  conn,
+		timeout: timeout,
+	}, nil
+}
+
+func (sad *ShootsAndroidDriver) NewSession(capabilities Capabilities) (SessionInfo, error) {
+	return SessionInfo{}, errDriverNotImplemented
+}
+
+func (sad *ShootsAndroidDriver) sendCommand(packageName string, cmdType string, params map[string]interface{}, readTimeout ...time.Duration) (interface{}, error) {
+	sad.seq++
+	packet := map[string]interface{}{
+		"Seq": sad.seq,
+		"Cmd": cmdType,
+		"v":   "",
+	}
+	for key, value := range params {
+		if key == "Cmd" || key == "Seq" {
+			return "", errors.New("params cannot be Cmd or Seq")
+		}
+		packet[key] = value
+	}
+	data, err := json.Marshal(packet)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := sad.adbClient.RunShootsCommand(append(data, '\n'), packageName)
+	if err != nil {
+		return nil, err
+	}
+	var resultMap map[string]interface{}
+	if err := json.Unmarshal([]byte(res), &resultMap); err != nil {
+		return nil, err
+	}
+	if resultMap["Error"] != nil {
+		return nil, fmt.Errorf("failed to call shoots command: %s", resultMap["Error"].(string))
+	}
+
+	return resultMap["Result"], nil
+}
+
+func (sad *ShootsAndroidDriver) send(data []byte, readTimeout ...time.Duration) (map[string]interface{}, error) {
+	timeout := sad.timeout
+	if len(readTimeout) > 0 {
+		timeout = readTimeout[0]
+	}
+	_ = sad.socket.SetReadDeadline(time.Now().Add(timeout))
+
+	err := _send(sad.socket, append(data, '\n'))
+	if err != nil {
+		sad.close()
+		return nil, err
+	}
+	raw, err := _readAll(sad.socket)
+	if err != nil {
+		return nil, err
+	}
+	var result map[string]interface{}
+	if err := json.Unmarshal(raw, &result); err != nil {
+		log.Printf("error when parse json response: %s\n", raw)
+		return nil, err
+	}
+	return result, nil
+}
+
+func _send(writer io.Writer, msg []byte) (err error) {
+	for totalSent := 0; totalSent < len(msg); {
+		var sent int
+		if sent, err = writer.Write(msg[totalSent:]); err != nil {
+			return err
+		}
+		if sent == 0 {
+			return errors.New("socket connection broken")
+		}
+		totalSent += sent
+	}
+	return
+}
+
+func _readN(reader io.Reader, size int) (raw []byte, err error) {
+	raw = make([]byte, 0, size)
+	for len(raw) < size {
+		buf := make([]byte, size-len(raw))
+		var n int
+		if n, err = io.ReadFull(reader, buf); err != nil {
+			return nil, err
+		}
+		if n == 0 {
+			return nil, errors.New("socket connection broken")
+		}
+		raw = append(raw, buf...)
+	}
+	return
+}
+
+func _readAll(reader io.Reader) (raw []byte, err error) {
+	buffer := new(bytes.Buffer)
+	for true {
+		lengthBuf := make([]byte, 4)
+		_, err := io.ReadFull(reader, lengthBuf)
+		if err != nil {
+			if err == io.EOF {
+				return buffer.Bytes(), nil
+			} else if errors.Is(err, io.ErrUnexpectedEOF) {
+				err = fmt.Errorf("reached unexpected EOF, read partial data: %s %v", string(buffer.Bytes()), err)
+				return nil, err
+			} else {
+				return nil, err
+			}
+		}
+		length := binary.BigEndian.Uint32(lengthBuf)
+
+		data, err := _readN(reader, int(length)-4)
+		if err != nil {
+			return nil, err
+		}
+		buffer.Write(data)
+
+	}
+	return buffer.Bytes(), nil
+}
+
+func (sad *ShootsAndroidDriver) DeleteSession() error {
+	return sad.close()
+}
+
+func (sad *ShootsAndroidDriver) close() error {
+	if sad.socket != nil {
+		return sad.socket.Close()
+	}
+	return nil
+}
+
+func (sad *ShootsAndroidDriver) Status() (DeviceStatus, error) {
+	app, err := sad.GetForegroundApp()
+	res, err := sad.sendCommand(app.PackageName, "Hello", nil)
+	if err != nil {
+		return DeviceStatus{}, err
+	}
+	log.Info().Msg(fmt.Sprintf("pint shoots result :%v", res))
+	return DeviceStatus{}, nil
+}
+
+func (sad *ShootsAndroidDriver) Source(srcOpt ...SourceOption) (source string, err error) {
+	app, err := sad.GetForegroundApp()
+	params := map[string]interface{}{
+		"ClassName": "com.bytedance.byteinsight.MockOperator",
+		"Method":    "getLayout",
+		"RetType":   "",
+		"Args":      []string{},
+	}
+	res, err := sad.sendCommand(app.PackageName, "CallStaticMethod", params)
+	if err != nil {
+		return "", err
+	}
+	return res.(string), nil
+}
+
+func (sad *ShootsAndroidDriver) LoginNoneUI(packageName, phoneNumber string, captcha string) error {
+	_, err := sad.adbClient.RunShellCommand("am", "broadcast", "-a", fmt.Sprintf("%s.util.crony.action_login", packageName), "-e", "phone", phoneNumber, "-e", "code", captcha)
+	time.Sleep(5 * time.Second)
+	login, err := sad.isLogin(packageName)
+	if err != nil || !login {
+		log.Err(err).Msg("failed to login")
+		return fmt.Errorf("failed to login")
+	}
+	return err
+}
+
+func (sad *ShootsAndroidDriver) isLogin(packageName string) (login bool, err error) {
+	params := map[string]interface{}{
+		"ClassName":   "com.ss.android.ugc.aweme.account.AccountProxyService",
+		"Method":      "userService",
+		"RetType":     "",
+		"Args":        []string{},
+		"CacheObject": true,
+	}
+	id, err := sad.sendCommand(packageName, "CallStaticMethod", params)
+	if err != nil {
+		return false, err
+	}
+
+	params = map[string]interface{}{
+		"Method":   "isLogin",
+		"RetType":  "",
+		"Args":     []string{},
+		"ObjectId": int(id.(float64)),
+	}
+	loginObj, err := sad.sendCommand(packageName, "CallMethod", params)
+	if err != nil {
+		return false, err
+	}
+	return loginObj.(bool), nil
+}

hrp/pkg/uixt/android_shoots_driver_test.go

@@ -0,0 +1,40 @@
+package uixt
+
+import "testing"
+
+var driver *ShootsAndroidDriver
+
+func setupAndroid(t *testing.T) {
+	device, err := NewAndroidDevice()
+	checkErr(t, err)
+	device.SHOOTS = true
+	driver, err = device.NewShootsDriver(Capabilities{})
+	checkErr(t, err)
+}
+
+func TestHello(t *testing.T) {
+	setupAndroid(t)
+	status, err := driver.Status()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(status)
+}
+
+func TestSource(t *testing.T) {
+	setupAndroid(t)
+	source, err := driver.Source()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(source)
+}
+
+func TestLogin(t *testing.T) {
+	setupAndroid(t)
+	res, err := driver.isLogin("com.ss.android.ugc.aweme")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(res)
+}

hrp/pkg/uixt/android_uia2_driver.go

@@ -250,10 +250,14 @@ func (ud *uiaDriver) PressBack(options ...ActionOption) (err error) {
 }
 
 func (ud *uiaDriver) Homescreen() (err error) {
-	return ud.PressKeyCode(KCHome, KMEmpty)
+	return ud.PressKeyCodes(KCHome, KMEmpty)
 }
 
-func (ud *uiaDriver) PressKeyCode(keyCode KeyCode, metaState KeyMeta, flags ...KeyFlag) (err error) {
+func (ud *uiaDriver) PressKeyCode(keyCode KeyCode) (err error) {
+	return ud.PressKeyCodes(keyCode, KMEmpty)
+}
+
+func (ud *uiaDriver) PressKeyCodes(keyCode KeyCode, metaState KeyMeta, flags ...KeyFlag) (err error) {
 	// register(postHandler, new PressKeyCodeAsync("/wd/hub/session/:sessionId/appium/device/press_keycode"))
 	data := map[string]interface{}{
 		"keycode": keyCode,

hrp/pkg/uixt/ext.go

@@ -155,11 +155,16 @@ type DriverExt struct {
 	plugin funplugin.IPlugin
 }
 
-func newDriverExt(device Device, driver WebDriver, plugin funplugin.IPlugin) (dExt *DriverExt, err error) {
+func newDriverExt(device Device, driver WebDriver, options ...DriverOption) (dExt *DriverExt, err error) {
+	driverOptions := &DriverOptions{}
+	for _, option := range options {
+		option(driverOptions)
+	}
+
 	dExt = &DriverExt{
 		Device:          device,
 		Driver:          driver,
-		plugin:          plugin,
+		plugin:          driverOptions.plugin,
 		cacheStepData:   cacheStepData{},
 		interruptSignal: make(chan os.Signal, 1),
 	}
@@ -179,17 +184,19 @@ func newDriverExt(device Device, driver WebDriver, plugin funplugin.IPlugin) (dE
 	if err != nil {
 		return nil, errors.Wrap(err, "get screen resolution failed")
 	}
-
-	if dExt.ImageService, err = newVEDEMImageService(); err != nil {
-		return nil, err
+	if driverOptions.withImageService {
+		if dExt.ImageService, err = newVEDEMImageService(); err != nil {
+			return nil, err
+		}
 	}
-
-	// create results directory
-	if err = builtin.EnsureFolderExists(env.ResultsPath); err != nil {
-		return nil, errors.Wrap(err, "create results directory failed")
-	}
-	if err = builtin.EnsureFolderExists(env.ScreenShotsPath); err != nil {
-		return nil, errors.Wrap(err, "create screenshots directory failed")
+	if driverOptions.withResultFolder {
+		// create results directory
+		if err = builtin.EnsureFolderExists(env.ResultsPath); err != nil {
+			return nil, errors.Wrap(err, "create results directory failed")
+		}
+		if err = builtin.EnsureFolderExists(env.ScreenShotsPath); err != nil {
+			return nil, errors.Wrap(err, "create screenshots directory failed")
+		}
 	}
 	return dExt, nil
 }

hrp/pkg/uixt/interface.go

@@ -252,11 +252,7 @@ type Screen struct {
 }
 
 type AppInfo struct {
-	ProcessArguments struct {
-		Env  interface{}   `json:"env"`
-		Args []interface{} `json:"args"`
-	} `json:"processArguments"`
-	Name string `json:"name"`
+	Name string `json:"name,omitempty"`
 	AppBaseInfo
 }
 
@@ -266,6 +262,10 @@ type AppBaseInfo struct {
 	ViewController string `json:"viewController,omitempty"` // ios view controller
 	PackageName    string `json:"packageName,omitempty"`    // android package name
 	Activity       string `json:"activity,omitempty"`       // android activity
+	VersionName    string `json:"versionName,omitempty"`
+	VersionCode    int    `json:"versionCode,omitempty"`
+	AppName        string `json:"appName,omitempty"`
+	// AppIcon        string `json:"appIcon,omitempty"`
 }
 
 type AppState int
@@ -376,6 +376,11 @@ func (opt SourceOption) WithFormatAsJson() SourceOption {
 	return opt
 }
 
+func (opt SourceOption) WithProcessName(processName string) SourceOption {
+	opt["processName"] = processName
+	return opt
+}
+
 // WithFormatAsXml Application elements tree in form of xml string
 func (opt SourceOption) WithFormatAsXml() SourceOption {
 	opt["format"] = "xml"
@@ -448,8 +453,17 @@ type Rect struct {
 }
 
 type DriverOptions struct {
-	capabilities Capabilities
-	plugin       funplugin.IPlugin
+	capabilities     Capabilities
+	plugin           funplugin.IPlugin
+	withImageService bool
+	withResultFolder bool
+}
+
+func NewDriverOptions() *DriverOptions {
+	return &DriverOptions{
+		withImageService: true,
+		withResultFolder: true,
+	}
 }
 
 type DriverOption func(*DriverOptions)
@@ -460,6 +474,18 @@ func WithDriverCapabilities(capabilities Capabilities) DriverOption {
 	}
 }
 
+func WithDriverImageService(withImageService bool) DriverOption {
+	return func(options *DriverOptions) {
+		options.withImageService = withImageService
+	}
+}
+
+func WithDriverResultFolder(withResultFolder bool) DriverOption {
+	return func(options *DriverOptions) {
+		options.withResultFolder = withResultFolder
+	}
+}
+
 func WithDriverPlugin(plugin funplugin.IPlugin) DriverOption {
 	return func(options *DriverOptions) {
 		options.plugin = plugin
@@ -526,6 +552,8 @@ type WebDriver interface {
 	// Homescreen Forces the device under test to switch to the home screen
 	Homescreen() error
 
+	Unlock() (err error)
+
 	// AppLaunch Launch an application with given bundle identifier in scope of current session.
 	// !This method is only available since Xcode9 SDK
 	AppLaunch(packageName string) error
@@ -588,11 +616,15 @@ type WebDriver interface {
 	// PressBack Presses the back button
 	PressBack(options ...ActionOption) error
 
+	PressKeyCode(keyCode KeyCode) (err error)
+
 	Screenshot() (*bytes.Buffer, error)
 
 	// Source Return application elements tree
 	Source(srcOpt ...SourceOption) (string, error)
 
+	LoginNoneUI(packageName, phoneNumber string, captcha string) error
+
 	TapByText(text string, options ...ActionOption) error
 
 	TapByTexts(actions ...TapTextAction) error

hrp/pkg/uixt/ios_device.go

@@ -308,7 +308,7 @@ func (dev *IOSDevice) LogEnabled() bool {
 }
 
 func (dev *IOSDevice) NewDriver(options ...DriverOption) (driverExt *DriverExt, err error) {
-	driverOptions := &DriverOptions{}
+	driverOptions := NewDriverOptions()
 	for _, option := range options {
 		option(driverOptions)
 	}
@@ -339,7 +339,7 @@ func (dev *IOSDevice) NewDriver(options ...DriverOption) (driverExt *DriverExt,
 		}
 	}
 
-	driverExt, err = newDriverExt(dev, driver, driverOptions.plugin)
+	driverExt, err = newDriverExt(dev, driver, options...)
 	if err != nil {
 		return nil, err
 	}

hrp/pkg/uixt/ios_driver.go

@@ -595,6 +595,10 @@ func (wd *wdaDriver) SetIme(ime string) error {
 	return errDriverNotImplemented
 }
 
+func (wd *wdaDriver) PressKeyCode(keyCode KeyCode) (err error) {
+	return errDriverNotImplemented
+}
+
 func (wd *wdaDriver) SendKeys(text string, options ...ActionOption) (err error) {
 	// [[FBRoute POST:@"/wda/keys"] respondWithTarget:self action:@selector(handleKeys:)]
 	actionOptions := NewActionOptions(options...)
@@ -655,6 +659,10 @@ func (wd *wdaDriver) PressButton(devBtn DeviceButton) (err error) {
 	return
 }
 
+func (wd *wdaDriver) LoginNoneUI(packageName, phoneNumber string, captcha string) error {
+	return errDriverNotImplemented
+}
+
 func (wd *wdaDriver) StartCamera() (err error) {
 	// start camera, alias for app_launch com.apple.camera
 	return wd.AppLaunch("com.apple.camera")