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

hrp/pkg/server/exception.go

@@ -0,0 +1,18 @@
+package server
+
+// 常见的错误代码和消息
+const (
+	InternalServerErrorCode = 100001
+	InternalServerErrorMsg  = "Invalid Server Error"
+
+	InvalidParamErrorCode = 100002
+	InvalidParamErrorMsg  = "Invalid %s Param"
+
+	CodeNotFound = 1004
+	MsgNotFound  = "Resource not found"
+)
+
+const (
+	DeviceNotFoundCode = 110001
+	DeviceNotFoundMsg  = "Device %s Not Found"
+)

hrp/pkg/server/model.go

@@ -0,0 +1,44 @@
+package server
+
+type HttpResponse struct {
+	Result    interface{} `json:"result,omitempty"`
+	ErrorCode int         `json:"errorCode"`
+	ErrorMsg  string      `json:"errorMsg"`
+}
+
+type TapRequest struct {
+	X        float64 `json:"x"`
+	Y        float64 `json:"y"`
+	Duration float64 `json:"duration"`
+}
+
+type DragRequest struct {
+	FromX    float64 `json:"from_x"`
+	FromY    float64 `json:"from_y"`
+	ToX      float64 `json:"to_x"`
+	ToY      float64 `json:"to_y"`
+	Duration float64 `json:"duration"`
+}
+
+type InputRequest struct {
+	Text      string `json:"text"`
+	Frequency int    `json:"frequency"` // only iOS
+}
+
+type KeycodeRequest struct {
+	Keycode int `json:"keycode"`
+}
+
+type AppLaunchRequest struct {
+	PackageName string `json:"packageName"`
+}
+
+type AppTerminalRequest struct {
+	PackageName string `json:"packageName"`
+}
+
+type LoginRequest struct {
+	PackageName string `json:"packageName"`
+	PhoneNumber string `json:"phoneNumber"`
+	Captcha     string `json:"captcha"`
+}

hrp/pkg/server/server.go

@@ -0,0 +1,514 @@
+package server
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog/log"
+
+	"github.com/httprunner/httprunner/v4/hrp/pkg/gadb"
+	"github.com/httprunner/httprunner/v4/hrp/pkg/uixt"
+)
+
+func NewServer(port int) error {
+	router := gin.Default()
+	router.GET("/ping", pingHandler)
+	router.GET("/api/v1/:platform/devices", listDeviceHandler)
+	router.POST("/api/v1/:platform/:serial/ui/tap", parseDeviceInfo(), tapHandler)
+	router.POST("/api/v1/:platform/:serial/ui/drag", parseDeviceInfo(), dragHandler)
+	router.POST("/api/v1/:platform/:serial/ui/input", parseDeviceInfo(), inputHandler)
+	router.POST("/api/v1/:platform/:serial/key/unlock", parseDeviceInfo(), unlockHandler)
+	router.POST("/api/v1/:platform/:serial/key/home", parseDeviceInfo(), homeHandler)
+	router.POST("/api/v1/:platform/:serial/key", parseDeviceInfo(), keycodeHandler)
+	router.GET("/api/v1/:platform/:serial/app/foreground", parseDeviceInfo(), foregroundAppHandler)
+	router.POST("/api/v1/:platform/:serial/app/launch", parseDeviceInfo(), launchAppHandler)
+	router.POST("/api/v1/:platform/:serial/app/terminal", parseDeviceInfo(), terminalAppHandler)
+	router.GET("/api/v1/:platform/:serial/screenshot", parseDeviceInfo(), screenshotHandler)
+	router.GET("/api/v1/:platform/:serial/shoots/source", parseDeviceInfo(), sourceHandler)
+	router.GET("/api/v1/:platform/:serial/adb/source", parseDeviceInfo(), adbSourceHandler)
+	router.POST("/api/v1/:platform/:serial/shoots/login", parseDeviceInfo(), loginHandler)
+
+	err := router.Run(fmt.Sprintf("127.0.0.1:%d", port))
+	if err != nil {
+		log.Err(err).Msg("failed to start http server")
+		return err
+	}
+	return nil
+}
+
+func pingHandler(c *gin.Context) {
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func listDeviceHandler(c *gin.Context) {
+	platform := c.Param("platform")
+	switch strings.ToLower(platform) {
+	case "android":
+		{
+			client, err := gadb.NewClient()
+			if err != nil {
+				log.Err(err).Msg("failed to init adb client")
+				c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+				c.Abort()
+				return
+			}
+			devices, err := client.DeviceList()
+			if err != nil && strings.Contains(err.Error(), "no android device found") {
+				c.JSON(http.StatusOK, HttpResponse{Result: nil})
+				return
+			} else if err != nil {
+				log.Err(err).Msg("failed to list devices")
+				c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+				c.Abort()
+				return
+			}
+			var deviceList []interface{}
+			for _, device := range devices {
+				brand, err := device.Brand()
+				if err != nil {
+					log.Err(err).Msg("failed to get device brand")
+					c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+					c.Abort()
+					return
+				}
+				model, err := device.Model()
+				if err != nil {
+					log.Err(err).Msg("failed to get device model")
+					c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+					c.Abort()
+					return
+				}
+				deviceInfo := map[string]interface{}{
+					"serial":   device.Serial(),
+					"brand":    brand,
+					"model":    model,
+					"platform": "android",
+				}
+				deviceList = append(deviceList, deviceInfo)
+			}
+			c.JSON(http.StatusOK, HttpResponse{Result: deviceList})
+			return
+		}
+	default:
+		{
+			c.JSON(http.StatusBadRequest, HttpResponse{
+				ErrorCode: InvalidParamErrorCode,
+				ErrorMsg:  fmt.Sprintf(InvalidParamErrorMsg, "platform"),
+			})
+			c.Abort()
+			return
+		}
+	}
+}
+
+func tapHandler(c *gin.Context) {
+	var tapReq TapRequest
+	if err := c.ShouldBindJSON(&tapReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	if tapReq.X < 1 && tapReq.Y < 1 {
+		err := dExt.TapXY(tapReq.X, tapReq.Y, uixt.WithPressDuration(tapReq.Duration))
+		if err != nil {
+			log.Err(err).Msg(fmt.Sprintf("[%s]: failed to tap %f, %f", c.HandlerName(), tapReq.X, tapReq.Y))
+			c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+			c.Abort()
+			return
+		}
+	} else {
+		err := dExt.TapAbsXY(tapReq.X, tapReq.Y, uixt.WithPressDuration(tapReq.Duration))
+		if err != nil {
+			log.Err(err).Msg(fmt.Sprintf("[%s]: failed to tap %f, %f", c.HandlerName(), tapReq.X, tapReq.Y))
+			c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+			c.Abort()
+			return
+		}
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func dragHandler(c *gin.Context) {
+	var dragReq DragRequest
+	if err := c.ShouldBindJSON(&dragReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	if dragReq.FromX < 1 && dragReq.FromY < 1 && dragReq.ToX < 1 && dragReq.ToY < 1 {
+		err := dExt.SwipeRelative(dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY, uixt.WithPressDuration(dragReq.Duration))
+		if err != nil {
+			log.Err(err).Msg(fmt.Sprintf("[%s]: failed to drag from %f, %f to %f, %f", c.HandlerName(), dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY))
+			c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+			c.Abort()
+			return
+		}
+	} else {
+		err := dExt.Driver.SwipeFloat(dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY, uixt.WithPressDuration(dragReq.Duration))
+		if err != nil {
+			log.Err(err).Msg(fmt.Sprintf("[%s]: failed to drag from %f, %f to %f, %f", c.HandlerName(), dragReq.FromX, dragReq.FromY, dragReq.ToX, dragReq.ToY))
+			c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+			c.Abort()
+			return
+		}
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func inputHandler(c *gin.Context) {
+	var inputReq InputRequest
+	if err := c.ShouldBindJSON(&inputReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.SendKeys(inputReq.Text, uixt.WithFrequency(inputReq.Frequency))
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to input text %s", c.HandlerName(), inputReq.Text))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func unlockHandler(c *gin.Context) {
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.Unlock()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to unlick screen", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func homeHandler(c *gin.Context) {
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.Homescreen()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to enter homescreen", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func keycodeHandler(c *gin.Context) {
+	var keycodeReq KeycodeRequest
+	if err := c.ShouldBindJSON(&keycodeReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.PressKeyCode(uixt.KeyCode(keycodeReq.Keycode))
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to input keycode %d", c.HandlerName(), keycodeReq.Keycode))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func foregroundAppHandler(c *gin.Context) {
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: false, ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	appInfo, err := dExt.Driver.GetForegroundApp()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to unlick screen", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: false, ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: appInfo})
+	return
+}
+
+func launchAppHandler(c *gin.Context) {
+	var appLaunchReq AppLaunchRequest
+	if err := c.ShouldBindJSON(&appLaunchReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.AppLaunch(appLaunchReq.PackageName)
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to launch app %s", c.HandlerName(), appLaunchReq.PackageName))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func terminalAppHandler(c *gin.Context) {
+	var appTerminalReq AppTerminalRequest
+	if err := c.ShouldBindJSON(&appTerminalReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	success, err := dExt.Driver.AppTerminate(appTerminalReq.PackageName)
+	if !success {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to launch app %s", c.HandlerName(), appTerminalReq.PackageName))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func screenshotHandler(c *gin.Context) {
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	raw, err := dExt.Driver.Screenshot()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get screenshot", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+
+	c.JSON(http.StatusOK, HttpResponse{Result: base64.StdEncoding.EncodeToString(raw.Bytes())})
+	return
+}
+
+func sourceHandler(c *gin.Context) {
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	app, err := dExt.Driver.GetForegroundApp()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get foreground app", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	source, err := dExt.Driver.Source(uixt.NewSourceOption().WithProcessName(app.PackageName))
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get source %s", c.HandlerName(), app.PackageName))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+
+	c.JSON(http.StatusOK, HttpResponse{Result: source})
+	return
+}
+
+func adbSourceHandler(c *gin.Context) {
+	deviceObj, exists := c.Get("device")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "device")})
+		c.Abort()
+		return
+	}
+	device := deviceObj.(*uixt.AndroidDevice)
+	driver, err := device.NewAdbDriver()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to new adb driver", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	source, err := driver.Source()
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get adb source", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: source})
+	return
+}
+
+func loginHandler(c *gin.Context) {
+	var loginReq LoginRequest
+	if err := c.ShouldBindJSON(&loginReq); err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: Invalid Request", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "request")})
+		c.Abort()
+		return
+	}
+
+	driverObj, exists := c.Get("driver")
+	if !exists {
+		log.Error().Msg(fmt.Sprintf("[%s]: Driver Not exsit", c.HandlerName()))
+		c.JSON(http.StatusBadRequest, HttpResponse{Result: "", ErrorCode: InvalidParamErrorCode, ErrorMsg: fmt.Sprintf(InvalidParamErrorMsg, "driver")})
+		c.Abort()
+		return
+	}
+
+	dExt := driverObj.(*uixt.DriverExt)
+	err := dExt.Driver.LoginNoneUI(loginReq.PackageName, loginReq.PhoneNumber, loginReq.Captcha)
+	if err != nil {
+		log.Err(err).Msg(fmt.Sprintf("[%s]: failed to get foreground app", c.HandlerName()))
+		c.JSON(http.StatusInternalServerError, HttpResponse{Result: "", ErrorCode: InternalServerErrorCode, ErrorMsg: InternalServerErrorMsg})
+		c.Abort()
+		return
+	}
+	c.JSON(http.StatusOK, HttpResponse{Result: true})
+	return
+}
+
+func parseDeviceInfo() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		platform := c.Param("platform")
+		switch strings.ToLower(platform) {
+		case "android":
+			serial := c.Param("serial")
+			if serial == "" {
+				log.Error().Str("platform", platform).Msg(fmt.Sprintf("[%s]: serial is empty", c.HandlerName()))
+				c.JSON(http.StatusBadRequest, HttpResponse{
+					ErrorCode: InvalidParamErrorCode,
+					ErrorMsg:  fmt.Sprintf(InvalidParamErrorMsg, "serial"),
+				})
+				c.Abort()
+				return
+			}
+			device, err := uixt.NewAndroidDevice(uixt.WithSerialNumber(serial), uixt.WithShoots(true))
+			if err != nil {
+				log.Error().Err(err).Str("platform", platform).Str("serial", serial).Msg(fmt.Sprintf("[%s]: Device Not Found", c.HandlerName()))
+				c.JSON(http.StatusBadRequest, HttpResponse{
+					ErrorCode: DeviceNotFoundCode,
+					ErrorMsg:  fmt.Sprintf(DeviceNotFoundMsg, serial),
+				})
+				c.Abort()
+				return
+			}
+			c.Set("device", device)
+			driver, err := device.NewDriver(uixt.WithDriverImageService(false), uixt.WithDriverResultFolder(false))
+			if err != nil {
+				log.Error().Err(err).Str("platform", platform).Str("serial", serial).Msg(fmt.Sprintf("[%s]: Failed New Driver", c.HandlerName()))
+				c.JSON(http.StatusInternalServerError, HttpResponse{
+					ErrorCode: InternalServerErrorCode,
+					ErrorMsg:  err.Error(),
+				})
+				c.Abort()
+				return
+			}
+			c.Set("driver", driver)
+		default:
+			c.JSON(http.StatusBadRequest, HttpResponse{
+				ErrorCode: InvalidParamErrorCode,
+				ErrorMsg:  fmt.Sprintf(InvalidParamErrorMsg, "platform"),
+			})
+			c.Abort()
+			return
+		}
+		c.Next()
+	}
+}