fix: test

# Conflicts:
#	pkg/download/extension.go

README.md

@@ -174,7 +174,7 @@ command:
 - android
 
 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

README_ja-JP.md

@@ -162,7 +162,7 @@ gomobile init
 - android
 
 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

README_vi-VN.md

@@ -170,7 +170,7 @@ command:
 - android
 
 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

README_zh-CN.md

@@ -174,7 +174,7 @@ gomobile init
 - android
 
 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

README_zh-TW.md

@@ -170,7 +170,7 @@ gomobile init
 - android
 
 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

bind/common.go

@@ -0,0 +1,41 @@
+package bind
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+)
+
+// Global singleton instance
+var instance *api.Instance
+
+func Init(config *model.StartConfig) (err error) {
+	if instance != nil {
+		return nil
+	}
+
+	config.ProductionMode = true
+	instance, err = api.Create(config)
+	return
+}
+
+func Invoke(request *api.Request) string {
+	if instance == nil {
+		return BuildResult(errors.New("instance not initialized"))
+	}
+	return jsonEncode(api.Invoke(instance, request))
+}
+
+func BuildResult(data any) string {
+	if err, ok := data.(error); ok {
+		buf, _ := json.Marshal(model.NewErrorResult[any](err.Error()))
+		return string(buf)
+	}
+	return jsonEncode(model.NewOkResult(data))
+}
+
+func jsonEncode(data any) string {
+	buf, _ := json.Marshal(data)
+	return string(buf)
+}

bind/desktop/main.go

@@ -3,27 +3,32 @@ package main
 import "C"
 import (
 	"encoding/json"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/bind"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 )
 
 func main() {}
 
-//export Start
-func Start(cfg *C.char) (int, *C.char) {
+//export Init
+func Init(cfg *C.char) *C.char {
 	var config model.StartConfig
 	if err := json.Unmarshal([]byte(C.GoString(cfg)), &config); err != nil {
-		return 0, C.CString(err.Error())
+		return C.CString(err.Error())
 	}
-	config.ProductionMode = true
-	realPort, err := rest.Start(&config)
-	if err != nil {
-		return 0, C.CString(err.Error())
+	if err := bind.Init(&config); err != nil {
+		return C.CString(err.Error())
 	}
-	return realPort, nil
+
+	return nil
 }
 
-//export Stop
-func Stop() {
-	rest.Stop()
+//export Invoke
+func Invoke(req *C.char) *C.char {
+	var request api.Request
+	if err := json.Unmarshal([]byte(C.GoString(req)), &request); err != nil {
+		return C.CString(bind.BuildResult(err))
+	}
+
+	return C.CString(bind.Invoke(&request))
 }

bind/mobile/main.go

@@ -3,20 +3,15 @@ package libgopeed
 // #cgo LDFLAGS: -static-libstdc++
 import "C"
 import (
-	"encoding/json"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/bind"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 )
 
-func Start(cfg string) (int, error) {
-	var config model.StartConfig
-	if err := json.Unmarshal([]byte(cfg), &config); err != nil {
-		return 0, err
-	}
-	config.ProductionMode = true
-	return rest.Start(&config)
+func Init(cfg *model.StartConfig) error {
+	return bind.Init(cfg)
 }
 
-func Stop() {
-	rest.Stop()
+func Invoke(request *api.Request) string {
+	return bind.Invoke(request)
 }

cmd/api/main.go

@@ -2,15 +2,21 @@ package main
 
 import (
 	"github.com/GopeedLab/gopeed/cmd"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
 )
 
 // only for local development
 func main() {
 	cfg := &model.StartConfig{
-		Network:   "tcp",
-		Address:   "127.0.0.1:9999",
-		Storage:   model.StorageBolt,
+		Storage: model.StorageBolt,
+		DownloadConfig: &base.DownloaderStoreConfig{
+			Http: &base.DownloaderHttpConfig{
+				Enable: true,
+				Host:   "127.0.0.1",
+				Port:   9999,
+			},
+		},
 		WebEnable: true,
 	}
 	cmd.Start(cfg)

cmd/server.go

@@ -3,10 +3,9 @@ package cmd
 import (
 	_ "embed"
 	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 	"github.com/GopeedLab/gopeed/pkg/base"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -18,20 +17,22 @@ var banner string
 
 func Start(cfg *model.StartConfig) {
 	fmt.Println(banner)
-	srv, listener, err := rest.BuildServer(cfg)
+	instance, err := api.Create(cfg)
 	if err != nil {
 		panic(err)
 	}
-	downloadCfg, err := rest.Downloader.GetConfig()
-	if err != nil {
-		panic(err)
+
+	downloadCfgResult := instance.GetConfig()
+	if downloadCfgResult.HasError() {
+		panic(downloadCfgResult.Msg)
 	}
+	downloadCfg := downloadCfgResult.Data
 	if downloadCfg.FirstLoad {
 		// Set default download config
 		if cfg.DownloadConfig != nil {
 			cfg.DownloadConfig.Merge(downloadCfg)
 			// TODO Use PatchConfig
-			rest.Downloader.PutConfig(cfg.DownloadConfig)
+			instance.PutConfig(cfg.DownloadConfig)
 			downloadCfg = cfg.DownloadConfig
 		}
 
@@ -48,25 +49,28 @@ func Start(cfg *model.StartConfig) {
 			}
 			if downloadDir != "" {
 				downloadCfg.DownloadDir = downloadDir
-				rest.Downloader.PutConfig(downloadCfg)
+				instance.PutConfig(downloadCfg)
 			}
 		}
 	}
-	watchExit()
 
-	fmt.Printf("Server start success on http://%s\n", listener.Addr().String())
-	if err := srv.Serve(listener); err != nil && err != http.ErrServerClosed {
+	watchExit(instance)
+
+	port, start, err := api.ListenHttp(cfg.DownloadConfig.Http, instance)
+	if err != nil {
 		panic(err)
 	}
+	fmt.Printf("Server start success on http://%s:%d\n", cfg.DownloadConfig.Http.Host, port)
+	start()
 }
 
-func watchExit() {
+func watchExit(instance *api.Instance) {
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		sig := <-sigs
 		fmt.Printf("Server is shutting down due to signal: %s\n", sig)
-		rest.Downloader.Close()
+		instance.Close()
 		os.Exit(0)
 	}()
 }

cmd/web/flags.go

@@ -10,7 +10,7 @@ import (
 )
 
 type args struct {
-	Address    *string `json:"address"`
+	Host       *string `json:"host"`
 	Port       *int    `json:"port"`
 	Username   *string `json:"username"`
 	Password   *string `json:"password"`
@@ -24,7 +24,7 @@ type args struct {
 
 func parse() *args {
 	var cliArgs args
-	cliArgs.Address = flag.String("A", "0.0.0.0", "Bind Address")
+	cliArgs.Host = flag.String("H", "0.0.0.0", "Bind Host")
 	cliArgs.Port = flag.Int("P", 9999, "Bind Port")
 	cliArgs.Username = flag.String("u", "gopeed", "HTTP Basic Auth Username")
 	cliArgs.Password = flag.String("p", "", "HTTP Basic Auth Pwd")
@@ -35,8 +35,8 @@ func parse() *args {
 
 	// args priority: config file > cli args
 	cfgArgs := loadConfig(*cliArgs.configPath)
-	if cfgArgs.Address == nil {
-		cfgArgs.Address = cliArgs.Address
+	if cfgArgs.Host == nil {
+		cfgArgs.Host = cliArgs.Host
 	}
 	if cfgArgs.Port == nil {
 		cfgArgs.Port = cliArgs.Port

cmd/web/main.go

@@ -5,9 +5,9 @@ package main
 
 import (
 	"embed"
-	"fmt"
 	"github.com/GopeedLab/gopeed/cmd"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -42,12 +42,19 @@ func main() {
 		dir = filepath.Dir(exe)
 	}
 
+	if args.DownloadConfig == nil {
+		args.DownloadConfig = &base.DownloaderStoreConfig{}
+	}
+	args.DownloadConfig.Http = &base.DownloaderHttpConfig{
+		Enable:   true,
+		Host:     *args.Host,
+		Port:     *args.Port,
+		ApiToken: *args.ApiToken,
+	}
+
 	cfg := &model.StartConfig{
-		Network:        "tcp",
-		Address:        fmt.Sprintf("%s:%d", *args.Address, *args.Port),
 		Storage:        model.StorageBolt,
 		StorageDir:     filepath.Join(dir, "storage"),
-		ApiToken:       *args.ApiToken,
 		DownloadConfig: args.DownloadConfig,
 		ProductionMode: true,
 		WebEnable:      true,

internal/protocol/bt/fetcher.go

@@ -11,9 +11,7 @@ import (
 	"github.com/GopeedLab/gopeed/pkg/util"
 	"github.com/anacrolix/torrent"
 	"github.com/anacrolix/torrent/metainfo"
-	"io"
 	"net/url"
-	"os"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -334,7 +332,7 @@ func (f *Fetcher) doUpload(fromUpload bool) {
 	}
 }
 
-// Get torrent stats maybe panic, see https://github.com/anacrolix/torrent/issues/972
+// get torrent stats maybe panic, see https://github.com/anacrolix/torrent/issues/972
 func (f *Fetcher) torrentStats() torrent.TorrentStats {
 	defer func() {
 		if r := recover(); r != nil {
@@ -361,27 +359,17 @@ func (f *Fetcher) addTorrent(req *base.Request, fromUpload bool) (err error) {
 	schema := util.ParseSchema(req.URL)
 	if schema == "MAGNET" {
 		f.torrent, err = client.AddMagnet(req.URL)
-	} else {
-		var reader io.Reader
-		if schema == "DATA" {
-			_, data := util.ParseDataUri(req.URL)
-			reader = bytes.NewBuffer(data)
-		} else {
-			reader, err = os.Open(req.URL)
-			if err != nil {
-				return
-			}
-			defer reader.(io.Closer).Close()
-		}
-
+	} else if schema == "DATA" {
+		_, data := util.ParseDataUri(req.URL)
+		buf := bytes.NewBuffer(data)
 		var metaInfo *metainfo.MetaInfo
-		metaInfo, err = metainfo.Load(reader)
-		// Hotfix for https://github.com/anacrolix/torrent/issues/992, ignore "expected EOF" error
-		// TODO remove this after the issue is fixed
-		if err != nil && !strings.Contains(err.Error(), "expected EOF") {
+		metaInfo, err = metainfo.Load(buf)
+		if err != nil {
 			return err
 		}
 		f.torrent, err = client.AddTorrent(metaInfo)
+	} else {
+		f.torrent, err = client.AddTorrentFromFile(req.URL)
 	}
 	if err != nil {
 		return

internal/protocol/bt/fetcher_test.go

@@ -96,7 +96,7 @@ func doResolve(t *testing.T, fetcher fetcher.Fetcher) {
 			Hash: "8a55cfbd5ca5d11507364765936c4f9e55b253ed",
 		}
 		if !reflect.DeepEqual(want, fetcher.Meta().Res) {
-			t.Errorf("Resolve Single File Resolve() got = %v, want %v", fetcher.Meta().Res, want)
+			t.Errorf("Resolve() got = %v, want %v", fetcher.Meta().Res, want)
 		}
 	})
 
@@ -136,16 +136,7 @@ func doResolve(t *testing.T, fetcher fetcher.Fetcher) {
 			Hash: "ccbc92b0cd8deec16a2ef4be242a8c9243b1cedb",
 		}
 		if !reflect.DeepEqual(want, fetcher.Meta().Res) {
-			t.Errorf("Resolve Multi Files Resolve() got = %v, want %v", fetcher.Meta().Res, want)
-		}
-	})
-
-	t.Run("Resolve Unclean Torrent", func(t *testing.T) {
-		err := fetcher.Resolve(&base.Request{
-			URL: "./testdata/test.unclean.torrent",
-		})
-		if err != nil {
-			t.Errorf("Resolve Unclean Torrent Resolve() got = %v, want nil", err)
+			t.Errorf("Resolve() got = %v, want %v", fetcher.Meta().Res, want)
 		}
 	})
 

internal/protocol/http/fetcher.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"io"
 	"mime"
-	"net"
 	"net/http"
 	"net/http/cookiejar"
 	"net/url"
@@ -26,9 +25,6 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
-const connectTimeout = 15 * time.Second
-const readTimeout = 15 * time.Second
-
 type RequestError struct {
 	Code int
 	Msg  string
@@ -107,7 +103,7 @@ func (f *Fetcher) Resolve(req *base.Request) error {
 	if base.HttpCodePartialContent == httpResp.StatusCode || (base.HttpCodeOK == httpResp.StatusCode && httpResp.Header.Get(base.HttpHeaderAcceptRanges) == base.HttpHeaderBytes && strings.HasPrefix(httpResp.Header.Get(base.HttpHeaderContentRange), base.HttpHeaderBytes)) {
 		// response 206 status code, support breakpoint continuation
 		res.Range = true
-		// parse content length from Content-Range header, eg: bytes 0-1000/1001
+		// 解析资源大小: bytes 0-1000/1001 => 1001
 		contentTotal := path.Base(httpResp.Header.Get(base.HttpHeaderContentRange))
 		if contentTotal != "" {
 			parse, err := strconv.ParseInt(contentTotal, 10, 64)
@@ -254,42 +250,23 @@ func (f *Fetcher) Wait() (err error) {
 	return <-f.doneCh
 }
 
-type fetchResult struct {
-	err error
-}
-
 func (f *Fetcher) fetch() {
 	var ctx context.Context
 	ctx, f.cancel = context.WithCancel(context.Background())
 	f.eg, _ = errgroup.WithContext(ctx)
-	chunkErrs := make([]error, len(f.chunks))
 	for i := 0; i < len(f.chunks); i++ {
 		i := i
 		f.eg.Go(func() error {
-			err := f.fetchChunk(i, ctx)
-			// if canceled, fail fast
-			if errors.Is(err, context.Canceled) {
-				return err
-			}
-			chunkErrs[i] = err
-			return nil
+			return f.fetchChunk(i, ctx)
 		})
 	}
 
 	go func() {
 		err := f.eg.Wait()
-		// error returned only if canceled, just return
-		if err != nil {
+		// check if canceled
+		if errors.Is(err, context.Canceled) {
 			return
 		}
-		// check all fetch results, if any error, return
-		for _, chunkErr := range chunkErrs {
-			if chunkErr != nil {
-				err = chunkErr
-				break
-			}
-		}
-
 		f.file.Close()
 		// Update file last modified time
 		if f.config.UseServerCtime && f.meta.Res.Files[0].Ctime != nil {
@@ -312,11 +289,24 @@ func (f *Fetcher) fetchChunk(index int, ctx context.Context) (err error) {
 	for {
 		// if chunk is completed, return
 		if f.meta.Res.Range && chunk.Downloaded >= chunk.End-chunk.Begin+1 {
-			return nil
+			return
 		}
 
 		if chunk.retryTimes >= maxRetries {
-			return
+			if !f.meta.Res.Range {
+				return
+			}
+			// check if all failed
+			allFailed := true
+			for _, c := range f.chunks {
+				if chunk.Downloaded < chunk.End-chunk.Begin+1 && c.retryTimes < maxRetries {
+					allFailed = false
+					break
+				}
+			}
+			if allFailed {
+				return
+			}
 		}
 
 		var (
@@ -343,9 +333,10 @@ func (f *Fetcher) fetchChunk(index int, ctx context.Context) (err error) {
 				err = NewRequestError(resp.StatusCode, resp.Status)
 				return err
 			}
-			reader := NewTimeoutReader(resp.Body, readTimeout)
+			// Http request success, reset retry times
+			chunk.retryTimes = 0
 			for {
-				n, err := reader.Read(buf)
+				n, err := resp.Body.Read(buf)
 				if n > 0 {
 					_, err := f.file.WriteAt(buf[:n], chunk.Begin+chunk.Downloaded)
 					if err != nil {
@@ -360,6 +351,7 @@ func (f *Fetcher) fetchChunk(index int, ctx context.Context) (err error) {
 					return err
 				}
 			}
+			return nil
 		}()
 		if err != nil {
 			// If canceled, do not retry
@@ -460,9 +452,6 @@ func (f *Fetcher) splitChunk() (chunks []*chunk) {
 
 func (f *Fetcher) buildClient() *http.Client {
 	transport := &http.Transport{
-		DialContext: (&net.Dialer{
-			Timeout: connectTimeout,
-		}).DialContext,
 		Proxy: f.ctl.GetProxy(f.meta.Req.Proxy),
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: f.meta.Req.SkipVerifyCert,
@@ -510,7 +499,7 @@ func (fm *FetcherManager) ParseName(u string) string {
 	if err != nil {
 		return ""
 	}
-	// Get filePath by URL
+	// get filePath by URL
 	name = path.Base(url.Path)
 	// If file name is empty, use host name
 	if name == "" || name == "/" || name == "." {

internal/protocol/http/fetcher_test.go

@@ -132,14 +132,6 @@ func TestFetcher_DownloadLimit(t *testing.T) {
 	downloadNormal(listener, 8, t)
 }
 
-func TestFetcher_DownloadResponseBodyReadTimeout(t *testing.T) {
-	listener := test.StartTestLimitServer(16, readTimeout.Milliseconds()+5000)
-	defer listener.Close()
-
-	downloadError(listener, 1, t)
-	downloadError(listener, 4, t)
-}
-
 func TestFetcher_DownloadResume(t *testing.T) {
 	listener := test.StartTestFileServer()
 	defer listener.Close()

internal/protocol/http/timeout_reader.go

@@ -1,40 +0,0 @@
-package http
-
-import (
-	"context"
-	"io"
-	"time"
-)
-
-type TimeoutReader struct {
-	reader  io.Reader
-	timeout time.Duration
-}
-
-func NewTimeoutReader(r io.Reader, timeout time.Duration) *TimeoutReader {
-	return &TimeoutReader{
-		reader:  r,
-		timeout: timeout,
-	}
-}
-
-func (tr *TimeoutReader) Read(p []byte) (n int, err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), tr.timeout)
-	defer cancel()
-
-	done := make(chan struct{})
-	var readErr error
-	var bytesRead int
-
-	go func() {
-		bytesRead, readErr = tr.reader.Read(p)
-		close(done)
-	}()
-
-	select {
-	case <-done:
-		return bytesRead, readErr
-	case <-ctx.Done():
-		return 0, ctx.Err()
-	}
-}

internal/protocol/http/timeout_reader_test.go

@@ -1,51 +0,0 @@
-package http
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"testing"
-	"time"
-)
-
-func TestTimeoutReader_Read(t *testing.T) {
-	data := []byte("Hello, World!")
-	reader := bytes.NewReader(data)
-	timeoutReader := NewTimeoutReader(reader, 1*time.Second)
-
-	buf := make([]byte, len(data))
-	n, err := timeoutReader.Read(buf)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if n != len(data) {
-		t.Fatalf("expected to read %d bytes, read %d", len(data), n)
-	}
-	if !bytes.Equal(buf, data) {
-		t.Fatalf("expected %s, got %s", data, buf)
-	}
-}
-
-func TestTimeoutReader_ReadTimeout(t *testing.T) {
-	reader := &slowReader{delay: 2 * time.Second}
-	timeoutReader := NewTimeoutReader(reader, 1*time.Second)
-
-	buf := make([]byte, 8192)
-	_, err := timeoutReader.Read(buf)
-	if err == nil {
-		t.Fatal("expected timeout error, got nil")
-	}
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Fatalf("expected %v, got %v", context.DeadlineExceeded, err)
-	}
-}
-
-type slowReader struct {
-	delay time.Duration
-}
-
-func (sr *slowReader) Read(p []byte) (n int, err error) {
-	time.Sleep(sr.delay)
-	return 0, io.EOF
-}

internal/test/httptest.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/armon/go-socks5"
@@ -37,7 +36,7 @@ const (
 )
 
 func StartTestFileServer() net.Listener {
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		return http.FileServer(http.Dir(Dir))
 	})
 }
@@ -53,7 +52,7 @@ func (s *SlowFileServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 }
 
 func StartTestSlowFileServer(delay time.Duration) net.Listener {
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		return &SlowFileServer{
 			delay:   delay,
 			handler: http.FileServer(http.Dir(Dir)),
@@ -62,7 +61,7 @@ func StartTestSlowFileServer(delay time.Duration) net.Listener {
 }
 
 func StartTestCustomServer() net.Listener {
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			file, err := os.Open(BuildFile)
@@ -89,7 +88,7 @@ func StartTestCustomServer() net.Listener {
 
 func StartTestRetryServer() net.Listener {
 	counter := 0
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			counter++
@@ -109,7 +108,7 @@ func StartTestRetryServer() net.Listener {
 }
 
 func StartTestPostServer() net.Listener {
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			if request.Method == "POST" && request.Header.Get("Authorization") != "" {
@@ -133,7 +132,7 @@ func StartTestPostServer() net.Listener {
 
 func StartTestErrorServer() net.Listener {
 	counter := 0
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			counter++
@@ -150,7 +149,7 @@ func StartTestErrorServer() net.Listener {
 func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 	var connections atomic.Int32
 
-	return startTestServer(func(sl *shutdownListener) http.Handler {
+	return startTestServer(func() http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			defer func() {
@@ -166,14 +165,12 @@ func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 			if r == "" {
 				writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
 				writer.WriteHeader(200)
-				(writer.(http.Flusher)).Flush()
-
 				file, err := os.Open(BuildFile)
 				if err != nil {
 					panic(err)
 				}
 				defer file.Close()
-				slowCopy(sl, writer, file, delay)
+				slowCopy(writer, file, delay)
 			} else {
 				// split range
 				s := strings.Split(r, "=")
@@ -207,8 +204,6 @@ func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 				writer.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, BuildSize))
 				writer.Header().Set("Accept-Ranges", "bytes")
 				writer.WriteHeader(206)
-				(writer.(http.Flusher)).Flush()
-
 				file, err := os.Open(BuildFile)
 				if err != nil {
 					writer.WriteHeader(500)
@@ -216,7 +211,7 @@ func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 				}
 				defer file.Close()
 				file.Seek(start, 0)
-				slowCopyN(sl, writer, file, end-start+1, delay)
+				slowCopyN(writer, file, end-start+1, delay)
 			}
 		})
 		return mux
@@ -224,12 +219,9 @@ func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 }
 
 // slowCopyN copies n bytes from src to dst, speed limit is bytes per second
-func slowCopy(sl *shutdownListener, dst io.Writer, src io.Reader, delay int64) (written int64, err error) {
+func slowCopy(dst io.Writer, src io.Reader, delay int64) (written int64, err error) {
 	buf := make([]byte, 32*1024)
 	for {
-		if sl.isShutdown {
-			return 0, errors.New("server shutdown")
-		}
 		nr, er := src.Read(buf)
 		if nr > 0 {
 			nw, ew := dst.Write(buf[0:nr])
@@ -258,8 +250,8 @@ func slowCopy(sl *shutdownListener, dst io.Writer, src io.Reader, delay int64) (
 	return written, err
 }
 
-func slowCopyN(sl *shutdownListener, dst io.Writer, src io.Reader, n int64, delay int64) (written int64, err error) {
-	written, err = slowCopy(sl, dst, io.LimitReader(src, n), delay)
+func slowCopyN(dst io.Writer, src io.Reader, n int64, delay int64) (written int64, err error) {
+	written, err = slowCopy(dst, io.LimitReader(src, n), delay)
 	if written == n {
 		return n, nil
 	}
@@ -270,7 +262,7 @@ func slowCopyN(sl *shutdownListener, dst io.Writer, src io.Reader, n int64, dela
 	return
 }
 
-func startTestServer(serverHandle func(sl *shutdownListener) http.Handler) net.Listener {
+func startTestServer(serverHandle func() http.Handler) net.Listener {
 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		panic(err)
@@ -280,7 +272,7 @@ func startTestServer(serverHandle func(sl *shutdownListener) http.Handler) net.L
 		panic(err)
 	}
 	defer file.Close()
-	// Write random data
+	// 随机生成一个文件
 	l := int64(8192)
 	buf := make([]byte, l)
 	size := int64(0)
@@ -297,24 +289,21 @@ func startTestServer(serverHandle func(sl *shutdownListener) http.Handler) net.L
 		size += l
 	}
 	server := &http.Server{}
-	sl := &shutdownListener{
+	server.Handler = serverHandle()
+	go server.Serve(listener)
+
+	return &shutdownListener{
 		server:   server,
 		Listener: listener,
 	}
-	server.Handler = serverHandle(sl)
-	go server.Serve(listener)
-
-	return sl
 }
 
 type shutdownListener struct {
-	server     *http.Server
-	isShutdown bool
+	server *http.Server
 	net.Listener
 }
 
 func (c *shutdownListener) Close() error {
-	c.isShutdown = true
 	closeErr := c.server.Shutdown(context.Background())
 	if err := ifExistAndRemove(BuildFile); err != nil {
 		fmt.Println(err)

pkg/api/api.go

@@ -0,0 +1,400 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"github.com/GopeedLab/gopeed/pkg/util"
+	"net"
+	"net/http"
+	"reflect"
+	"runtime"
+	"sync"
+)
+
+type Instance struct {
+	startCfg   *model.StartConfig
+	downloader *download.Downloader
+
+	httpLock sync.Mutex
+	srv      *http.Server
+	listener net.Listener
+}
+
+func Create(startCfg *model.StartConfig) (*Instance, error) {
+	if startCfg == nil {
+		startCfg = &model.StartConfig{}
+	}
+	startCfg.Init()
+
+	i := &Instance{
+		startCfg: startCfg,
+	}
+
+	downloadCfg := &download.DownloaderConfig{
+		ProductionMode:  startCfg.ProductionMode,
+		RefreshInterval: startCfg.RefreshInterval,
+	}
+	if startCfg.Storage == model.StorageBolt {
+		downloadCfg.Storage = download.NewBoltStorage(startCfg.StorageDir)
+	} else {
+		downloadCfg.Storage = download.NewMemStorage()
+	}
+	downloadCfg.StorageDir = startCfg.StorageDir
+	downloadCfg.Init()
+	downloader := download.NewDownloader(downloadCfg)
+	if err := downloader.Setup(); err != nil {
+		return nil, err
+	}
+	i.downloader = downloader
+	i.httpLock = sync.Mutex{}
+
+	return i, nil
+}
+
+func (i *Instance) Listener(listener download.Listener) *model.Result[any] {
+	i.downloader.Listener(listener)
+	return model.NewNilResult()
+}
+
+func (i *Instance) StartHttp() *model.Result[int] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	return i.startHttp()
+}
+
+func (i *Instance) startHttp() *model.Result[int] {
+	httpCfg := i.getHttpConfig()
+	if httpCfg == nil || !httpCfg.Enable {
+		return model.NewErrorResult[int]("HTTP API server not enabled")
+	}
+	if i.srv != nil {
+		return model.NewErrorResult[int]("HTTP API server already started")
+	}
+
+	port, start, err := ListenHttp(httpCfg, i)
+	if err != nil {
+		return model.NewErrorResult[int](err.Error())
+	}
+	httpCfg.RunningPort = port
+	go start()
+	return model.NewOkResult(port)
+}
+
+func (i *Instance) getHttpConfig() *base.DownloaderHttpConfig {
+	var httpCfg *base.DownloaderHttpConfig
+	if i.startCfg.DownloadConfig != nil && i.startCfg.DownloadConfig.Http != nil {
+		httpCfg = i.startCfg.DownloadConfig.Http
+	} else {
+		cfg, _ := i.downloader.GetConfig()
+		httpCfg = cfg.Http
+	}
+	return httpCfg
+}
+
+func (i *Instance) StopHttp() *model.Result[any] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	return i.stopHttp()
+}
+
+func (i *Instance) stopHttp() *model.Result[any] {
+	if i.srv != nil {
+		if err := i.srv.Shutdown(context.Background()); err != nil {
+			i.downloader.Logger.Warn().Err(err).Msg("shutdown http server failed")
+		}
+		i.srv = nil
+		i.listener = nil
+	}
+	httpCfg := i.getHttpConfig()
+	if httpCfg != nil {
+		httpCfg.RunningPort = 0
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) RestartHttp() *model.Result[int] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	i.stopHttp()
+	return i.startHttp()
+}
+
+func (i *Instance) Info() *model.Result[map[string]any] {
+	return model.NewOkResult(map[string]any{
+		"version":  base.Version,
+		"runtime":  runtime.Version(),
+		"os":       runtime.GOOS,
+		"arch":     runtime.GOARCH,
+		"inDocker": base.InDocker == "true",
+	})
+}
+
+func (i *Instance) Resolve(req *base.Request) *model.Result[*download.ResolveResult] {
+	rr, err := i.downloader.Resolve(req)
+	if err != nil {
+		return model.NewErrorResult[*download.ResolveResult](err.Error())
+	}
+	return model.NewOkResult(rr)
+}
+
+func (i *Instance) CreateTask(req *model.CreateTask) *model.Result[string] {
+	var (
+		taskId string
+		err    error
+	)
+	if req.Rid != "" {
+		taskId, err = i.downloader.Create(req.Rid, req.Opt)
+	} else if req.Req != nil {
+		taskId, err = i.downloader.CreateDirect(req.Req, req.Opt)
+	} else {
+		return model.NewErrorResult[string]("param invalid: rid or req", model.CodeInvalidParam)
+	}
+	if err != nil {
+		return model.NewErrorResult[string](err.Error())
+	}
+	return model.NewOkResult(taskId)
+}
+
+func (i *Instance) CreateTaskBatch(req *model.CreateTaskBatch) *model.Result[[]string] {
+	if len(req.Reqs) == 0 {
+		return model.NewErrorResult[[]string]("param invalid: reqs", model.CodeInvalidParam)
+	}
+	taskIds, err := i.downloader.CreateDirectBatch(req.Reqs, req.Opt)
+	if err != nil {
+		return model.NewErrorResult[[]string](err.Error())
+	}
+	return model.NewOkResult(taskIds)
+}
+
+func (i *Instance) PauseTask(taskId string) *model.Result[any] {
+	err := i.downloader.Pause(&download.TaskFilter{
+		ID: []string{taskId},
+	})
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) PauseTasks(filter *download.TaskFilter) *model.Result[any] {
+	err := i.downloader.Pause(filter)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) ContinueTask(taskId string) *model.Result[any] {
+	err := i.downloader.Continue(&download.TaskFilter{
+		ID: []string{taskId},
+	})
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) ContinueTasks(filter *download.TaskFilter) *model.Result[any] {
+	err := i.downloader.Continue(filter)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteTask(taskId string, force bool) *model.Result[any] {
+	err := i.downloader.Delete(&download.TaskFilter{
+		ID: []string{taskId},
+	}, force)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteTasks(filter *download.TaskFilter, force bool) *model.Result[any] {
+	err := i.downloader.Delete(filter, force)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) GetTask(taskId string) *model.Result[*download.Task] {
+	if taskId == "" {
+		return model.NewErrorResult[*download.Task]("param invalid: id", model.CodeInvalidParam)
+	}
+	task := i.downloader.GetTask(taskId)
+	if task == nil {
+		return model.NewErrorResult[*download.Task]("task not found", model.CodeTaskNotFound)
+	}
+	return model.NewOkResult(task)
+}
+
+func (i *Instance) GetTasks(filter *download.TaskFilter) *model.Result[[]*download.Task] {
+	return model.NewOkResult(i.downloader.GetTasksByFilter(filter))
+}
+
+func (i *Instance) GetTaskStats(taskId string) *model.Result[any] {
+	stats, err := i.downloader.GetTaskStats(taskId)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewOkResult(stats)
+}
+
+func (i *Instance) GetConfig() *model.Result[*base.DownloaderStoreConfig] {
+	config, err := i.downloader.GetConfig()
+	if err != nil {
+		return model.NewErrorResult[*base.DownloaderStoreConfig](err.Error())
+	}
+	return model.NewOkResult(config)
+}
+
+func (i *Instance) PutConfig(cfg *base.DownloaderStoreConfig) *model.Result[any] {
+	err := i.downloader.PutConfig(cfg)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) InstallExtension(req *model.InstallExtension) *model.Result[string] {
+	var (
+		installedExt *download.Extension
+		err          error
+	)
+	if req.DevMode {
+		installedExt, err = i.downloader.InstallExtensionByFolder(req.URL, true)
+	} else {
+		installedExt, err = i.downloader.InstallExtensionByGit(req.URL)
+	}
+	if err != nil {
+		return model.NewErrorResult[string](err.Error())
+	}
+
+	return model.NewOkResult(installedExt.Identity)
+}
+
+func (i *Instance) GetExtension(identity string) *model.Result[*download.Extension] {
+	extension, err := i.downloader.GetExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[*download.Extension](err.Error())
+	}
+	return model.NewOkResult(extension)
+}
+
+func (i *Instance) GetExtensions() *model.Result[[]*download.Extension] {
+	return model.NewOkResult(i.downloader.GetExtensions())
+}
+
+func (i *Instance) UpdateExtensionSettings(identity string, req *model.UpdateExtensionSettings) *model.Result[any] {
+	err := i.downloader.UpdateExtensionSettings(identity, req.Settings)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) SwitchExtension(identity string, req *model.SwitchExtension) *model.Result[any] {
+	err := i.downloader.SwitchExtension(identity, req.Status)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteExtension(identity string) *model.Result[any] {
+	err := i.downloader.DeleteExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) UpgradeCheckExtension(identity string) *model.Result[*model.UpgradeCheckExtensionResp] {
+	newVersion, err := i.downloader.UpgradeCheckExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[*model.UpgradeCheckExtensionResp](err.Error())
+	}
+
+	return model.NewOkResult(&model.UpgradeCheckExtensionResp{
+		NewVersion: newVersion,
+	})
+}
+
+func (i *Instance) UpgradeExtension(identity string) *model.Result[any] {
+	err := i.downloader.UpgradeExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) Close() *model.Result[any] {
+	i.StopHttp()
+	if i.downloader != nil {
+		if err := i.downloader.Close(); err != nil {
+			i.downloader.Logger.Warn().Err(err).Msg("close downloader failed")
+		}
+		i.downloader = nil
+	}
+
+	return model.NewNilResult()
+}
+
+func (i *Instance) Clear() *model.Result[any] {
+	if err := i.downloader.Clear(); err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+type Request struct {
+	Method string `json:"method"`
+	Params []any  `json:"params"`
+}
+
+// Invoke support dynamic call method
+func Invoke(instance *Instance, request *Request) (ret any) {
+	defer func() {
+		if err := recover(); err != nil {
+			ret = model.NewErrorResult[any](fmt.Sprintf("%v", err))
+		}
+	}()
+
+	method, args := request.Method, request.Params
+	dsType := reflect.ValueOf(instance)
+	fn := dsType.MethodByName(method)
+	numIn := fn.Type().NumIn()
+	in := make([]reflect.Value, numIn)
+	for i := 0; i < numIn; i++ {
+		paramType := fn.Type().In(i)
+		arg := args[i]
+		if arg == nil {
+			in[i] = reflect.Zero(fn.Type().In(i))
+			continue
+		}
+		var param reflect.Value
+		var paramPtr any
+		if paramType.Kind() == reflect.Ptr {
+			param = reflect.New(paramType.Elem())
+			paramPtr = param.Interface()
+		} else {
+			param = reflect.New(paramType).Elem()
+			paramPtr = param.Addr().Interface()
+		}
+		if err := util.MapToStruct(arg, paramPtr); err != nil {
+			panic(err)
+		}
+		in[i] = param
+	}
+	retVals := fn.Call(in)
+	return retVals[0].Interface()
+}

pkg/api/api_test.go

@@ -0,0 +1,42 @@
+package api
+
+import (
+	"encoding/json"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"testing"
+)
+
+func TestInvoke(t *testing.T) {
+	doTestInvoke(t, "Info", []any{}, model.CodeOk)
+	doTestInvoke(t, "Info1", []any{}, model.CodeError)
+	doTestInvoke(t, "CreateTask", []any{nil}, model.CodeError)
+	doTestInvoke(t, "GetTasks", nil, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{}, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{"{abc:123"}, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{&download.TaskFilter{}}, model.CodeOk)
+	doTestInvoke(t, "SwitchExtension", []any{"test", &model.SwitchExtension{Status: true}}, model.CodeError)
+}
+
+func doTestInvoke(t *testing.T, method string, params []any, expectCode model.RespCode) {
+	instance, _ := Create(nil)
+	defer instance.Close()
+
+	result := Invoke(instance, &Request{
+		Method: method,
+		Params: params,
+	})
+	buf, err := json.Marshal(result)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var res model.Result[any]
+	if err := json.Unmarshal(buf, &res); err != nil {
+		t.Fatal(err)
+	}
+
+	if res.Code != expectCode {
+		t.Fatalf("Invoke method [%s] failed, expect code [%d], got [%d], msg: %s", method, expectCode, res.Code, res.Msg)
+	}
+}

pkg/api/http.go

@@ -0,0 +1,451 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+const instanceKey string = "apiInstance"
+
+func ListenHttp(httpCfg *base.DownloaderHttpConfig, ai *Instance) (int, func(), error) {
+	var r = mux.NewRouter()
+	r.Methods(http.MethodGet).Path("/api/v1/info").HandlerFunc(Info)
+	r.Methods(http.MethodPost).Path("/api/v1/resolve").HandlerFunc(Resolve)
+	r.Methods(http.MethodPost).Path("/api/v1/tasks").HandlerFunc(CreateTask)
+	r.Methods(http.MethodPost).Path("/api/v1/tasks/batch").HandlerFunc(CreateTaskBatch)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/pause").HandlerFunc(PauseTask)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/pause").HandlerFunc(PauseTasks)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/continue").HandlerFunc(ContinueTask)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/continue").HandlerFunc(ContinueTasks)
+	r.Methods(http.MethodDelete).Path("/api/v1/tasks/{id}").HandlerFunc(DeleteTask)
+	r.Methods(http.MethodDelete).Path("/api/v1/tasks").HandlerFunc(DeleteTasks)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}").HandlerFunc(GetTask)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks").HandlerFunc(GetTasks)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}/stats").HandlerFunc(GetTaskStats)
+	r.Methods(http.MethodGet).Path("/api/v1/config").HandlerFunc(GetConfig)
+	r.Methods(http.MethodPut).Path("/api/v1/config").HandlerFunc(PutConfig)
+	r.Methods(http.MethodPost).Path("/api/v1/extensions").HandlerFunc(InstallExtension)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions").HandlerFunc(GetExtensions)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}").HandlerFunc(GetExtension)
+	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/settings").HandlerFunc(UpdateExtensionSettings)
+	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/switch").HandlerFunc(SwitchExtension)
+	r.Methods(http.MethodDelete).Path("/api/v1/extensions/{identity}").HandlerFunc(DeleteExtension)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}/upgrade").HandlerFunc(UpgradeCheckExtension)
+	r.Methods(http.MethodPost).Path("/api/v1/extensions/{identity}/upgrade").HandlerFunc(UpgradeExtension)
+	if ai.startCfg.WebEnable {
+		r.Path("/api/v1/proxy").HandlerFunc(DoProxy)
+		r.PathPrefix("/fs/tasks").Handler(http.FileServer(&taskFileSystem{
+			downloader: ai.downloader,
+		}))
+		r.PathPrefix("/fs/extensions").Handler(http.FileServer(&extensionFileSystem{
+			downloader: ai.downloader,
+		}))
+		r.PathPrefix("/").Handler(http.FileServer(http.FS(ai.startCfg.WebFS)))
+	}
+
+	r.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := context.WithValue(r.Context(), instanceKey, ai)
+			h.ServeHTTP(w, r.WithContext(ctx))
+		})
+	})
+
+	if httpCfg.ApiToken != "" || (ai.startCfg.WebEnable && ai.startCfg.WebBasicAuth != nil) {
+		r.Use(func(h http.Handler) http.Handler {
+			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if httpCfg.ApiToken != "" && r.Header.Get("X-Api-Token") == httpCfg.ApiToken {
+					h.ServeHTTP(w, r)
+					return
+				}
+				if ai.startCfg.WebEnable && ai.startCfg.WebBasicAuth != nil {
+					if r.Header.Get("Authorization") == ai.startCfg.WebBasicAuth.Authorization() {
+						h.ServeHTTP(w, r)
+						return
+					}
+					w.Header().Set("WWW-Authenticate", "Basic realm=\"gopeed web\"")
+				}
+				WriteStatusJson(w, http.StatusUnauthorized, model.NewErrorResult[any]("unauthorized", model.CodeUnauthorized))
+			})
+		})
+	}
+
+	// recover panic
+	r.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			defer func() {
+				if v := recover(); v != nil {
+					err := errors.WithStack(fmt.Errorf("%v", v))
+					ai.downloader.Logger.Error().Stack().Err(err).Msgf("http server panic: %s %s", r.Method, r.RequestURI)
+					WriteJson(w, model.NewErrorResult[any](err.Error(), model.CodeError))
+				}
+			}()
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	srv := &http.Server{Handler: handlers.CORS(
+		handlers.AllowedHeaders([]string{"Content-Type", "X-Api-Token", "X-Target-Uri"}),
+		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}),
+		handlers.AllowedOrigins([]string{"*"}),
+	)(r)}
+
+	listener, err := net.Listen("tcp", net.JoinHostPort(httpCfg.Host, fmt.Sprintf("%d", httpCfg.Port)))
+	if err != nil {
+		return 0, nil, err
+	}
+	ai.srv = srv
+	ai.listener = listener
+
+	return listener.Addr().(*net.TCPAddr).Port, func() {
+		if err := srv.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			ai.downloader.Logger.Error().Err(err).Msg("http server listen error")
+		}
+	}, nil
+}
+
+func getInstance(r *http.Request) *Instance {
+	return r.Context().Value(instanceKey).(*Instance)
+}
+
+func Info(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).Info())
+}
+
+func Resolve(w http.ResponseWriter, r *http.Request) {
+	var req base.Request
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).Resolve(&req))
+	}
+}
+
+func CreateTask(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateTask
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).CreateTask(&req))
+	}
+}
+
+func CreateTaskBatch(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateTaskBatch
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).CreateTaskBatch(&req))
+	}
+}
+
+func PauseTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).PauseTask(taskId))
+}
+
+func PauseTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).PauseTasks(&filter))
+}
+
+func ContinueTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).ContinueTask(taskId))
+}
+
+func ContinueTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).ContinueTasks(&filter))
+}
+
+func DeleteTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	force := r.FormValue("force")
+	WriteJson(w, getInstance(r).DeleteTask(taskId, force == "true"))
+}
+
+func DeleteTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	force := r.FormValue("force")
+	WriteJson(w, getInstance(r).DeleteTasks(&filter, force == "true"))
+}
+
+func GetTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTask(taskId))
+}
+
+func GetTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTasks(&filter))
+}
+
+func GetTaskStats(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTaskStats(taskId))
+}
+
+func GetConfig(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).GetConfig())
+}
+
+func PutConfig(w http.ResponseWriter, r *http.Request) {
+	var cfg base.DownloaderStoreConfig
+	if !ReadJson(r, w, &cfg) {
+		return
+	}
+	WriteJson(w, getInstance(r).PutConfig(&cfg))
+}
+
+func InstallExtension(w http.ResponseWriter, r *http.Request) {
+	var req model.InstallExtension
+	if !ReadJson(r, w, &req) {
+		return
+	}
+	WriteJson(w, getInstance(r).InstallExtension(&req))
+}
+
+func GetExtensions(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).GetExtensions())
+}
+
+func GetExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetExtension(identity))
+}
+
+func UpdateExtensionSettings(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	var req model.UpdateExtensionSettings
+	if !ReadJson(r, w, &req) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpdateExtensionSettings(identity, &req))
+}
+
+func SwitchExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	var switchExtension model.SwitchExtension
+	if !ReadJson(r, w, &switchExtension) {
+		return
+	}
+	WriteJson(w, getInstance(r).SwitchExtension(identity, &switchExtension))
+}
+
+func DeleteExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).DeleteExtension(identity))
+}
+
+func UpgradeCheckExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpgradeCheckExtension(identity))
+}
+
+func UpgradeExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpgradeExtension(identity))
+}
+
+func DoProxy(w http.ResponseWriter, r *http.Request) {
+	target := r.Header.Get("X-Target-Uri")
+	if target == "" {
+		writeError(w, "param invalid: X-Target-Uri")
+		return
+	}
+	targetUrl, err := url.Parse(target)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	r.RequestURI = ""
+	r.URL = targetUrl
+	r.Host = targetUrl.Host
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	defer resp.Body.Close()
+	for k, vv := range resp.Header {
+		for _, v := range vv {
+			w.Header().Set(k, v)
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+	buf, err := io.ReadAll(resp.Body)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	w.Write(buf)
+}
+
+func parsePathParam(r *http.Request, w http.ResponseWriter, name string, value *string) bool {
+	vars := mux.Vars(r)
+	*value = vars[name]
+	if *value == "" {
+		WriteJson(w, model.NewErrorResult[any]("param invalid: id", model.CodeInvalidParam))
+		return false
+	}
+	return true
+}
+
+func parseTaskId(r *http.Request, w http.ResponseWriter, taskId *string) bool {
+	return parsePathParam(r, w, "id", taskId)
+}
+
+func parseIdentity(r *http.Request, w http.ResponseWriter, identity *string) bool {
+	return parsePathParam(r, w, "identity", identity)
+}
+
+func parseFilter(r *http.Request, w http.ResponseWriter, filter *download.TaskFilter) bool {
+	if err := r.ParseForm(); err != nil {
+		WriteJson(w, model.NewErrorResult[any](err.Error()))
+		return false
+	}
+
+	filter.ID = r.Form["id"]
+	filter.Status = convertStatues(r.Form["status"])
+	filter.NotStatus = convertStatues(r.Form["notStatus"])
+	return true
+}
+
+func convertStatues(statues []string) []base.Status {
+	result := make([]base.Status, 0)
+	for _, status := range statues {
+		result = append(result, base.Status(status))
+	}
+	return result
+}
+
+func writeError(w http.ResponseWriter, msg string) {
+	w.WriteHeader(http.StatusInternalServerError)
+	w.Write([]byte(msg))
+}
+
+func ReadJson(r *http.Request, w http.ResponseWriter, v any) bool {
+	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
+		WriteJson(w, model.NewErrorResult[any](err.Error()))
+		return false
+	}
+	return true
+}
+
+func WriteJson(w http.ResponseWriter, v any) {
+	WriteStatusJson(w, http.StatusOK, v)
+}
+
+func WriteStatusJson(w http.ResponseWriter, statusCode int, v any) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(statusCode)
+	json.NewEncoder(w).Encode(v)
+}
+
+func resolvePath(urlPath string, prefix string) (identity string, path string, err error) {
+	// remove prefix
+	clearPath := strings.TrimPrefix(urlPath, prefix)
+	// match extension identity, eg: /fs/extensions/identity/xxx
+	reg := regexp.MustCompile(`^/([^/]+)/(.*)$`)
+	if !reg.MatchString(clearPath) {
+		err = os.ErrNotExist
+		return
+	}
+	matched := reg.FindStringSubmatch(clearPath)
+	if len(matched) != 3 {
+		err = os.ErrNotExist
+		return
+	}
+	return matched[1], matched[2], nil
+}
+
+// handle task file resource
+type taskFileSystem struct {
+	downloader *download.Downloader
+}
+
+func (e *taskFileSystem) Open(name string) (http.File, error) {
+	// get extension identity
+	identity, path, err := resolvePath(name, "/fs/tasks")
+	if err != nil {
+		return nil, err
+	}
+	task := e.downloader.GetTask(identity)
+	if task == nil {
+		return nil, os.ErrNotExist
+	}
+	return os.Open(filepath.Join(task.Meta.RootDirPath(), path))
+}
+
+// handle extension file resource
+type extensionFileSystem struct {
+	downloader *download.Downloader
+}
+
+func (e *extensionFileSystem) Open(name string) (http.File, error) {
+	// get extension identity
+	identity, path, err := resolvePath(name, "/fs/extensions")
+	if err != nil {
+		return nil, err
+	}
+	extension, err := e.downloader.GetExtension(identity)
+	if err != nil {
+		return nil, os.ErrNotExist
+	}
+	extensionPath := e.downloader.ExtensionPath(extension)
+	return os.Open(filepath.Join(extensionPath, path))
+}

pkg/api/http_test.go

@@ -1,4 +1,4 @@
-package rest
+package api
 
 import (
 	"bytes"
@@ -7,9 +7,9 @@ import (
 	"errors"
 	"fmt"
 	"github.com/GopeedLab/gopeed/internal/test"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
 	"io"
 	"net"
 	"net/http"
@@ -21,7 +21,8 @@ import (
 )
 
 var (
-	restPort int
+	httpInstance *Instance
+	restPort     int
 
 	taskReq = &base.Request{
 		Extra: map[string]any{
@@ -90,7 +91,7 @@ func TestCreateTask(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -117,7 +118,7 @@ func TestCreateDirectTask(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -156,7 +157,7 @@ func TestCreateDirectTaskWithResoled(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -180,7 +181,7 @@ func TestPauseAndContinueTask(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			switch event.Key {
 			case download.EventKeyFinally:
 				wg.Done()
@@ -214,10 +215,7 @@ func TestPauseAndContinueTask(t *testing.T) {
 
 func TestPauseAllAndContinueALLTasks(t *testing.T) {
 	doTest(func() {
-		cfg, err := Downloader.GetConfig()
-		if err != nil {
-			t.Fatal(err)
-		}
+		cfg := UnwrapResult(httpInstance.GetConfig())
 
 		createAndPause := func() {
 			taskId := httpRequestCheckOk[string](http.MethodPost, "/api/v1/tasks", createReq)
@@ -275,7 +273,7 @@ func TestDeleteAllTasks(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(taskCount)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -301,7 +299,7 @@ func TestDeleteTasksByStatues(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(taskCount)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -325,7 +323,7 @@ func TestGetTasks(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -354,7 +352,10 @@ func TestGetAndPutConfig(t *testing.T) {
 		cfg := httpRequestCheckOk[*base.DownloaderStoreConfig](http.MethodGet, "/api/v1/config", nil)
 		cfg.DownloadDir = "./download"
 		cfg.Extra = map[string]any{
-			"serverConfig": &Config{
+			"serverConfig": &struct {
+				Host string `json:"host"`
+				Port int    `json:"port"`
+			}{
 				Host: "127.0.0.1",
 				Port: 8080,
 			},
@@ -446,16 +447,16 @@ func TestDeleteExtension(t *testing.T) {
 	})
 }
 
-func TestUpdateCheckExtension(t *testing.T) {
+func TestUpgradeCheckExtension(t *testing.T) {
 	doTest(func() {
 		identity := httpRequestCheckOk[string](http.MethodPost, "/api/v1/extensions", installExtensionReq)
-		resp := httpRequestCheckOk[*model.UpdateCheckExtensionResp](http.MethodGet, "/api/v1/extensions/"+identity+"/update", nil)
+		resp := httpRequestCheckOk[*model.UpgradeCheckExtensionResp](http.MethodGet, "/api/v1/extensions/"+identity+"/upgrade", nil)
 		// no new version
 		if resp.NewVersion != "" {
-			t.Errorf("UpdateCheckExtension() got = %v, want %v", resp.NewVersion, "")
+			t.Errorf("UpgradeCheckExtension() got = %v, want %v", resp.NewVersion, "")
 		}
 		// force update
-		httpRequestCheckOk[any](http.MethodPost, "/api/v1/extensions/"+identity+"/update", nil)
+		httpRequestCheckOk[any](http.MethodPost, "/api/v1/extensions/"+identity+"/upgrade", nil)
 	})
 }
 
@@ -506,13 +507,19 @@ func TestDoProxy(t *testing.T) {
 func TestApiToken(t *testing.T) {
 	var cfg = &model.StartConfig{}
 	cfg.Init()
-	cfg.ApiToken = "123456"
-	fileListener := doStart(cfg)
+	cfg.DownloadConfig = &base.DownloaderStoreConfig{
+		Http: &base.DownloaderHttpConfig{
+			Enable:   true,
+			ApiToken: "123456",
+		},
+	}
+	httpInstance, _ = Create(cfg)
+	fileListener := doStart()
 	defer func() {
 		if err := fileListener.Close(); err != nil {
 			panic(err)
 		}
-		Stop()
+		httpInstance.Close()
 	}()
 
 	status, _ := doHttpRequest0(http.MethodGet, "/api/v1/config", nil, nil)
@@ -521,7 +528,7 @@ func TestApiToken(t *testing.T) {
 	}
 
 	status, _ = doHttpRequest0(http.MethodGet, "/api/v1/config", map[string]string{
-		"X-Api-Token": cfg.ApiToken,
+		"X-Api-Token": cfg.DownloadConfig.Http.ApiToken,
 	}, nil)
 	if status != http.StatusOK {
 		t.Errorf("TestApiToken() got = %v, want %v", status, http.StatusOK)
@@ -532,18 +539,24 @@ func TestApiToken(t *testing.T) {
 func TestAuthorization(t *testing.T) {
 	var cfg = &model.StartConfig{}
 	cfg.Init()
-	cfg.ApiToken = "123456"
+	cfg.DownloadConfig = &base.DownloaderStoreConfig{
+		Http: &base.DownloaderHttpConfig{
+			Enable:   true,
+			ApiToken: "123456",
+		},
+	}
 	cfg.WebEnable = true
 	cfg.WebBasicAuth = &model.WebBasicAuth{
 		Username: "admin",
 		Password: "123456",
 	}
-	fileListener := doStart(cfg)
+	httpInstance, _ = Create(cfg)
+	fileListener := doStart()
 	defer func() {
 		if err := fileListener.Close(); err != nil {
 			panic(err)
 		}
-		Stop()
+		httpInstance.Close()
 	}()
 
 	status, _ := doHttpRequest0(http.MethodGet, "/api/v1/config", nil, nil)
@@ -559,7 +572,7 @@ func TestAuthorization(t *testing.T) {
 	}
 
 	status, _ = doHttpRequest0(http.MethodGet, "/api/v1/config", map[string]string{
-		"X-Api-Token": cfg.ApiToken,
+		"X-Api-Token": cfg.DownloadConfig.Http.ApiToken,
 	}, nil)
 	if status != http.StatusOK {
 		t.Errorf("TestAuthorization() got = %v, want %v", status, http.StatusOK)
@@ -573,17 +586,23 @@ func doTest(handler func()) {
 		cfg.Storage = storage
 		cfg.StorageDir = ".test_storage"
 		cfg.WebEnable = true
-		fileListener := doStart(cfg)
+		cfg.DownloadConfig = &base.DownloaderStoreConfig{
+			Http: &base.DownloaderHttpConfig{
+				Enable: true,
+			},
+		}
+		httpInstance, _ = Create(cfg)
+		fileListener := doStart()
 		defer func() {
 			if err := fileListener.Close(); err != nil {
 				panic(err)
 			}
-			Stop()
-			Downloader.Clear()
+			httpInstance.StopHttp()
+			httpInstance.Clear()
 		}()
 		defer func() {
-			Downloader.Pause(nil)
-			Downloader.Delete(nil, true)
+			httpInstance.PauseTasks(nil)
+			httpInstance.DeleteTasks(nil, true)
 			os.RemoveAll(cfg.StorageDir)
 		}()
 		taskReq.URL = "http://" + fileListener.Addr().String() + "/" + test.BuildName
@@ -593,15 +612,19 @@ func doTest(handler func()) {
 	testFunc(model.StorageBolt)
 }
 
-func doStart(cfg *model.StartConfig) net.Listener {
-	port, err := Start(cfg)
-	if err != nil {
-		panic(err)
-	}
+func doStart() net.Listener {
+	port := UnwrapResult(httpInstance.StartHttp())
 	restPort = port
 	return test.StartTestFileServer()
 }
 
+func UnwrapResult[T any](result *model.Result[T]) T {
+	if result.HasError() {
+		panic(result.Msg)
+	}
+	return result.Data
+}
+
 func doHttpRequest0(method string, path string, headers map[string]string, body any) (int, []byte) {
 	var reader io.Reader
 	if body != nil {

pkg/api/model/api.go

@@ -14,13 +14,10 @@ const (
 )
 
 type StartConfig struct {
-	Network           string                      `json:"network"`
-	Address           string                      `json:"address"`
 	RefreshInterval   int                         `json:"refreshInterval"`
 	Storage           Storage                     `json:"storage"`
 	StorageDir        string                      `json:"storageDir"`
 	WhiteDownloadDirs []string                    `json:"whiteDownloadDirs"`
-	ApiToken          string                      `json:"apiToken"`
 	DownloadConfig    *base.DownloaderStoreConfig `json:"downloadConfig"`
 
 	ProductionMode bool
@@ -31,12 +28,6 @@ type StartConfig struct {
 }
 
 func (cfg *StartConfig) Init() *StartConfig {
-	if cfg.Network == "" {
-		cfg.Network = "tcp"
-	}
-	if cfg.Address == "" {
-		cfg.Address = "127.0.0.1:0"
-	}
 	if cfg.RefreshInterval == 0 {
 		cfg.RefreshInterval = 350
 	}
@@ -59,3 +50,9 @@ func (cfg *WebBasicAuth) Authorization() string {
 	userId := cfg.Username + ":" + cfg.Password
 	return "Basic " + base64.StdEncoding.EncodeToString([]byte(userId))
 }
+
+type HttpListenResult struct {
+	Host string `json:"host"`
+	// Port is the http server real listen port.
+	Port int `json:"port"`
+}

pkg/api/model/extension.go

@@ -13,6 +13,6 @@ type SwitchExtension struct {
 	Status bool `json:"status"`
 }
 
-type UpdateCheckExtensionResp struct {
+type UpgradeCheckExtensionResp struct {
 	NewVersion string `json:"newVersion"`
 }

pkg/api/model/result.go

@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 type RespCode int
 
 const (
@@ -20,6 +22,15 @@ type Result[T any] struct {
 	Data T        `json:"data"`
 }
 
+func (r *Result[T]) Json() string {
+	buf, _ := json.Marshal(r)
+	return string(buf)
+}
+
+func (r *Result[T]) HasError() bool {
+	return r.Code != CodeOk
+}
+
 func NewOkResult[T any](data T) *Result[T] {
 	return &Result[T]{
 		Code: CodeOk,
@@ -33,14 +44,14 @@ func NewNilResult() *Result[any] {
 	}
 }
 
-func NewErrorResult(msg string, code ...RespCode) *Result[any] {
+func NewErrorResult[T any](msg string, code ...RespCode) *Result[T] {
 	// if code is not provided, the default code is CodeError
 	c := CodeError
 	if len(code) > 0 {
 		c = code[0]
 	}
 
-	return &Result[any]{
+	return &Result[T]{
 		Code: c,
 		Msg:  msg,
 	}

pkg/base/model.go

@@ -171,6 +171,7 @@ type DownloaderStoreConfig struct {
 	MaxRunning     int                    `json:"maxRunning"`     // MaxRunning is the max running download count
 	ProtocolConfig map[string]any         `json:"protocolConfig"` // ProtocolConfig is special config for each protocol
 	Extra          map[string]any         `json:"extra"`
+	Http           *DownloaderHttpConfig  `json:"http"`
 	Proxy          *DownloaderProxyConfig `json:"proxy"`
 }
 
@@ -181,6 +182,12 @@ func (cfg *DownloaderStoreConfig) Init() *DownloaderStoreConfig {
 	if cfg.ProtocolConfig == nil {
 		cfg.ProtocolConfig = make(map[string]any)
 	}
+	if cfg.Extra == nil {
+		cfg.Extra = make(map[string]any)
+	}
+	if cfg.Http == nil {
+		cfg.Http = &DownloaderHttpConfig{}
+	}
 	if cfg.Proxy == nil {
 		cfg.Proxy = &DownloaderProxyConfig{}
 	}
@@ -203,12 +210,28 @@ func (cfg *DownloaderStoreConfig) Merge(beforeCfg *DownloaderStoreConfig) *Downl
 	if cfg.Extra == nil {
 		cfg.Extra = beforeCfg.Extra
 	}
+	if cfg.Http == nil {
+		cfg.Http = beforeCfg.Http
+	}
 	if cfg.Proxy == nil {
 		cfg.Proxy = beforeCfg.Proxy
 	}
 	return cfg
 }
 
+type DownloaderHttpConfig struct {
+	// Enable is the flag that enable http server
+	Enable bool `json:"Enable"`
+	// Host is the http server listen address.
+	Host string `json:"host"`
+	// Port is the http server listen port.
+	Port int `json:"port"`
+	// ApiToken is the auth token for http API
+	ApiToken string `json:"apiToken"`
+	// RunningPort is the http server real listen port.
+	RunningPort int `json:"runningPort"`
+}
+
 type DownloaderProxyConfig struct {
 	Enable bool `json:"enable"`
 	// System is the flag that use system proxy

pkg/base/model_test.go

@@ -17,6 +17,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     5,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy:          &DownloaderProxyConfig{},
 			},
 		},
@@ -28,6 +30,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     10,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy:          &DownloaderProxyConfig{},
 			},
 		},
@@ -43,6 +47,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 				ProtocolConfig: map[string]any{
 					"key": "value",
 				},
+				Extra: make(map[string]any),
+				Http:  &DownloaderHttpConfig{},
 				Proxy: &DownloaderProxyConfig{},
 			},
 		},
@@ -56,6 +62,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     5,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy: &DownloaderProxyConfig{
 					Enable: true,
 				},

pkg/download/downloader.go

@@ -252,7 +252,7 @@ func (d *Downloader) setupFetcher(fm fetcher.FetcherManager, fetcher fetcher.Fet
 	ctl.GetConfig = func(v any) {
 		d.getProtocolConfig(fm.Name(), v)
 	}
-	// Get proxy config, task request proxy config has higher priority, then use global proxy config
+	// get proxy config, task request proxy config has higher priority, then use global proxy config
 	ctl.GetProxy = func(requestProxy *base.RequestProxy) func(*gohttp.Request) (*url.URL, error) {
 		if requestProxy == nil {
 			return d.cfg.Proxy.ToHandler()
@@ -390,7 +390,7 @@ func (d *Downloader) Pause(filter *TaskFilter) (err error) {
 		return d.pauseAll()
 	}
 
-	filter.NotStatuses = []base.Status{base.DownloadStatusPause, base.DownloadStatusError, base.DownloadStatusDone}
+	filter.NotStatus = []base.Status{base.DownloadStatusPause, base.DownloadStatusError, base.DownloadStatusDone}
 	pauseTasks := d.GetTasksByFilter(filter)
 	if len(pauseTasks) == 0 {
 		return ErrTaskNotFound
@@ -430,7 +430,7 @@ func (d *Downloader) Continue(filter *TaskFilter) (err error) {
 		return d.continueAll()
 	}
 
-	filter.NotStatuses = []base.Status{base.DownloadStatusRunning, base.DownloadStatusDone}
+	filter.NotStatus = []base.Status{base.DownloadStatusRunning, base.DownloadStatusDone}
 	continueTasks := d.GetTasksByFilter(filter)
 	if len(continueTasks) == 0 {
 		return ErrTaskNotFound
@@ -527,7 +527,7 @@ func (d *Downloader) ContinueBatch(filter *TaskFilter) (err error) {
 
 func (d *Downloader) Delete(filter *TaskFilter, force bool) (err error) {
 	if filter == nil || filter.IsEmpty() {
-		return d.deleteAll()
+		return d.deleteAll(force)
 	}
 
 	deleteTasks := d.GetTasksByFilter(filter)
@@ -572,24 +572,27 @@ func (d *Downloader) Delete(filter *TaskFilter, force bool) (err error) {
 	return
 }
 
-func (d *Downloader) deleteAll() (err error) {
+func (d *Downloader) deleteAll(force bool) (err error) {
+	deleteTasksPtr := make([]*Task, 0)
+
 	func() {
 		d.lock.Lock()
 		defer d.lock.Unlock()
 
+		deleteTasksPtr = append(deleteTasksPtr, d.tasks...)
 		d.tasks = make([]*Task, 0)
 		d.waitTasks = make([]*Task, 0)
 	}()
 
-	for _, task := range d.tasks {
-		if err = d.doDelete(task, true); err != nil {
+	for _, task := range deleteTasksPtr {
+		if err = d.doDelete(task, force); err != nil {
 			return
 		}
 	}
 	return
 }
 
-func (d *Downloader) Stats(id string) (sr any, err error) {
+func (d *Downloader) GetTaskStats(id string) (sr any, err error) {
 	task := d.GetTask(id)
 	if task == nil {
 		return sr, ErrTaskNotFound
@@ -719,10 +722,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 	}
 
 	idMatch := func(task *Task) bool {
-		if len(filter.IDs) == 0 {
+		if len(filter.ID) == 0 {
 			return true
 		}
-		for _, id := range filter.IDs {
+		for _, id := range filter.ID {
 			if task.ID == id {
 				return true
 			}
@@ -730,10 +733,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 		return false
 	}
 	statusMatch := func(task *Task) bool {
-		if len(filter.Statuses) == 0 {
+		if len(filter.Status) == 0 {
 			return true
 		}
-		for _, status := range filter.Statuses {
+		for _, status := range filter.Status {
 			if task.Status == status {
 				return true
 			}
@@ -741,10 +744,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 		return false
 	}
 	notStatusMatch := func(task *Task) bool {
-		if len(filter.NotStatuses) == 0 {
+		if len(filter.NotStatus) == 0 {
 			return true
 		}
-		for _, status := range filter.NotStatuses {
+		for _, status := range filter.NotStatus {
 			if task.Status == status {
 				return false
 			}
@@ -826,7 +829,7 @@ func (d *Downloader) watch(task *Task) {
 	}
 
 	// When delete a not resolved task, need check if the task resource is nil
-	if task.Meta.Res == nil || d.GetTask(task.ID) == nil {
+	if task.Meta.Res == nil {
 		return
 	}
 

pkg/download/downloader_test.go

@@ -400,7 +400,7 @@ func TestDownloader_StoreAndRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 	time.Sleep(time.Millisecond * 1001)
-	err = downloader.Pause(&TaskFilter{IDs: []string{id}})
+	err = downloader.Pause(&TaskFilter{ID: []string{id}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -424,7 +424,7 @@ func TestDownloader_StoreAndRestore(t *testing.T) {
 			wg.Done()
 		}
 	})
-	err = downloader.Continue(&TaskFilter{IDs: []string{id}})
+	err = downloader.Continue(&TaskFilter{ID: []string{id}})
 	wg.Wait()
 	if err != nil {
 		t.Fatal(err)
@@ -551,7 +551,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: taskIds,
+			ID: taskIds,
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), len(reqs))
@@ -560,7 +560,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: []string{taskIds[0]},
+			ID: []string{taskIds[0]},
 		})
 		if len(tasks) != 1 {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), 1)
@@ -569,7 +569,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: []string{"xxx"},
+			ID: []string{"xxx"},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), 0)
@@ -578,7 +578,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			Statuses: []base.Status{base.DownloadStatusDone},
+			Status: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter status task got = %v, want %v", len(tasks), len(reqs))
@@ -587,7 +587,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			Statuses: []base.Status{base.DownloadStatusError},
+			Status: []base.Status{base.DownloadStatusError},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter status task got = %v, want %v", len(tasks), 0)
@@ -596,7 +596,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match notStatus", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			NotStatuses: []base.Status{base.DownloadStatusRunning, base.DownloadStatusPause},
+			NotStatus: []base.Status{base.DownloadStatusRunning, base.DownloadStatusPause},
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter match notStatus task got = %v, want %v", len(tasks), len(reqs))
@@ -605,7 +605,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match notStatus", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			NotStatuses: []base.Status{base.DownloadStatusDone},
+			NotStatus: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter not match notStatus task got = %v, want %v", len(tasks), 0)
@@ -614,8 +614,8 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match ids and status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs:      []string{taskIds[0]},
-			Statuses: []base.Status{base.DownloadStatusDone},
+			ID:     []string{taskIds[0]},
+			Status: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != 1 {
 			t.Errorf("GetTasksByFilter match ids and status task got = %v, want %v", len(tasks), 1)
@@ -624,8 +624,8 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match ids and status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs:      []string{taskIds[0]},
-			Statuses: []base.Status{base.DownloadStatusError},
+			ID:     []string{taskIds[0]},
+			Status: []base.Status{base.DownloadStatusError},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter not match ids and status task got = %v, want %v", len(tasks), 0)

pkg/download/extension.go

@@ -702,34 +702,38 @@ type OnDoneContext struct {
 	Task *Task `json:"task"`
 }
 
-// ExtensionTask is a wrapper of Task, it's used to interact with extension scripts.
-// Avoid extension scripts modifying task directly, use ExtensionTask to encapsulate task,
-// only some fields can be modified, such as request info.
 type ExtensionTask struct {
 	download *Downloader
+	task     *Task
 
-	*Task
+	Meta *ExtensionTaskMeta `json:"meta"`
+}
+
+// ExtensionTaskMeta restricts extension scripts to only modify request info
+type ExtensionTaskMeta struct {
+	Req *base.Request `json:"req"`
 }
 
 func NewExtensionTask(download *Downloader, task *Task) *ExtensionTask {
-	// restricts extension scripts to only modify request info
 	newTask := task.clone()
-	newTask.Meta.Req = task.Meta.Req
 	return &ExtensionTask{
+		task:     newTask,
 		download: download,
-		Task:     newTask,
+		Meta: &ExtensionTaskMeta{
+			Req: task.Meta.Req,
+		},
 	}
 }
 
 func (t *ExtensionTask) Continue() error {
 	return t.download.Continue(&TaskFilter{
-		IDs: []string{t.ID},
+		ID: []string{t.task.ID},
 	})
 }
 
 func (t *ExtensionTask) Pause() error {
 	return t.download.Pause(&TaskFilter{
-		IDs: []string{t.ID},
+		ID: []string{t.task.ID},
 	})
 }
 

pkg/download/model.go

@@ -75,7 +75,7 @@ func (t *Task) Name() string {
 		return t.Meta.Res.Name
 	}
 
-	// Get the name of the first file
+	// get the name of the first file
 	return t.Meta.Res.Files[0].Name
 }
 
@@ -113,13 +113,13 @@ func (t *Task) calcSpeed(speedArr []int64, downloaded int64, usedTime float64) i
 }
 
 type TaskFilter struct {
-	IDs         []string
-	Statuses    []base.Status
-	NotStatuses []base.Status
+	ID        []string      `json:"id"`
+	Status    []base.Status `json:"status"`
+	NotStatus []base.Status `json:"notStatus"`
 }
 
 func (f *TaskFilter) IsEmpty() bool {
-	return len(f.IDs) == 0 && len(f.Statuses) == 0 && len(f.NotStatuses) == 0
+	return len(f.ID) == 0 && len(f.Status) == 0 && len(f.NotStatus) == 0
 }
 
 type DownloaderConfig struct {

pkg/rest/api.go

@@ -1,389 +0,0 @@
-package rest
-
-import (
-	"github.com/GopeedLab/gopeed/pkg/base"
-	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"github.com/gorilla/mux"
-	"io"
-	"net/http"
-	"net/url"
-	"runtime"
-)
-
-func Info(w http.ResponseWriter, r *http.Request) {
-	info := map[string]any{
-		"version":  base.Version,
-		"runtime":  runtime.Version(),
-		"os":       runtime.GOOS,
-		"arch":     runtime.GOARCH,
-		"inDocker": base.InDocker == "true",
-	}
-	WriteJson(w, model.NewOkResult(info))
-}
-
-func Resolve(w http.ResponseWriter, r *http.Request) {
-	var req base.Request
-	if ReadJson(r, w, &req) {
-		rr, err := Downloader.Resolve(&req)
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(rr))
-	}
-}
-
-func CreateTask(w http.ResponseWriter, r *http.Request) {
-	var req model.CreateTask
-	if ReadJson(r, w, &req) {
-		var (
-			taskId string
-			err    error
-		)
-		if req.Rid != "" {
-			taskId, err = Downloader.Create(req.Rid, req.Opt)
-		} else if req.Req != nil {
-			taskId, err = Downloader.CreateDirect(req.Req, req.Opt)
-		} else {
-			WriteJson(w, model.NewErrorResult("param invalid: rid or req", model.CodeInvalidParam))
-			return
-		}
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(taskId))
-	}
-}
-
-func CreateTaskBatch(w http.ResponseWriter, r *http.Request) {
-	var req model.CreateTaskBatch
-	if ReadJson(r, w, &req) {
-		if len(req.Reqs) == 0 {
-			WriteJson(w, model.NewErrorResult("param invalid: reqs", model.CodeInvalidParam))
-			return
-		}
-		taskIds, err := Downloader.CreateDirectBatch(req.Reqs, req.Opt)
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(taskIds))
-	}
-}
-
-func PauseTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Pause(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func PauseTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Pause(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func ContinueTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Continue(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func ContinueTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Continue(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-	force := r.FormValue("force")
-
-	if err := Downloader.Delete(filter, force == "true"); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-	force := r.FormValue("force")
-
-	if err := Downloader.Delete(filter, force == "true"); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func GetTask(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		WriteJson(w, model.NewErrorResult("param invalid: id", model.CodeInvalidParam))
-		return
-	}
-	task := Downloader.GetTask(taskId)
-	if task == nil {
-		WriteJson(w, model.NewErrorResult("task not found", model.CodeTaskNotFound))
-		return
-	}
-	WriteJson(w, model.NewOkResult(task))
-}
-
-func GetTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	tasks := Downloader.GetTasksByFilter(filter)
-	WriteJson(w, model.NewOkResult(tasks))
-}
-
-func GetConfig(w http.ResponseWriter, r *http.Request) {
-	WriteJson(w, model.NewOkResult(getServerConfig()))
-}
-
-func PutConfig(w http.ResponseWriter, r *http.Request) {
-	var cfg base.DownloaderStoreConfig
-	if ReadJson(r, w, &cfg) {
-		if err := Downloader.PutConfig(&cfg); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func InstallExtension(w http.ResponseWriter, r *http.Request) {
-	var req model.InstallExtension
-	if ReadJson(r, w, &req) {
-		var (
-			installedExt *download.Extension
-			err          error
-		)
-		if req.DevMode {
-			installedExt, err = Downloader.InstallExtensionByFolder(req.URL, true)
-		} else {
-			installedExt, err = Downloader.InstallExtensionByGit(req.URL)
-		}
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(installedExt.Identity))
-	}
-}
-
-func GetExtensions(w http.ResponseWriter, r *http.Request) {
-	list := Downloader.GetExtensions()
-	WriteJson(w, model.NewOkResult(list))
-}
-
-func GetExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	ext, err := Downloader.GetExtension(identity)
-	if err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewOkResult(ext))
-}
-
-func UpdateExtensionSettings(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	var req model.UpdateExtensionSettings
-	if ReadJson(r, w, &req) {
-		if err := Downloader.UpdateExtensionSettings(identity, req.Settings); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func SwitchExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	var switchExtension model.SwitchExtension
-	if ReadJson(r, w, &switchExtension) {
-		if err := Downloader.SwitchExtension(identity, switchExtension.Status); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	if err := Downloader.DeleteExtension(identity); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func UpdateCheckExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	newVersion, err := Downloader.UpgradeCheckExtension(identity)
-	if err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewOkResult(&model.UpdateCheckExtensionResp{
-		NewVersion: newVersion,
-	}))
-}
-
-func UpdateExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	if err := Downloader.UpgradeExtension(identity); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DoProxy(w http.ResponseWriter, r *http.Request) {
-	target := r.Header.Get("X-Target-Uri")
-	if target == "" {
-		writeError(w, "param invalid: X-Target-Uri")
-		return
-	}
-	targetUrl, err := url.Parse(target)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	r.RequestURI = ""
-	r.URL = targetUrl
-	r.Host = targetUrl.Host
-	resp, err := http.DefaultClient.Do(r)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	defer resp.Body.Close()
-	for k, vv := range resp.Header {
-		for _, v := range vv {
-			w.Header().Set(k, v)
-		}
-	}
-	w.WriteHeader(resp.StatusCode)
-	buf, err := io.ReadAll(resp.Body)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	w.Write(buf)
-}
-
-func GetStats(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		WriteJson(w, model.NewErrorResult("param invalid: id", model.CodeInvalidParam))
-		return
-	}
-	statsResult, err := Downloader.Stats(taskId)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	WriteJson(w, model.NewOkResult(statsResult))
-}
-
-func parseIdFilter(r *http.Request) (*download.TaskFilter, any) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		return nil, model.NewErrorResult("param invalid: id", model.CodeInvalidParam)
-	}
-
-	filter := &download.TaskFilter{
-		IDs: []string{taskId},
-	}
-	return filter, nil
-}
-
-func parseFilter(r *http.Request) (*download.TaskFilter, any) {
-	if err := r.ParseForm(); err != nil {
-		return nil, model.NewErrorResult(err.Error())
-	}
-
-	filter := &download.TaskFilter{
-		IDs:         r.Form["id"],
-		Statuses:    convertStatues(r.Form["status"]),
-		NotStatuses: convertStatues(r.Form["notStatus"]),
-	}
-	return filter, nil
-}
-
-func convertStatues(statues []string) []base.Status {
-	result := make([]base.Status, 0)
-	for _, status := range statues {
-		result = append(result, base.Status(status))
-	}
-	return result
-}
-
-func writeError(w http.ResponseWriter, msg string) {
-	w.WriteHeader(http.StatusInternalServerError)
-	w.Write([]byte(msg))
-}
-
-func getServerConfig() *base.DownloaderStoreConfig {
-	cfg, _ := Downloader.GetConfig()
-	return cfg
-}

pkg/rest/config.go

@@ -1,6 +0,0 @@
-package rest
-
-type Config struct {
-	Host string `json:"host"`
-	Port int    `json:"port"`
-}

pkg/rest/server.go

@@ -1,241 +0,0 @@
-package rest
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"github.com/GopeedLab/gopeed/pkg/util"
-	"github.com/gorilla/handlers"
-	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-var (
-	srv         *http.Server
-	runningPort int
-
-	Downloader *download.Downloader
-)
-
-func Start(startCfg *model.StartConfig) (port int, err error) {
-	// avoid repeat start
-	if srv != nil {
-		return runningPort, nil
-	}
-
-	var listener net.Listener
-	srv, listener, err = BuildServer(startCfg)
-	if err != nil {
-		return
-	}
-
-	go func() {
-		if err := srv.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
-			panic(err)
-		}
-	}()
-
-	if addr, ok := listener.Addr().(*net.TCPAddr); ok {
-		port = addr.Port
-		runningPort = port
-	}
-	return
-}
-
-func Stop() {
-	defer func() {
-		srv = nil
-	}()
-
-	if srv != nil {
-		if err := srv.Shutdown(context.TODO()); err != nil {
-			Downloader.Logger.Warn().Err(err).Msg("shutdown server failed")
-		}
-	}
-	if Downloader != nil {
-		if err := Downloader.Close(); err != nil {
-			Downloader.Logger.Warn().Err(err).Msg("close downloader failed")
-		}
-	}
-}
-
-func BuildServer(startCfg *model.StartConfig) (*http.Server, net.Listener, error) {
-	if startCfg == nil {
-		startCfg = &model.StartConfig{}
-	}
-	startCfg.Init()
-
-	downloadCfg := &download.DownloaderConfig{
-		ProductionMode:  startCfg.ProductionMode,
-		RefreshInterval: startCfg.RefreshInterval,
-	}
-	if startCfg.Storage == model.StorageBolt {
-		downloadCfg.Storage = download.NewBoltStorage(startCfg.StorageDir)
-	} else {
-		downloadCfg.Storage = download.NewMemStorage()
-	}
-	downloadCfg.StorageDir = startCfg.StorageDir
-	downloadCfg.Init()
-	Downloader = download.NewDownloader(downloadCfg)
-	if err := Downloader.Setup(); err != nil {
-		return nil, nil, err
-	}
-
-	if startCfg.Network == "unix" {
-		util.SafeRemove(startCfg.Address)
-	}
-
-	listener, err := net.Listen(startCfg.Network, startCfg.Address)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var r = mux.NewRouter()
-	r.Methods(http.MethodGet).Path("/api/v1/info").HandlerFunc(Info)
-	r.Methods(http.MethodPost).Path("/api/v1/resolve").HandlerFunc(Resolve)
-	r.Methods(http.MethodPost).Path("/api/v1/tasks").HandlerFunc(CreateTask)
-	r.Methods(http.MethodPost).Path("/api/v1/tasks/batch").HandlerFunc(CreateTaskBatch)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/pause").HandlerFunc(PauseTask)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/pause").HandlerFunc(PauseTasks)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/continue").HandlerFunc(ContinueTask)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/continue").HandlerFunc(ContinueTasks)
-	r.Methods(http.MethodDelete).Path("/api/v1/tasks/{id}").HandlerFunc(DeleteTask)
-	r.Methods(http.MethodDelete).Path("/api/v1/tasks").HandlerFunc(DeleteTasks)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}").HandlerFunc(GetTask)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks").HandlerFunc(GetTasks)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}/stats").HandlerFunc(GetStats)
-	r.Methods(http.MethodGet).Path("/api/v1/config").HandlerFunc(GetConfig)
-	r.Methods(http.MethodPut).Path("/api/v1/config").HandlerFunc(PutConfig)
-	r.Methods(http.MethodPost).Path("/api/v1/extensions").HandlerFunc(InstallExtension)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions").HandlerFunc(GetExtensions)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}").HandlerFunc(GetExtension)
-	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/settings").HandlerFunc(UpdateExtensionSettings)
-	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/switch").HandlerFunc(SwitchExtension)
-	r.Methods(http.MethodDelete).Path("/api/v1/extensions/{identity}").HandlerFunc(DeleteExtension)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}/update").HandlerFunc(UpdateCheckExtension)
-	r.Methods(http.MethodPost).Path("/api/v1/extensions/{identity}/update").HandlerFunc(UpdateExtension)
-	r.Path("/api/v1/proxy").HandlerFunc(DoProxy)
-	if startCfg.WebEnable {
-		r.PathPrefix("/fs/tasks").Handler(http.FileServer(new(taskFileSystem)))
-		r.PathPrefix("/fs/extensions").Handler(http.FileServer(new(extensionFileSystem)))
-		r.PathPrefix("/").Handler(http.FileServer(http.FS(startCfg.WebFS)))
-	}
-
-	if startCfg.ApiToken != "" || (startCfg.WebEnable && startCfg.WebBasicAuth != nil) {
-		r.Use(func(h http.Handler) http.Handler {
-			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if startCfg.ApiToken != "" && r.Header.Get("X-Api-Token") == startCfg.ApiToken {
-					h.ServeHTTP(w, r)
-					return
-				}
-				if startCfg.WebEnable && startCfg.WebBasicAuth != nil {
-					if r.Header.Get("Authorization") == startCfg.WebBasicAuth.Authorization() {
-						h.ServeHTTP(w, r)
-						return
-					}
-					w.Header().Set("WWW-Authenticate", "Basic realm=\"gopeed web\"")
-				}
-				WriteStatusJson(w, http.StatusUnauthorized, model.NewErrorResult("unauthorized", model.CodeUnauthorized))
-			})
-		})
-	}
-
-	// recover panic
-	r.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			defer func() {
-				if v := recover(); v != nil {
-					err := errors.WithStack(fmt.Errorf("%v", v))
-					Downloader.Logger.Error().Stack().Err(err).Msgf("http server panic: %s %s", r.Method, r.RequestURI)
-					WriteJson(w, model.NewErrorResult(err.Error(), model.CodeError))
-				}
-			}()
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	srv = &http.Server{Handler: handlers.CORS(
-		handlers.AllowedHeaders([]string{"Content-Type", "X-Api-Token", "X-Target-Uri"}),
-		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}),
-		handlers.AllowedOrigins([]string{"*"}),
-	)(r)}
-	return srv, listener, nil
-}
-
-func resolvePath(urlPath string, prefix string) (identity string, path string, err error) {
-	// remove prefix
-	clearPath := strings.TrimPrefix(urlPath, prefix)
-	// match extension identity, eg: /fs/extensions/identity/xxx
-	reg := regexp.MustCompile(`^/([^/]+)/(.*)$`)
-	if !reg.MatchString(clearPath) {
-		err = os.ErrNotExist
-		return
-	}
-	matched := reg.FindStringSubmatch(clearPath)
-	if len(matched) != 3 {
-		err = os.ErrNotExist
-		return
-	}
-	return matched[1], matched[2], nil
-}
-
-// handle task file resource
-type taskFileSystem struct {
-}
-
-func (e *taskFileSystem) Open(name string) (http.File, error) {
-	// get extension identity
-	identity, path, err := resolvePath(name, "/fs/tasks")
-	if err != nil {
-		return nil, err
-	}
-	task := Downloader.GetTask(identity)
-	if task == nil {
-		return nil, os.ErrNotExist
-	}
-	return os.Open(filepath.Join(task.Meta.RootDirPath(), path))
-}
-
-// handle extension file resource
-type extensionFileSystem struct {
-}
-
-func (e *extensionFileSystem) Open(name string) (http.File, error) {
-	// get extension identity
-	identity, path, err := resolvePath(name, "/fs/extensions")
-	if err != nil {
-		return nil, err
-	}
-	extension, err := Downloader.GetExtension(identity)
-	if err != nil {
-		return nil, os.ErrNotExist
-	}
-	extensionPath := Downloader.ExtensionPath(extension)
-	return os.Open(filepath.Join(extensionPath, path))
-}
-
-func ReadJson(r *http.Request, w http.ResponseWriter, v any) bool {
-	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return false
-	}
-	return true
-}
-
-func WriteJson(w http.ResponseWriter, v any) {
-	WriteStatusJson(w, http.StatusOK, v)
-}
-
-func WriteStatusJson(w http.ResponseWriter, statusCode int, v any) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	w.WriteHeader(statusCode)
-	json.NewEncoder(w).Encode(v)
-}

ui/flutter/include/libgopeed.h

@@ -74,14 +74,8 @@ typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
 extern "C" {
 #endif
 
-
-/* Return type for Start */
-struct Start_return {
-	GoInt r0;
-	char* r1;
-};
-extern struct Start_return Start(char* cfg);
-extern void Stop();
+extern __declspec(dllexport) char* Init(char* cfg);
+extern __declspec(dllexport) char* Invoke(char* req);
 
 #ifdef __cplusplus
 }

ui/flutter/lib/api/api.dart

@@ -1,227 +0,0 @@
-import 'dart:io';
-
-import 'package:dio/dio.dart';
-import 'package:dio/io.dart';
-import 'package:flutter/foundation.dart';
-import 'package:gopeed/api/model/extension.dart';
-import 'package:gopeed/api/model/install_extension.dart';
-import 'package:gopeed/api/model/switch_extension.dart';
-
-import '../util/util.dart';
-import 'model/create_task.dart';
-import 'model/downloader_config.dart';
-import 'model/request.dart';
-import 'model/resolve_result.dart';
-import 'model/result.dart';
-import 'model/task.dart';
-import 'model/update_extension_settings.dart';
-import 'model/update_check_extension_resp.dart';
-
-class _Client {
-  static _Client? _instance;
-
-  late Dio dio;
-
-  _Client._internal();
-
-  factory _Client(String network, String address, String apiToken) {
-    if (_instance == null) {
-      _instance = _Client._internal();
-      var dio = Dio();
-      final isUnixSocket = network == 'unix';
-      var baseUrl = 'http://127.0.0.1';
-      if (!isUnixSocket) {
-        if (Util.isWeb()) {
-          baseUrl = kDebugMode ? 'http://127.0.0.1:9999' : '';
-        } else {
-          baseUrl = 'http://$address';
-        }
-      }
-      dio.options.baseUrl = baseUrl;
-      dio.options.contentType = Headers.jsonContentType;
-      dio.options.sendTimeout = const Duration(seconds: 5);
-      dio.options.connectTimeout = const Duration(seconds: 5);
-      dio.options.receiveTimeout = const Duration(seconds: 60);
-      dio.interceptors.add(InterceptorsWrapper(onRequest: (options, handler) {
-        if (apiToken.isNotEmpty) {
-          options.headers['X-Api-Token'] = apiToken;
-        }
-        handler.next(options);
-      }));
-
-      _instance!.dio = dio;
-      if (isUnixSocket) {
-        (_instance!.dio.httpClientAdapter as IOHttpClientAdapter)
-            .createHttpClient = () {
-          final client = HttpClient();
-          client.connectionFactory =
-              (Uri uri, String? proxyHost, int? proxyPort) {
-            return Socket.startConnect(
-                InternetAddress(address, type: InternetAddressType.unix), 0);
-          };
-          return client;
-        };
-      }
-    }
-    return _instance!;
-  }
-}
-
-class TimeoutException implements Exception {
-  final String message;
-
-  TimeoutException(this.message);
-}
-
-late _Client _client;
-
-void init(String network, String address, String apiToken) {
-  _client = _Client(network, address, apiToken);
-}
-
-Future<T> _parse<T>(
-  Future<Response> Function() fetch,
-  T Function(dynamic json)? fromJsonT,
-) async {
-  try {
-    var resp = await fetch();
-    fromJsonT ??= (json) => null as T;
-    final result = Result<T>.fromJson(resp.data, fromJsonT);
-    if (result.code == 0) {
-      return result.data as T;
-    } else {
-      throw Exception(result);
-    }
-  } on DioException catch (e) {
-    if (e.type == DioExceptionType.sendTimeout ||
-        e.type == DioExceptionType.receiveTimeout ||
-        e.type == DioExceptionType.connectionTimeout) {
-      throw TimeoutException("request timeout");
-    }
-    throw Exception(Result(code: 1000, msg: e.message));
-  }
-}
-
-Future<ResolveResult> resolve(Request request) async {
-  return _parse<ResolveResult>(
-      () => _client.dio.post("/api/v1/resolve", data: request),
-      (data) => ResolveResult.fromJson(data));
-}
-
-Future<String> createTask(CreateTask createTask) async {
-  return _parse<String>(
-      () => _client.dio.post("/api/v1/tasks", data: createTask),
-      (data) => data as String);
-}
-
-Future<List<Task>> getTasks(List<Status> statuses) async {
-  return _parse<List<Task>>(
-      () => _client.dio.get(
-          "/api/v1/tasks?${statuses.map((e) => "status=${e.name}").join("&")}"),
-      (data) => (data as List).map((e) => Task.fromJson(e)).toList());
-}
-
-Future<void> pauseTask(String id) async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/$id/pause"), null);
-}
-
-Future<void> continueTask(String id) async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/$id/continue"), null);
-}
-
-Future<void> pauseAllTasks(List<String>? ids) async {
-  return _parse(
-      () => _client.dio.put("/api/v1/tasks/pause", queryParameters: {
-            "id": ids,
-          }),
-      null);
-}
-
-Future<void> continueAllTasks(List<String>? ids) async {
-  return _parse(
-      () => _client.dio.put("/api/v1/tasks/continue", queryParameters: {
-            "id": ids,
-          }),
-      null);
-}
-
-Future<void> deleteTask(String id, bool force) async {
-  return _parse(
-      () => _client.dio.delete("/api/v1/tasks/$id?force=$force"), null);
-}
-
-Future<void> deleteTasks(List<String>? ids, bool force) async {
-  return _parse(
-      () => _client.dio.delete("/api/v1/tasks", queryParameters: {
-            "id": ids,
-            "force": force,
-          }),
-      null);
-}
-
-Future<DownloaderConfig> getConfig() async {
-  return _parse(() => _client.dio.get("/api/v1/config"),
-      (data) => DownloaderConfig.fromJson(data));
-}
-
-Future<void> putConfig(DownloaderConfig config) async {
-  return _parse(() => _client.dio.put("/api/v1/config", data: config), null);
-}
-
-Future<void> installExtension(InstallExtension installExtension) async {
-  return _parse(
-      () => _client.dio.post("/api/v1/extensions", data: installExtension),
-      null);
-}
-
-Future<List<Extension>> getExtensions() async {
-  return _parse<List<Extension>>(() => _client.dio.get("/api/v1/extensions"),
-      (data) => (data as List).map((e) => Extension.fromJson(e)).toList());
-}
-
-Future<void> updateExtensionSettings(
-    String identity, UpdateExtensionSettings updateExtensionSettings) async {
-  return _parse(
-      () => _client.dio.put("/api/v1/extensions/$identity/settings",
-          data: updateExtensionSettings),
-      null);
-}
-
-Future<void> switchExtension(
-    String identity, SwitchExtension switchExtension) async {
-  return _parse(
-      () => _client.dio
-          .put("/api/v1/extensions/$identity/switch", data: switchExtension),
-      null);
-}
-
-Future<void> deleteExtension(String identity) async {
-  return _parse(() => _client.dio.delete("/api/v1/extensions/$identity"), null);
-}
-
-Future<UpdateCheckExtensionResp> upgradeCheckExtension(String identity) async {
-  return _parse(() => _client.dio.get("/api/v1/extensions/$identity/update"),
-      (data) => UpdateCheckExtensionResp.fromJson(data));
-}
-
-Future<void> updateExtension(String identity) async {
-  return _parse(
-      () => _client.dio.post("/api/v1/extensions/$identity/update"), null);
-}
-
-Future<Response<String>> proxyRequest<T>(String uri,
-    {data, Options? options}) async {
-  options ??= Options();
-  options.headers ??= {};
-  options.headers!["X-Target-Uri"] = uri;
-
-  // add timestamp to avoid cache
-  return _client.dio.request(
-      "/api/v1/proxy?t=${DateTime.now().millisecondsSinceEpoch}",
-      data: data,
-      options: options);
-}
-
-String join(String path) {
-  return "${_client.dio.options.baseUrl}/${Util.cleanPath(path)}";
-}

ui/flutter/lib/api/api_exception.dart

@@ -0,0 +1,6 @@
+class ApiException implements Exception {
+  final int code;
+  final String message;
+
+  ApiException(this.code, this.message);
+}

ui/flutter/lib/api/entry/libgopeed_boot_base.dart

@@ -0,0 +1,25 @@
+import 'package:dio/dio.dart';
+
+import '../api_exception.dart';
+import '../model/result.dart';
+
+mixin LibgopeedBootBase {
+  Dio createDio() {
+    Dio dio = Dio();
+    dio.options.contentType = Headers.jsonContentType;
+    dio.options.sendTimeout = const Duration(seconds: 5);
+    dio.options.connectTimeout = const Duration(seconds: 5);
+    dio.options.receiveTimeout = const Duration(seconds: 60);
+    return dio;
+  }
+
+  T handleResult<T>(
+    Result<T> result,
+  ) {
+    if (result.code == 0) {
+      return result.data as T;
+    } else {
+      throw ApiException(result.code, result.msg ?? '');
+    }
+  }
+}

ui/flutter/lib/api/entry/libgopeed_boot_native.dart

@@ -0,0 +1,239 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+
+import '../../api/model/create_task.dart';
+import '../../api/model/create_task_batch.dart';
+import '../../api/model/downloader_config.dart';
+import '../../api/model/extension.dart';
+import '../../api/model/http_listen_result.dart';
+import '../../api/model/info.dart';
+import '../../api/model/install_extension.dart';
+import '../../api/model/request.dart';
+import '../../api/model/resolve_result.dart';
+import '../../api/model/result.dart';
+import '../../api/model/switch_extension.dart';
+import '../../api/model/task.dart';
+import '../../api/model/task_filter.dart';
+import '../../api/model/update_check_extension_resp.dart';
+import '../../api/model/update_extension_settings.dart';
+import '../../util/extensions.dart';
+import '../../util/util.dart';
+import '../libgopeed_boot.dart';
+import '../native/channel/libgopeed_channel.dart';
+import '../native/ffi/libgopeed_bind.dart';
+import '../native/ffi/libgopeed_ffi.dart';
+import '../native/libgopeed_interface.dart';
+import '../native/model/invoke_request.dart';
+import '../native/model/start_config.dart';
+import 'libgopeed_boot_base.dart';
+
+LibgopeedBoot create() => LibgopeedBootNative();
+
+class LibgopeedBootNative
+    with LibgopeedBootBase
+    implements LibgopeedBoot, LibgopeedApi {
+  late LibgopeedAbi _libgopeedAbi;
+  late Dio _dio;
+
+  LibgopeedBootNative() {
+    if (Util.isDesktop()) {
+      var libName = "libgopeed.";
+      if (Platform.isWindows) {
+        libName += "dll";
+      }
+      if (Platform.isMacOS) {
+        libName += "dylib";
+      }
+      if (Platform.isLinux) {
+        libName += "so";
+      }
+      _libgopeedAbi = LibgopeedFFi(LibgopeedBind(DynamicLibrary.open(libName)));
+    } else {
+      _libgopeedAbi = LibgopeedChannel();
+    }
+  }
+
+  Future<T> _invoke<T>(
+    String method,
+    List<dynamic> params,
+    T Function(dynamic json)? fromJsonT,
+  ) async {
+    final invokeRequest = InvokeRequest(method: method, params: params);
+    final resp = await _libgopeedAbi.invoke(jsonEncode(invokeRequest));
+    final result =
+        Result<T>.fromJson(jsonDecode(resp), fromJsonT ??= (json) => null as T);
+    return handleResult(result);
+  }
+
+  List<dynamic> _parseTaskFilter(TaskFilter? filter) {
+    if (filter == null) {
+      return [null];
+    }
+    return [filter];
+  }
+
+  @override
+  Future<LibgopeedApi> init(StartConfig cfg) async {
+    await _libgopeedAbi.init(jsonEncode(cfg.toJson()));
+    _dio = createDio();
+    return this;
+  }
+
+  @override
+  Future<HttpListenResult> startHttp() async {
+    return _invoke<HttpListenResult>(
+        "StartHttp", [], (json) => HttpListenResult.fromJson(json));
+  }
+
+  @override
+  Future<void> stopHttp() async {
+    await _invoke<void>("StopHttp", [], null);
+  }
+
+  @override
+  Future<void> restartHttp() async {
+    await _invoke<void>("RestartHttp", [], null);
+  }
+
+  @override
+  Future<Info> info() async {
+    return _invoke<Info>("Info", [], (json) => Info.fromJson(json));
+  }
+
+  @override
+  Future<ResolveResult> resolve(Request request) async {
+    return _invoke<ResolveResult>(
+        "Resolve", [request], (json) => ResolveResult.fromJson(json));
+  }
+
+  @override
+  Future<String> createTask(CreateTask createTask) async {
+    return _invoke<String>(
+        "CreateTask", [createTask], (json) => json as String);
+  }
+
+  @override
+  Future<String> createTaskBatch(CreateTaskBatch createTask) async {
+    return _invoke<String>(
+        "CreateTaskBatch", [createTask], (json) => json as String);
+  }
+
+  @override
+  Future<void> pauseTask(String id) async {
+    await _invoke<void>("PauseTask", [id], null);
+  }
+
+  @override
+  Future<void> pauseTasks(TaskFilter? filter) async {
+    await _invoke<void>("PauseTasks", _parseTaskFilter(filter), null);
+  }
+
+  @override
+  Future<void> continueTask(String id) async {
+    await _invoke<void>("ContinueTask", [id], null);
+  }
+
+  @override
+  Future<void> continueTasks(TaskFilter? filter) async {
+    await _invoke<void>("ContinueTasks", _parseTaskFilter(filter), null);
+  }
+
+  @override
+  Future<void> deleteTask(String id, bool force) async {
+    await _invoke<void>("DeleteTask", [id, force], null);
+  }
+
+  @override
+  Future<void> deleteTasks(TaskFilter? filter, bool force) async {
+    await _invoke<void>(
+        "DeleteTasks",
+        _parseTaskFilter(filter).apply((it) {
+          it.add(force);
+        }),
+        null);
+  }
+
+  @override
+  Future<Task> getTask(String id) async {
+    return _invoke<Task>("GetTask", [id], (json) => Task.fromJson(json));
+  }
+
+  @override
+  Future<List<Task>> getTasks(TaskFilter? filter) async {
+    return _invoke<List<Task>>("GetTasks", _parseTaskFilter(filter),
+        (json) => (json as List).map((e) => Task.fromJson(e)).toList());
+  }
+
+  @override
+  Future<Map<String, dynamic>> getTaskStats(String id) async {
+    return _invoke<Map<String, dynamic>>(
+        "GetTaskStats", [id], (json) => json as Map<String, dynamic>);
+  }
+
+  @override
+  Future<DownloaderConfig> getConfig() async {
+    return _invoke<DownloaderConfig>(
+        "GetConfig", [], (json) => DownloaderConfig.fromJson(json));
+  }
+
+  @override
+  Future<void> putConfig(DownloaderConfig config) async {
+    await _invoke<void>("PutConfig", [config], null);
+  }
+
+  @override
+  Future<void> installExtension(InstallExtension installExtension) async {
+    await _invoke<void>("InstallExtension", [installExtension], null);
+  }
+
+  @override
+  Future<List<Extension>> getExtensions() async {
+    return _invoke<List<Extension>>("GetExtensions", [],
+        (json) => (json as List).map((e) => Extension.fromJson(e)).toList());
+  }
+
+  @override
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings) async {
+    await _invoke<void>(
+        "UpdateExtensionSettings", [identity, updateExtensionSettings], null);
+  }
+
+  @override
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension) async {
+    await _invoke<void>("SwitchExtension", [identity, switchExtension], null);
+  }
+
+  @override
+  Future<void> deleteExtension(String identity) async {
+    await _invoke<void>("DeleteExtension", [identity], null);
+  }
+
+  @override
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(
+      String identity) async {
+    return _invoke<UpdateCheckExtensionResp>("UpgradeCheckExtension",
+        [identity], (json) => UpdateCheckExtensionResp.fromJson(json));
+  }
+
+  @override
+  Future<void> upgradeExtension(String identity) async {
+    await _invoke<void>("UpgradeExtension", [identity], null);
+  }
+
+  @override
+  Future<void> close() async {
+    await _invoke<void>("Close", [], null);
+  }
+
+  @override
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options}) {
+    return _dio.request(uri, data: data, options: options);
+  }
+}

ui/flutter/lib/api/entry/libgopeed_boot_web.dart

@@ -0,0 +1,277 @@
+import 'package:dio/dio.dart';
+import 'package:flutter/foundation.dart';
+
+import '../../api/model/create_task.dart';
+import '../../api/model/create_task_batch.dart';
+import '../../api/model/downloader_config.dart';
+import '../../api/model/extension.dart';
+import '../../api/model/http_listen_result.dart';
+import '../../api/model/info.dart';
+import '../../api/model/install_extension.dart';
+import '../../api/model/request.dart';
+import '../../api/model/resolve_result.dart';
+import '../../api/model/result.dart';
+import '../../api/model/switch_extension.dart';
+import '../../api/model/task.dart';
+import '../../api/model/task_filter.dart';
+import '../../api/model/update_check_extension_resp.dart';
+import '../../api/model/update_extension_settings.dart';
+import '../../util/extensions.dart';
+import '../../util/util.dart';
+import '../api_exception.dart';
+import '../libgopeed_boot.dart';
+import '../native/libgopeed_interface.dart';
+import '../native/model/start_config.dart';
+import 'libgopeed_boot_base.dart';
+
+LibgopeedBoot create() => LibgopeedBootWeb();
+
+class LibgopeedBootWeb
+    with LibgopeedBootBase
+    implements LibgopeedBoot, LibgopeedApi {
+  late Dio _dio;
+  static const String _apiPrefix = '/api/v1';
+
+  LibgopeedBootWeb();
+
+  Future<T> _fetch<T>(
+    Future<Response> Function() fetch,
+    T Function(dynamic json)? fromJsonT,
+  ) async {
+    try {
+      var resp = await fetch();
+      fromJsonT ??= (json) => null as T;
+      final result = Result<T>.fromJson(resp.data, fromJsonT);
+      return handleResult(result);
+    } on DioException catch (e) {
+      if (e.type == DioExceptionType.sendTimeout ||
+          e.type == DioExceptionType.receiveTimeout ||
+          e.type == DioExceptionType.connectionTimeout) {
+        throw ApiException(1000, 'request timeout');
+      }
+      throw ApiException(1000, e.message ?? "");
+    }
+  }
+
+  Map<String, dynamic>? _parseTaskFilter(TaskFilter? filter) {
+    if (filter == null) {
+      return null;
+    }
+
+    Map<String, dynamic> params = {};
+    if (filter.id != null) {
+      params['id'] = filter.id;
+    }
+    if (filter.status != null) {
+      params['status'] = filter.status;
+    }
+    if (filter.notStatus != null) {
+      params['notStatus'] = filter.notStatus;
+    }
+    if (params.isEmpty) {
+      return null;
+    }
+    return params;
+  }
+
+  @override
+  Future<LibgopeedApi> init(StartConfig cfg) async {
+    _dio = createDio();
+    _dio.options.baseUrl = kDebugMode ? 'http://127.0.0.1:9999' : '';
+    return this;
+  }
+
+  @override
+  Future<HttpListenResult> startHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<void> stopHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<void> restartHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<Info> info() {
+    return _fetch<Info>(
+        () => _dio.get("$_apiPrefix/info"), (data) => Info.fromJson(data));
+  }
+
+  @override
+  Future<ResolveResult> resolve(Request request) async {
+    return _fetch<ResolveResult>(
+        () => _dio.post("$_apiPrefix/resolve", data: request),
+        (data) => ResolveResult.fromJson(data));
+  }
+
+  @override
+  Future<String> createTask(CreateTask createTask) async {
+    return _fetch<String>(
+        () => _dio.post("$_apiPrefix/tasks", data: createTask),
+        (data) => data as String);
+  }
+
+  @override
+  Future<String> createTaskBatch(CreateTaskBatch createTask) async {
+    return _fetch<String>(
+        () => _dio.post("$_apiPrefix/tasks", data: createTask),
+        (data) => data as String);
+  }
+
+  @override
+  Future<void> pauseTask(String id) async {
+    await _fetch<void>(() => _dio.put("$_apiPrefix/tasks/$id/pause"), null);
+  }
+
+  @override
+  Future<void> pauseTasks(TaskFilter? filter) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/tasks/pause",
+            queryParameters: _parseTaskFilter(filter)),
+        null);
+  }
+
+  @override
+  Future<void> continueTask(String id) async {
+    await _fetch<void>(() => _dio.put("$_apiPrefix/tasks/$id/continue"), null);
+  }
+
+  @override
+  Future<void> continueTasks(TaskFilter? filter) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/tasks/continue",
+            queryParameters: _parseTaskFilter(filter)),
+        null);
+  }
+
+  @override
+  Future<void> deleteTask(String id, bool force) async {
+    await _fetch<void>(
+        () => _dio
+            .delete("$_apiPrefix/tasks/$id", queryParameters: {'force': force}),
+        null);
+  }
+
+  @override
+  Future<void> deleteTasks(TaskFilter? filter, bool force) async {
+    await _fetch<void>(
+        () => _dio.delete("$_apiPrefix/tasks",
+            queryParameters: _parseTaskFilter(filter)?.apply((it) {
+              it['force'] = force;
+            })),
+        null);
+  }
+
+  @override
+  Future<Task> getTask(String id) async {
+    return _fetch<Task>(
+        () => _dio.get("$_apiPrefix/tasks/$id"), (data) => Task.fromJson(data));
+  }
+
+  @override
+  Future<List<Task>> getTasks(TaskFilter? filter) async {
+    return _fetch<List<Task>>(
+        () => _dio.get("$_apiPrefix/tasks",
+            queryParameters: _parseTaskFilter(filter)),
+        (data) => (data as List).map((e) => Task.fromJson(e)).toList());
+  }
+
+  @override
+  Future<Map<String, dynamic>> getTaskStats(String id) async {
+    return _fetch<Map<String, dynamic>>(
+        () => _dio.get("$_apiPrefix/tasks/$id/stats"),
+        (data) => data as Map<String, dynamic>);
+  }
+
+  @override
+  Future<DownloaderConfig> getConfig() async {
+    return _fetch<DownloaderConfig>(() => _dio.get("$_apiPrefix/config"),
+        (data) => DownloaderConfig.fromJson(data));
+  }
+
+  @override
+  Future<void> putConfig(DownloaderConfig config) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/config", data: config), null);
+  }
+
+  @override
+  Future<void> installExtension(InstallExtension installExtension) async {
+    await _fetch<void>(
+        () => _dio.post("$_apiPrefix/extensions", data: installExtension),
+        null);
+  }
+
+  @override
+  Future<List<Extension>> getExtensions() async {
+    return _fetch<List<Extension>>(() => _dio.get("$_apiPrefix/extensions"),
+        (data) => (data as List).map((e) => Extension.fromJson(e)).toList());
+  }
+
+  @override
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/extensions/$identity/settings",
+            data: updateExtensionSettings),
+        null);
+  }
+
+  @override
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/extensions/$identity/switch",
+            data: switchExtension),
+        null);
+  }
+
+  @override
+  Future<void> deleteExtension(String identity) async {
+    await _fetch<void>(
+        () => _dio.delete("$_apiPrefix/extensions/$identity"), null);
+  }
+
+  @override
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(
+      String identity) async {
+    return _fetch<UpdateCheckExtensionResp>(
+        () => _dio.get("$_apiPrefix/extensions/$identity/upgrade"),
+        (data) => UpdateCheckExtensionResp.fromJson(data));
+  }
+
+  @override
+  Future<void> upgradeExtension(String identity) async {
+    await _fetch<void>(
+        () => _dio.post("$_apiPrefix/extensions/$identity/upgrade"), null);
+  }
+
+  @override
+  Future<void> close() async {
+    throw UnimplementedError();
+  }
+
+  // To avoid CORS, use a backend proxy to forward the request
+  @override
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options}) async {
+    options ??= Options();
+    options.headers ??= {};
+    options.headers!["X-Target-Uri"] = uri;
+
+    // add timestamp to avoid cache
+    return _dio.request(
+        "/api/v1/proxy?t=${DateTime.now().millisecondsSinceEpoch}",
+        data: data,
+        options: options);
+  }
+
+  String join(String path) {
+    return "${_dio.options.baseUrl}/${Util.cleanPath(path)}";
+  }
+}

ui/flutter/lib/api/libgopeed_boot.dart

@@ -0,0 +1,18 @@
+import "libgopeed_boot_stub.dart"
+    if (dart.library.html) 'entry/libgopeed_boot_browser.dart'
+    if (dart.library.io) 'entry/libgopeed_boot_native.dart';
+import 'native/libgopeed_interface.dart';
+
+abstract class LibgopeedBoot implements LibgopeedApiSingleton {
+  static LibgopeedApi? _instance;
+
+  static void singleton(LibgopeedApi instance) {
+    _instance ??= instance;
+  }
+
+  static LibgopeedApi get instance {
+    return _instance!;
+  }
+
+  factory LibgopeedBoot() => create();
+}

ui/flutter/lib/api/model/create_task_batch.dart

@@ -0,0 +1,20 @@
+import 'package:gopeed/api/model/extension.dart';
+import 'package:gopeed/api/model/request.dart';
+import 'package:json_annotation/json_annotation.dart';
+
+part 'create_task_batch.g.dart';
+
+@JsonSerializable()
+class CreateTaskBatch {
+  List<Request> reqs;
+  Option? opt;
+
+  CreateTaskBatch({
+    this.reqs = const [],
+    this.opt,
+  });
+
+  factory CreateTaskBatch.fromJson(Map<String, dynamic> json) =>
+      _$CreateTaskBatchFromJson(json);
+  Map<String, dynamic> toJson() => _$CreateTaskBatchToJson(this);
+}

ui/flutter/lib/api/model/create_task_batch.g.dart

@@ -0,0 +1,33 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'create_task_batch.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+CreateTaskBatch _$CreateTaskBatchFromJson(Map<String, dynamic> json) =>
+    CreateTaskBatch(
+      reqs: (json['reqs'] as List<dynamic>?)
+              ?.map((e) => Request.fromJson(e as Map<String, dynamic>))
+              .toList() ??
+          const [],
+      opt: json['opt'] == null
+          ? null
+          : Option.fromJson(json['opt'] as Map<String, dynamic>),
+    );
+
+Map<String, dynamic> _$CreateTaskBatchToJson(CreateTaskBatch instance) {
+  final val = <String, dynamic>{
+    'reqs': instance.reqs,
+  };
+
+  void writeNotNull(String key, dynamic value) {
+    if (value != null) {
+      val[key] = value;
+    }
+  }
+
+  writeNotNull('opt', instance.opt);
+  return val;
+}

ui/flutter/lib/api/model/http_listen_result.dart

@@ -0,0 +1,18 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'http_listen_result.g.dart';
+
+@JsonSerializable()
+class HttpListenResult {
+  String host;
+  int port;
+
+  HttpListenResult({
+    this.host = '',
+    this.port = 0,
+  });
+
+  factory HttpListenResult.fromJson(Map<String, dynamic> json) =>
+      _$HttpListenResultFromJson(json);
+  Map<String, dynamic> toJson() => _$HttpListenResultToJson(this);
+}

ui/flutter/lib/api/model/http_listen_result.g.dart

@@ -0,0 +1,19 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'http_listen_result.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+HttpListenResult _$HttpListenResultFromJson(Map<String, dynamic> json) =>
+    HttpListenResult(
+      host: json['host'] as String? ?? '',
+      port: (json['port'] as num?)?.toInt() ?? 0,
+    );
+
+Map<String, dynamic> _$HttpListenResultToJson(HttpListenResult instance) =>
+    <String, dynamic>{
+      'host': instance.host,
+      'port': instance.port,
+    };

ui/flutter/lib/api/model/info.dart

@@ -0,0 +1,23 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'info.g.dart';
+
+@JsonSerializable()
+class Info {
+  String version;
+  String runtime;
+  String os;
+  String arch;
+  bool inDocker;
+
+  Info({
+    this.version = '',
+    this.runtime = '',
+    this.os = '',
+    this.arch = '',
+    this.inDocker = false,
+  });
+
+  factory Info.fromJson(Map<String, dynamic> json) => _$InfoFromJson(json);
+  Map<String, dynamic> toJson() => _$InfoToJson(this);
+}

ui/flutter/lib/api/model/info.g.dart

@@ -0,0 +1,23 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'info.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+Info _$InfoFromJson(Map<String, dynamic> json) => Info(
+      version: json['version'] as String? ?? '',
+      runtime: json['runtime'] as String? ?? '',
+      os: json['os'] as String? ?? '',
+      arch: json['arch'] as String? ?? '',
+      inDocker: json['inDocker'] as bool? ?? false,
+    );
+
+Map<String, dynamic> _$InfoToJson(Info instance) => <String, dynamic>{
+      'version': instance.version,
+      'runtime': instance.runtime,
+      'os': instance.os,
+      'arch': instance.arch,
+      'inDocker': instance.inDocker,
+    };

ui/flutter/lib/api/model/options.g.dart

@@ -10,7 +10,7 @@ Options _$OptionsFromJson(Map<String, dynamic> json) => Options(
       name: json['name'] as String,
       path: json['path'] as String,
       selectFiles: (json['selectFiles'] as List<dynamic>?)
-              ?.map((e) => e as int)
+              ?.map((e) => (e as num).toInt())
               .toList() ??
           const [],
       extra: json['extra'],
@@ -35,7 +35,7 @@ Map<String, dynamic> _$OptionsToJson(Options instance) {
 
 OptsExtraHttp _$OptsExtraHttpFromJson(Map<String, dynamic> json) =>
     OptsExtraHttp()
-      ..connections = json['connections'] as int
+      ..connections = (json['connections'] as num).toInt()
       ..autoTorrent = json['autoTorrent'] as bool;
 
 Map<String, dynamic> _$OptsExtraHttpToJson(OptsExtraHttp instance) =>

ui/flutter/lib/api/model/result.g.dart

@@ -11,7 +11,7 @@ Result<T> _$ResultFromJson<T>(
   T Function(Object? json) fromJsonT,
 ) =>
     Result<T>(
-      code: json['code'] as int,
+      code: (json['code'] as num).toInt(),
       msg: json['msg'] as String?,
       data: _$nullableGenericFromJson(json['data'], fromJsonT),
     );

ui/flutter/lib/api/model/task_filter.dart

@@ -0,0 +1,17 @@
+import 'package:gopeed/api/model/task.dart';
+import 'package:json_annotation/json_annotation.dart';
+
+part 'task_filter.g.dart';
+
+@JsonSerializable()
+class TaskFilter {
+  List<String>? id;
+  List<Status>? status;
+  List<Status>? notStatus;
+
+  TaskFilter({this.id, this.status, this.notStatus});
+
+  factory TaskFilter.fromJson(Map<String, dynamic> json) =>
+      _$TaskFilterFromJson(json);
+  Map<String, dynamic> toJson() => _$TaskFilterToJson(this);
+}

ui/flutter/lib/api/model/task_filter.g.dart

@@ -0,0 +1,43 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'task_filter.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+TaskFilter _$TaskFilterFromJson(Map<String, dynamic> json) => TaskFilter(
+      id: (json['ids'] as List<dynamic>?)?.map((e) => e as String).toList(),
+      status: (json['statuses'] as List<dynamic>?)
+          ?.map((e) => $enumDecode(_$StatusEnumMap, e))
+          .toList(),
+      notStatus: (json['notStatuses'] as List<dynamic>?)
+          ?.map((e) => $enumDecode(_$StatusEnumMap, e))
+          .toList(),
+    );
+
+Map<String, dynamic> _$TaskFilterToJson(TaskFilter instance) {
+  final val = <String, dynamic>{};
+
+  void writeNotNull(String key, dynamic value) {
+    if (value != null) {
+      val[key] = value;
+    }
+  }
+
+  writeNotNull('ids', instance.id);
+  writeNotNull(
+      'statuses', instance.status?.map((e) => _$StatusEnumMap[e]!).toList());
+  writeNotNull('notStatuses',
+      instance.notStatus?.map((e) => _$StatusEnumMap[e]!).toList());
+  return val;
+}
+
+const _$StatusEnumMap = {
+  Status.ready: 'ready',
+  Status.running: 'running',
+  Status.pause: 'pause',
+  Status.wait: 'wait',
+  Status.error: 'error',
+  Status.done: 'done',
+};

ui/flutter/lib/api/native/channel/libgopeed_channel.dart

@@ -0,0 +1,22 @@
+import 'package:flutter/services.dart';
+
+import '../libgopeed_interface.dart';
+
+class LibgopeedChannel implements LibgopeedAbi {
+  static const _channel = MethodChannel('gopeed.com/libgopeed');
+
+  @override
+  Future<void> init(String cfg) async {
+    await _channel.invokeMethod<String>('init', {
+      'cfg': cfg,
+    });
+  }
+
+  @override
+  Future<String> invoke(String params) async {
+    final result = await _channel.invokeMethod<String>('invoke', {
+      'params': params,
+    });
+    return result!;
+  }
+}

ui/flutter/lib/api/native/ffi/libgopeed_bind.dart

@@ -857,27 +857,33 @@ class LibgopeedBind {
   late final __FCmulcr =
       __FCmulcrPtr.asFunction<_Fcomplex Function(_Fcomplex, double)>();
 
-  Start_return Start(
+  ffi.Pointer<ffi.Char> Init(
     ffi.Pointer<ffi.Char> cfg,
   ) {
-    return _Start(
+    return _Init(
       cfg,
     );
   }
 
-  late final _StartPtr =
-      _lookup<ffi.NativeFunction<Start_return Function(ffi.Pointer<ffi.Char>)>>(
-          'Start');
-  late final _Start =
-      _StartPtr.asFunction<Start_return Function(ffi.Pointer<ffi.Char>)>();
+  late final _InitPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>>('Init');
+  late final _Init = _InitPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
 
-  void Stop() {
-    return _Stop();
+  ffi.Pointer<ffi.Char> Invoke(
+    ffi.Pointer<ffi.Char> req,
+  ) {
+    return _Invoke(
+      req,
+    );
   }
 
-  late final _StopPtr =
-      _lookup<ffi.NativeFunction<ffi.Void Function()>>('Stop');
-  late final _Stop = _StopPtr.asFunction<void Function()>();
+  late final _InvokePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>>('Invoke');
+  late final _Invoke = _InvokePtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
 }
 
 typedef va_list = ffi.Pointer<ffi.Char>;
@@ -914,6 +920,7 @@ final class _Mbstatet extends ffi.Struct {
 }
 
 typedef errno_t = ffi.Int;
+typedef Darterrno_t = int;
 
 final class _GoString_ extends ffi.Struct {
   external ffi.Pointer<ffi.Char> p;
@@ -923,6 +930,7 @@ final class _GoString_ extends ffi.Struct {
 }
 
 typedef ptrdiff_t = ffi.LongLong;
+typedef Dartptrdiff_t = int;
 
 final class _C_double_complex extends ffi.Struct {
   @ffi.Array.multi([2])
@@ -957,13 +965,7 @@ final class GoSlice extends ffi.Struct {
 
 typedef GoInt = GoInt64;
 typedef GoInt64 = ffi.LongLong;
-
-final class Start_return extends ffi.Struct {
-  @GoInt()
-  external int r0;
-
-  external ffi.Pointer<ffi.Char> r1;
-}
+typedef DartGoInt64 = int;
 
 const int _VCRT_COMPILER_PREPROCESSOR = 1;
 
@@ -993,6 +995,10 @@ const int _HAS_CXX23 = 0;
 
 const int _HAS_NODISCARD = 1;
 
+const int _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE = 1;
+
+const int _CRT_BUILD_DESKTOP_APP = 1;
+
 const int _UCRT_DISABLED_WARNINGS = 4324;
 
 const int _ARGMAX = 100;
@@ -1009,9 +1015,7 @@ const int _CRT_FUNCTIONS_REQUIRED = 1;
 
 const int _CRT_HAS_CXX17 = 0;
 
-const int _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE = 1;
-
-const int _CRT_BUILD_DESKTOP_APP = 1;
+const int _CRT_HAS_C11 = 0;
 
 const int _CRT_INTERNAL_NONSTDC_NAMES = 1;
 

ui/flutter/lib/api/native/ffi/libgopeed_ffi.dart

@@ -0,0 +1,41 @@
+import 'dart:async';
+import 'dart:ffi';
+
+import 'package:ffi/ffi.dart';
+
+import '../libgopeed_interface.dart';
+import 'libgopeed_bind.dart';
+
+class LibgopeedFFi implements LibgopeedAbi {
+  late LibgopeedBind _libgopeed;
+
+  LibgopeedFFi(LibgopeedBind libgopeed) {
+    _libgopeed = libgopeed;
+  }
+
+  @override
+  Future<void> init(String cfg) {
+    final cfgPtr = cfg.toNativeUtf8();
+    try {
+      final result = _libgopeed.Init(cfgPtr.cast());
+      if (result != nullptr) {
+        throw Exception(
+            'Libgopeed init failed: ${result.cast<Utf8>().toDartString()}');
+      }
+      return Future.value();
+    } finally {
+      calloc.free(cfgPtr);
+    }
+  }
+
+  @override
+  Future<String> invoke(String params) {
+    final paramsPtr = params.toNativeUtf8();
+    try {
+      final result = _libgopeed.Invoke(paramsPtr.cast());
+      return Future.value(result.cast<Utf8>().toDartString());
+    } finally {
+      calloc.free(paramsPtr);
+    }
+  }
+}

ui/flutter/lib/api/native/libgopeed_interface.dart

@@ -0,0 +1,85 @@
+import 'package:dio/dio.dart';
+
+import '../model/create_task.dart';
+import '../model/create_task_batch.dart';
+import '../model/downloader_config.dart';
+import '../model/extension.dart';
+import '../model/http_listen_result.dart';
+import '../model/info.dart';
+import '../model/install_extension.dart';
+import '../model/request.dart';
+import '../model/resolve_result.dart';
+import '../model/switch_extension.dart';
+import '../model/task.dart';
+import '../model/task_filter.dart';
+import '../model/update_check_extension_resp.dart';
+import '../model/update_extension_settings.dart';
+import 'model/start_config.dart';
+
+abstract class LibgopeedAbi {
+  Future<void> init(String cfg);
+  Future<String> invoke(String params);
+}
+
+abstract class LibgopeedApiSingleton {
+  Future<LibgopeedApi> init(StartConfig config);
+}
+
+abstract class LibgopeedApi {
+  Future<HttpListenResult> startHttp();
+
+  Future<void> stopHttp();
+
+  Future<void> restartHttp();
+
+  Future<Info> info();
+
+  Future<ResolveResult> resolve(Request request);
+
+  Future<String> createTask(CreateTask createTask);
+
+  Future<String> createTaskBatch(CreateTaskBatch createTask);
+
+  Future<void> pauseTask(String id);
+
+  Future<void> pauseTasks(TaskFilter? filter);
+
+  Future<void> continueTask(String id);
+
+  Future<void> continueTasks(TaskFilter? filter);
+
+  Future<void> deleteTask(String id, bool force);
+
+  Future<void> deleteTasks(TaskFilter? filter, bool force);
+
+  Future<Task> getTask(String id);
+
+  Future<List<Task>> getTasks(TaskFilter? filter);
+
+  Future<Map<String, dynamic>> getTaskStats(String id);
+
+  Future<DownloaderConfig> getConfig();
+
+  Future<void> putConfig(DownloaderConfig config);
+
+  Future<void> installExtension(InstallExtension installExtension);
+
+  Future<List<Extension>> getExtensions();
+
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings);
+
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension);
+
+  Future<void> deleteExtension(String identity);
+
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(String identity);
+
+  Future<void> upgradeExtension(String identity);
+
+  Future<void> close();
+
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options});
+}

ui/flutter/lib/api/native/model/invoke_request.dart

@@ -0,0 +1,19 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'invoke_request.g.dart';
+
+@JsonSerializable()
+class InvokeRequest {
+  String method;
+  List<dynamic> params;
+
+  InvokeRequest({
+    this.method = '',
+    this.params = const [],
+  });
+
+  factory InvokeRequest.fromJson(Map<String, dynamic> json) =>
+      _$InvokeRequestFromJson(json);
+
+  Map<String, dynamic> toJson() => _$InvokeRequestToJson(this);
+}

ui/flutter/lib/api/native/model/invoke_request.g.dart

@@ -0,0 +1,22 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'invoke_request.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+InvokeRequest _$InvokeRequestFromJson(Map<String, dynamic> json) =>
+    InvokeRequest(
+      method: json['method'] as String? ?? '',
+      params: (json['params'] as List<dynamic>?)
+              ?.map((e) => e as String)
+              .toList() ??
+          const [],
+    );
+
+Map<String, dynamic> _$InvokeRequestToJson(InvokeRequest instance) =>
+    <String, dynamic>{
+      'method': instance.method,
+      'params': instance.params,
+    };

ui/flutter/lib/api/native/model/start_config.dart

@@ -4,14 +4,13 @@ part 'start_config.g.dart';
 
 @JsonSerializable()
 class StartConfig {
-  late String network;
-  late String address;
-  late String storage;
-  late String storageDir;
-  late int refreshInterval;
-  late String apiToken;
+  String storage;
+  String storageDir;
 
-  StartConfig();
+  StartConfig({
+    this.storage = '',
+    this.storageDir = '',
+  });
 
   factory StartConfig.fromJson(Map<String, dynamic> json) =>
       _$StartConfigFromJson(json);

ui/flutter/lib/api/native/model/start_config.g.dart

@@ -6,20 +6,13 @@ part of 'start_config.dart';
 // JsonSerializableGenerator
 // **************************************************************************
 
-StartConfig _$StartConfigFromJson(Map<String, dynamic> json) => StartConfig()
-  ..network = json['network'] as String
-  ..address = json['address'] as String
-  ..storage = json['storage'] as String
-  ..storageDir = json['storageDir'] as String
-  ..refreshInterval = json['refreshInterval'] as int
-  ..apiToken = json['apiToken'] as String;
+StartConfig _$StartConfigFromJson(Map<String, dynamic> json) => StartConfig(
+      storage: json['storage'] as String? ?? '',
+      storageDir: json['storageDir'] as String? ?? '',
+    );
 
 Map<String, dynamic> _$StartConfigToJson(StartConfig instance) =>
     <String, dynamic>{
-      'network': instance.network,
-      'address': instance.address,
       'storage': instance.storage,
       'storageDir': instance.storageDir,
-      'refreshInterval': instance.refreshInterval,
-      'apiToken': instance.apiToken,
     };

ui/flutter/lib/app/modules/app/controllers/app_controller.dart

@@ -14,10 +14,8 @@ import 'package:uri_to_file/uri_to_file.dart';
 import 'package:url_launcher/url_launcher.dart';
 import 'package:window_manager/window_manager.dart';
 
-import '../../../../api/api.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/downloader_config.dart';
-import '../../../../core/common/start_config.dart';
-import '../../../../core/libgopeed_boot.dart';
 import '../../../../database/database.dart';
 import '../../../../database/entity.dart';
 import '../../../../i18n/message.dart';
@@ -74,12 +72,9 @@ final allTrackerSubscribeUrlCdns = Map.fromIterable(allTrackerSubscribeUrls,
     });
 
 class AppController extends GetxController with WindowListener, TrayListener {
-  static StartConfig? _defaultStartConfig;
-
   final autoStartup = false.obs;
-  final startConfig = StartConfig().obs;
-  final runningPort = 0.obs;
   final downloaderConfig = DownloaderConfig().obs;
+  final httpRunningPort = 0.obs;
 
   late AppLinks _appLinks;
   StreamSubscription<Uri>? _linkSubscription;
@@ -111,7 +106,7 @@ class AppController extends GetxController with WindowListener, TrayListener {
   void onClose() {
     _linkSubscription?.cancel();
     trayManager.removeListener(this);
-    LibgopeedBoot.instance.stop();
+    LibgopeedBoot.instance.close();
   }
 
   @override
@@ -218,11 +213,12 @@ class AppController extends GetxController with WindowListener, TrayListener {
       ),
       MenuItem(
         label: "startAll".tr,
-        onClick: (menuItem) async => {continueAllTasks(null)},
+        onClick: (menuItem) async =>
+            {LibgopeedBoot.instance.continueTasks(null)},
       ),
       MenuItem(
         label: "pauseAll".tr,
-        onClick: (menuItem) async => {pauseAllTasks(null)},
+        onClick: (menuItem) async => {LibgopeedBoot.instance.pauseTasks(null)},
       ),
       MenuItem(
         label: 'setting'.tr,
@@ -247,7 +243,7 @@ class AppController extends GetxController with WindowListener, TrayListener {
         label: 'exit'.tr,
         onClick: (menuItem) async {
           try {
-            await LibgopeedBoot.instance.stop();
+            await LibgopeedBoot.instance.close();
           } catch (e) {
             logger.w("libgopeed stop fail", e);
           }
@@ -313,43 +309,9 @@ class AppController extends GetxController with WindowListener, TrayListener {
     await Get.rootDelegate.offAndToNamed(Routes.CREATE, arguments: path);
   }
 
-  String runningAddress() {
-    if (startConfig.value.network == 'unix') {
-      return startConfig.value.address;
-    }
-    return '${startConfig.value.address.split(':').first}:$runningPort';
-  }
-
-  Future<StartConfig> _initDefaultStartConfig() async {
-    if (_defaultStartConfig != null) {
-      return _defaultStartConfig!;
-    }
-    _defaultStartConfig = StartConfig();
-    if (!Util.supportUnixSocket()) {
-      // not support unix socket, use tcp
-      _defaultStartConfig!.network = "tcp";
-      _defaultStartConfig!.address = "127.0.0.1:0";
-    } else {
-      _defaultStartConfig!.network = "unix";
-      _defaultStartConfig!.address =
-          "${(await getTemporaryDirectory()).path}/$unixSocketPath";
-    }
-    _defaultStartConfig!.apiToken = '';
-    return _defaultStartConfig!;
-  }
-
-  Future<StartConfig> loadStartConfig() async {
-    final defaultCfg = await _initDefaultStartConfig();
-    final saveCfg = Database.instance.getStartConfig();
-    startConfig.value.network = saveCfg?.network ?? defaultCfg.network;
-    startConfig.value.address = saveCfg?.address ?? defaultCfg.address;
-    startConfig.value.apiToken = saveCfg?.apiToken ?? defaultCfg.apiToken;
-    return startConfig.value;
-  }
-
   Future<DownloaderConfig> loadDownloaderConfig() async {
     try {
-      downloaderConfig.value = await getConfig();
+      downloaderConfig.value = await LibgopeedBoot.instance.getConfig();
     } catch (e) {
       logger.w("load downloader config fail", e, StackTrace.current);
       downloaderConfig.value = DownloaderConfig();
@@ -382,7 +344,7 @@ class AppController extends GetxController with WindowListener, TrayListener {
     });
     refreshTrackers();
 
-    await saveConfig();
+    await LibgopeedBoot.instance.putConfig(downloaderConfig.value);
   }
 
   refreshTrackers() {
@@ -411,7 +373,7 @@ class AppController extends GetxController with WindowListener, TrayListener {
   }
 
   Future<List<String>> _fetchTrackers(String subscribeUrl) async {
-    final resp = await proxyRequest(subscribeUrl);
+    final resp = await LibgopeedBoot.instance.proxyRequest(subscribeUrl);
     if (resp.statusCode != 200) {
       throw Exception(
           'Failed to get trackers, status code: ${resp.statusCode}');
@@ -468,12 +430,4 @@ class AppController extends GetxController with WindowListener, TrayListener {
         args: ['--${Args.flagHidden}']);
     autoStartup.value = await launchAtStartup.isEnabled();
   }
-
-  Future<void> saveConfig() async {
-    Database.instance.saveStartConfig(StartConfigEntity(
-        network: startConfig.value.network,
-        address: startConfig.value.address,
-        apiToken: startConfig.value.apiToken));
-    await putConfig(downloaderConfig.value);
-  }
 }

ui/flutter/lib/app/modules/create/views/create_view.dart

@@ -1,5 +1,4 @@
 import 'package:autoscale_tabbarview/autoscale_tabbarview.dart';
-import 'package:checkable_treeview/checkable_treeview.dart';
 import 'package:desktop_drop/desktop_drop.dart';
 import 'package:file_picker/file_picker.dart';
 import 'package:flutter/material.dart';
@@ -8,7 +7,7 @@ import 'package:get/get.dart';
 import 'package:path/path.dart' as path;
 import 'package:rounded_loading_button_plus/rounded_loading_button.dart';
 
-import '../../../../api/api.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/create_task.dart';
 import '../../../../api/model/options.dart';
 import '../../../../api/model/request.dart';
@@ -17,11 +16,10 @@ import '../../../../database/database.dart';
 import '../../../../util/input_formatter.dart';
 import '../../../../util/message.dart';
 import '../../../../util/util.dart';
-import '../../../../util/extensions.dart';
 import '../../../routes/app_pages.dart';
 import '../../../views/compact_checkbox.dart';
 import '../../../views/directory_selector.dart';
-import '../../../views/file_tree_view.dart';
+import '../../../views/file_list_view.dart';
 import '../../app/controllers/app_controller.dart';
 import '../../history/views/history_view.dart';
 import '../controllers/create_controller.dart';
@@ -42,7 +40,6 @@ class CreateView extends GetView<CreateController> {
   final _httpCookieController = TextEditingController();
   final _httpRefererController = TextEditingController();
   final _btTrackerController = TextEditingController();
-  final _fileTreeViewKey = GlobalKey<TreeViewState<int>>();
 
   final _availableSchemes = ["http:", "https:", "magnet:"];
 
@@ -597,7 +594,7 @@ class CreateView extends GetView<CreateController> {
         final isDirect = controller.directDownload.value || isMultiLine;
         if (isDirect) {
           await Future.wait(urls.map((url) {
-            return createTask(CreateTask(
+            return LibgopeedBoot.instance.createTask(CreateTask(
                 req: Request(
                   url: url,
                   extra: parseReqExtra(url),
@@ -613,7 +610,7 @@ class CreateView extends GetView<CreateController> {
           }));
           Get.rootDelegate.offNamed(Routes.TASK);
         } else {
-          final rr = await resolve(Request(
+          final rr = await LibgopeedBoot.instance.resolve(Request(
             url: submitUrl,
             extra: parseReqExtra(_urlController.text),
             proxy: parseProxy(),
@@ -701,13 +698,7 @@ class CreateView extends GetView<CreateController> {
                     child: Form(
                         key: createFormKey,
                         autovalidateMode: AutovalidateMode.always,
-                        child: FileTreeView(
-                          files: rr.res.files,
-                          initialValues: rr.res.files.asMap().keys.toList(),
-                          onSelectionChanged: (List<int> values) {
-                            controller.selectedIndexes.value = values;
-                          },
-                        )),
+                        child: FileListView(files: rr.res.files)),
                   );
                 },
               ),
@@ -750,23 +741,28 @@ class CreateView extends GetView<CreateController> {
                               await Future.wait(
                                   controller.selectedIndexes.map((index) {
                                 final file = rr.res.files[index];
-                                return createTask(CreateTask(
-                                    req: file.req!..proxy = parseProxy(),
-                                    opt: Options(
-                                        name: file.name,
-                                        path: path.join(_pathController.text,
-                                            rr.res.name, file.path),
-                                        selectFiles: [],
-                                        extra: optExtra)));
+                                return LibgopeedBoot.instance.createTask(
+                                    CreateTask(
+                                        req: file.req!..proxy = parseProxy(),
+                                        opt: Options(
+                                            name: file.name,
+                                            path: path.join(
+                                                _pathController.text,
+                                                rr.res.name,
+                                                file.path),
+                                            selectFiles: [],
+                                            extra: optExtra)));
                               }));
                             } else {
-                              await createTask(CreateTask(
-                                  rid: rr.id,
-                                  opt: Options(
-                                      name: _renameController.text,
-                                      path: _pathController.text,
-                                      selectFiles: controller.selectedIndexes,
-                                      extra: optExtra)));
+                              await LibgopeedBoot.instance.createTask(
+                                  CreateTask(
+                                      rid: rr.id,
+                                      opt: Options(
+                                          name: _renameController.text,
+                                          path: _pathController.text,
+                                          selectFiles:
+                                              controller.selectedIndexes,
+                                          extra: optExtra)));
                             }
                             Get.back();
                             Get.rootDelegate.offNamed(Routes.TASK);

ui/flutter/lib/app/modules/extension/controllers/extension_controller.dart

@@ -1,6 +1,6 @@
 import 'package:get/get.dart';
-import 'package:gopeed/api/api.dart';
 
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/extension.dart';
 
 class ExtensionController extends GetxController {
@@ -17,12 +17,13 @@ class ExtensionController extends GetxController {
   }
 
   Future<void> load() async {
-    extensions.value = await getExtensions();
+    extensions.value = await LibgopeedBoot.instance.getExtensions();
   }
 
   Future<void> checkUpdate() async {
     for (final ext in extensions) {
-      final resp = await upgradeCheckExtension(ext.identity);
+      final resp =
+          await LibgopeedBoot.instance.upgradeCheckExtension(ext.identity);
       if (resp.newVersion.isNotEmpty) {
         updateFlags[ext.identity] = resp.newVersion;
       }

ui/flutter/lib/app/modules/extension/views/extension_view.dart

@@ -11,7 +11,8 @@ import 'package:path/path.dart' as path;
 import 'package:rounded_loading_button_plus/rounded_loading_button.dart';
 import 'package:url_launcher/url_launcher.dart';
 
-import '../../../../api/api.dart';
+import '../../../../api/entry/libgopeed_boot_web.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/extension.dart';
 import '../../../../api/model/install_extension.dart';
 import '../../../../api/model/switch_extension.dart';
@@ -78,8 +79,9 @@ class ExtensionView extends GetView<ExtensionController> {
                         }
                         _installBtnController.start();
                         try {
-                          await installExtension(InstallExtension(
-                              url: _installUrlController.text));
+                          await LibgopeedBoot.instance.installExtension(
+                              InstallExtension(
+                                  url: _installUrlController.text));
                           Get.snackbar('tip'.tr, 'extensionInstallSuccess'.tr);
                           await controller.load();
                         } catch (e) {
@@ -98,7 +100,7 @@ class ExtensionView extends GetView<ExtensionController> {
                             if (dir != null) {
                               MacSecureUtil.saveBookmark(dir);
                               try {
-                                await installExtension(
+                                await LibgopeedBoot.instance.installExtension(
                                     InstallExtension(devMode: true, url: dir));
                                 Get.snackbar(
                                     'tip'.tr, 'extensionInstallSuccess'.tr);
@@ -133,8 +135,10 @@ class ExtensionView extends GetView<ExtensionController> {
                                         )
                                       : Util.isWeb()
                                           ? Image.network(
-                                              join(
-                                                  '/fs/extensions/${extension.identity}/${extension.icon}'),
+                                              (LibgopeedBoot.instance
+                                                      as LibgopeedBootWeb)
+                                                  .join(
+                                                      '/fs/extensions/${extension.identity}/${extension.icon}'),
                                               width: 48,
                                               height: 48,
                                             )
@@ -155,9 +159,9 @@ class ExtensionView extends GetView<ExtensionController> {
                                     value: !extension.disabled,
                                     onChanged: (value) async {
                                       try {
-                                        await switchExtension(
-                                            extension.identity,
-                                            SwitchExtension(status: value));
+                                        await LibgopeedBoot.instance
+                                            .switchExtension(extension.identity,
+                                                SwitchExtension(status: value));
                                         await controller.load();
                                       } catch (e) {
                                         showErrorMessage(e);
@@ -354,10 +358,11 @@ class ExtensionView extends GetView<ExtensionController> {
                         try {
                           confrimController.start();
                           if (formKey.currentState?.saveAndValidate() == true) {
-                            await updateExtensionSettings(
-                                extension.identity,
-                                UpdateExtensionSettings(
-                                    settings: formKey.currentState!.value));
+                            await LibgopeedBoot.instance
+                                .updateExtensionSettings(
+                                    extension.identity,
+                                    UpdateExtensionSettings(
+                                        settings: formKey.currentState!.value));
                             await controller.load();
                             Get.back();
                           }
@@ -454,7 +459,8 @@ class ExtensionView extends GetView<ExtensionController> {
                   ),
                   onPressed: () async {
                     try {
-                      await deleteExtension(extension.identity);
+                      await LibgopeedBoot.instance
+                          .deleteExtension(extension.identity);
                       await controller.load();
                       Get.back();
                     } catch (e) {
@@ -487,18 +493,19 @@ class ExtensionView extends GetView<ExtensionController> {
                   onPressed: () async {
                     confrimController.start();
                     try {
-                      await updateExtension(extension.identity);
+                      await LibgopeedBoot.instance
+                          .upgradeExtension(extension.identity);
                       await controller.load();
                       controller.updateFlags.remove(extension.identity);
                       Get.back();
-                      showMessage('tip'.tr, 'extensionUpdateSuccess'.tr);
+                      showMessage('tip'.tr, 'extensionUpgradeSuccess'.tr);
                     } catch (e) {
                       showErrorMessage(e);
                     } finally {
                       confrimController.stop();
                     }
                   },
-                  child: Text('newVersionUpdate'.tr),
+                  child: Text('newVersionUpgrade'.tr),
                 ),
               ],
             ));

ui/flutter/lib/app/modules/setting/controllers/setting_controller.dart

@@ -1,7 +1,8 @@
 import 'dart:convert';
 
 import 'package:get/get.dart';
-import 'package:gopeed/api/api.dart';
+
+import '../../../../api/libgopeed_boot.dart';
 
 class SettingController extends GetxController {
   final tapStatues = <String, bool>{}.obs;
@@ -28,12 +29,13 @@ class SettingController extends GetxController {
   void fetchLatestVersion() async {
     String? releaseDataStr;
     try {
-      releaseDataStr = (await proxyRequest(
+      releaseDataStr = (await LibgopeedBoot.instance.proxyRequest(
               "https://api.github.com/repos/GopeedLab/gopeed/releases/latest"))
           .data;
     } catch (e) {
-      releaseDataStr =
-          (await proxyRequest("https://gopeed.com/api/release")).data;
+      releaseDataStr = (await LibgopeedBoot.instance
+              .proxyRequest("https://gopeed.com/api/release"))
+          .data;
     }
     if (releaseDataStr == null) {
       return;

ui/flutter/lib/app/modules/setting/views/setting_view.dart

@@ -10,6 +10,7 @@ import 'package:intl/intl.dart';
 import 'package:launch_at_startup/launch_at_startup.dart';
 import 'package:url_launcher/url_launcher.dart';
 
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/downloader_config.dart';
 import '../../../../i18n/message.dart';
 import '../../../../util/input_formatter.dart';
@@ -35,7 +36,6 @@ class SettingView extends GetView<SettingController> {
   Widget build(BuildContext context) {
     final appController = Get.find<AppController>();
     final downloaderCfg = appController.downloaderConfig;
-    final startCfg = appController.startConfig;
 
     Timer? timer;
     Future<bool> debounceSave(
@@ -51,8 +51,8 @@ class SettingView extends GetView<SettingController> {
             return;
           }
         }
-        appController
-            .saveConfig()
+        LibgopeedBoot.instance
+            .putConfig(downloaderCfg.value)
             .then((_) => completer.complete(true))
             .onError(completer.completeError);
         if (needRestart) {
@@ -530,7 +530,7 @@ class SettingView extends GetView<SettingController> {
                             launchUrl(Uri.parse('https://gopeed.com'),
                                 mode: LaunchMode.externalApplication);
                           },
-                          child: Text('newVersionUpdate'.tr),
+                          child: Text('newVersionUpgrade'.tr),
                         ),
                       ],
                     ));
@@ -637,7 +637,7 @@ class SettingView extends GetView<SettingController> {
         final portController = TextEditingController(text: port);
         updateAddress() async {
           final newAddress = '${ipController.text}:${portController.text}';
-          if (newAddress != startCfg.value.address) {
+          if (newAddress != proxy.host) {
             proxy.host = newAddress;
 
             await debounceSave();
@@ -718,152 +718,152 @@ class SettingView extends GetView<SettingController> {
     );
 
     // advanced config API items start
-    final buildApiProtocol = _buildConfigItem(
-      'protocol',
-      () => startCfg.value.network == 'tcp'
-          ? 'TCP ${startCfg.value.address}'
-          : 'Unix',
-      (Key key) {
-        final items = <Widget>[
-          SizedBox(
-            width: 80,
-            child: DropdownButtonFormField<String>(
-              value: startCfg.value.network,
-              onChanged: Util.isDesktop()
-                  ? (value) async {
-                      startCfg.update((val) {
-                        val!.network = value!;
-                      });
+    // final buildApiProtocol = _buildConfigItem(
+    //   'protocol',
+    //   () => startCfg.value.host == 'tcp'
+    //       ? 'TCP ${startCfg.value.address}'
+    //       : 'Unix',
+    //   (Key key) {
+    //     final items = <Widget>[
+    //       SizedBox(
+    //         width: 80,
+    //         child: DropdownButtonFormField<String>(
+    //           value: startCfg.value.host,
+    //           onChanged: Util.isDesktop()
+    //               ? (value) async {
+    //                   startCfg.update((val) {
+    //                     val!.host = value!;
+    //                   });
 
-                      await debounceSave(needRestart: true);
-                    }
-                  : null,
-              items: [
-                const DropdownMenuItem<String>(
-                  value: 'tcp',
-                  child: Text('TCP'),
-                ),
-                Util.supportUnixSocket()
-                    ? const DropdownMenuItem<String>(
-                        value: 'unix',
-                        child: Text('Unix'),
-                      )
-                    : null,
-              ].where((e) => e != null).map((e) => e!).toList(),
-            ),
-          )
-        ];
-        if (Util.isDesktop() && startCfg.value.network == 'tcp') {
-          final arr = startCfg.value.address.split(':');
-          var ip = '127.0.0.1';
-          var port = '0';
-          if (arr.length > 1) {
-            ip = arr[0];
-            port = arr[1];
-          }
+    //                   await debounceSave(needRestart: true);
+    //                 }
+    //               : null,
+    //           items: [
+    //             const DropdownMenuItem<String>(
+    //               value: 'tcp',
+    //               child: Text('TCP'),
+    //             ),
+    //             Util.supportUnixSocket()
+    //                 ? const DropdownMenuItem<String>(
+    //                     value: 'unix',
+    //                     child: Text('Unix'),
+    //                   )
+    //                 : null,
+    //           ].where((e) => e != null).map((e) => e!).toList(),
+    //         ),
+    //       )
+    //     ];
+    //     if (Util.isDesktop() && startCfg.value.host == 'tcp') {
+    //       final arr = startCfg.value.address.split(':');
+    //       var ip = '127.0.0.1';
+    //       var port = '0';
+    //       if (arr.length > 1) {
+    //         ip = arr[0];
+    //         port = arr[1];
+    //       }
 
-          final ipController = TextEditingController(text: ip);
-          final portController = TextEditingController(text: port);
-          updateAddress() async {
-            if (ipController.text.isEmpty || portController.text.isEmpty) {
-              return;
-            }
-            final newAddress = '${ipController.text}:${portController.text}';
-            if (newAddress != startCfg.value.address) {
-              startCfg.value.address = newAddress;
+    //       final ipController = TextEditingController(text: ip);
+    //       final portController = TextEditingController(text: port);
+    //       updateAddress() async {
+    //         if (ipController.text.isEmpty || portController.text.isEmpty) {
+    //           return;
+    //         }
+    //         final newAddress = '${ipController.text}:${portController.text}';
+    //         if (newAddress != startCfg.value.address) {
+    //           startCfg.value.address = newAddress;
 
-              final saved = await debounceSave(
-                  check: () async {
-                    // Check if address already in use
-                    final configIp = ipController.text;
-                    final configPort = int.parse(portController.text);
-                    if (configPort == 0) {
-                      return '';
-                    }
-                    try {
-                      final socket = await Socket.connect(configIp, configPort,
-                          timeout: const Duration(seconds: 3));
-                      socket.close();
-                      return 'portInUse'
-                          .trParams({'port': configPort.toString()});
-                    } catch (e) {
-                      return '';
-                    }
-                  },
-                  needRestart: true);
+    //           final saved = await debounceSave(
+    //               check: () async {
+    //                 // Check if address already in use
+    //                 final configIp = ipController.text;
+    //                 final configPort = int.parse(portController.text);
+    //                 if (configPort == 0) {
+    //                   return '';
+    //                 }
+    //                 try {
+    //                   final socket = await Socket.connect(configIp, configPort,
+    //                       timeout: const Duration(seconds: 3));
+    //                   socket.close();
+    //                   return 'portInUse'
+    //                       .trParams({'port': configPort.toString()});
+    //                 } catch (e) {
+    //                   return '';
+    //                 }
+    //               },
+    //               needRestart: true);
 
-              // If save failed, restore the old address
-              if (!saved) {
-                final oldAddress =
-                    (await appController.loadStartConfig()).address;
-                startCfg.update((val) async {
-                  val!.address = oldAddress;
-                });
-              }
-            }
-          }
+    //           // If save failed, restore the old address
+    //           if (!saved) {
+    //             // final oldAddress =
+    //             //     (await appController.loadStartConfig()).address;
+    //             // startCfg.update((val) async {
+    //             //   val!.address = oldAddress;
+    //             // });
+    //           }
+    //         }
+    //       }
 
-          ipController.addListener(updateAddress);
-          portController.addListener(updateAddress);
-          items.addAll([
-            const Padding(padding: EdgeInsets.only(left: 20)),
-            Flexible(
-              child: TextFormField(
-                controller: ipController,
-                decoration: const InputDecoration(
-                  labelText: 'IP',
-                  contentPadding: EdgeInsets.all(0.0),
-                ),
-                keyboardType: TextInputType.number,
-                inputFormatters: [
-                  FilteringTextInputFormatter.allow(RegExp('[0-9.]')),
-                ],
-              ),
-            ),
-            const Padding(padding: EdgeInsets.only(left: 10)),
-            Flexible(
-              child: TextFormField(
-                controller: portController,
-                decoration: InputDecoration(
-                  labelText: 'port'.tr,
-                  contentPadding: const EdgeInsets.all(0.0),
-                ),
-                keyboardType: TextInputType.number,
-                inputFormatters: [
-                  FilteringTextInputFormatter.digitsOnly,
-                  NumericalRangeFormatter(min: 0, max: 65535),
-                ],
-              ),
-            ),
-          ]);
-        }
+    //       ipController.addListener(updateAddress);
+    //       portController.addListener(updateAddress);
+    //       items.addAll([
+    //         const Padding(padding: EdgeInsets.only(left: 20)),
+    //         Flexible(
+    //           child: TextFormField(
+    //             controller: ipController,
+    //             decoration: const InputDecoration(
+    //               labelText: 'IP',
+    //               contentPadding: EdgeInsets.all(0.0),
+    //             ),
+    //             keyboardType: TextInputType.number,
+    //             inputFormatters: [
+    //               FilteringTextInputFormatter.allow(RegExp('[0-9.]')),
+    //             ],
+    //           ),
+    //         ),
+    //         const Padding(padding: EdgeInsets.only(left: 10)),
+    //         Flexible(
+    //           child: TextFormField(
+    //             controller: portController,
+    //             decoration: InputDecoration(
+    //               labelText: 'port'.tr,
+    //               contentPadding: const EdgeInsets.all(0.0),
+    //             ),
+    //             keyboardType: TextInputType.number,
+    //             inputFormatters: [
+    //               FilteringTextInputFormatter.digitsOnly,
+    //               NumericalRangeFormatter(min: 0, max: 65535),
+    //             ],
+    //           ),
+    //         ),
+    //       ]);
+    //     }
 
-        return Form(
-          child: Row(
-            children: items,
-          ),
-        );
-      },
-    );
-    final buildApiToken = _buildConfigItem('apiToken',
-        () => startCfg.value.apiToken.isEmpty ? 'notSet'.tr : 'set'.tr,
-        (Key key) {
-      final apiTokenController =
-          TextEditingController(text: startCfg.value.apiToken);
-      apiTokenController.addListener(() async {
-        if (apiTokenController.text != startCfg.value.apiToken) {
-          startCfg.value.apiToken = apiTokenController.text;
+    //     return Form(
+    //       child: Row(
+    //         children: items,
+    //       ),
+    //     );
+    //   },
+    // );
+    // final buildApiToken = _buildConfigItem('apiToken',
+    //     () => startCfg.value.apiToken.isEmpty ? 'notSet'.tr : 'set'.tr,
+    //     (Key key) {
+    //   final apiTokenController =
+    //       TextEditingController(text: startCfg.value.apiToken);
+    //   apiTokenController.addListener(() async {
+    //     if (apiTokenController.text != startCfg.value.apiToken) {
+    //       startCfg.value.apiToken = apiTokenController.text;
 
-          await debounceSave(needRestart: true);
-        }
-      });
-      return TextField(
-        key: key,
-        obscureText: true,
-        controller: apiTokenController,
-        focusNode: FocusNode(),
-      );
-    });
+    //       await debounceSave(needRestart: true);
+    //     }
+    //   });
+    //   return TextField(
+    //     key: key,
+    //     obscureText: true,
+    //     controller: apiTokenController,
+    //     focusNode: FocusNode(),
+    //   );
+    // });
 
     // advanced config log items start
     buildLogsDir() {
@@ -993,16 +993,16 @@ class SettingView extends GetView<SettingController> {
                           child: Column(
                         children: _addDivider([buildProxy()]),
                       )),
-                      const Text('API'),
-                      Card(
-                          child: Column(
-                        children: _addDivider([
-                          buildApiProtocol(),
-                          Util.isDesktop() && startCfg.value.network == 'tcp'
-                              ? buildApiToken()
-                              : null,
-                        ]),
-                      )),
+                      // const Text('API'),
+                      // Card(
+                      //     child: Column(
+                      //   children: _addDivider([
+                      //     buildApiProtocol(),
+                      //     Util.isDesktop() && startCfg.value.host == 'tcp'
+                      //         ? buildApiToken()
+                      //         : null,
+                      //   ]),
+                      // )),
                       Text('developer'.tr),
                       Card(
                           child: Column(

ui/flutter/lib/app/modules/task/controllers/task_controller.dart

@@ -6,4 +6,5 @@ class TaskController extends GetxController {
   final tabIndex = 0.obs;
   final scaffoldKey = GlobalKey<ScaffoldState>();
   final selectTask = Rx<Task?>(null);
+  final copyUrlDone = false.obs;
 }

ui/flutter/lib/app/modules/task/controllers/task_downloading_controller.dart

@@ -9,13 +9,5 @@ class TaskDownloadingController extends TaskListController {
           Status.pause,
           Status.wait,
           Status.error
-        ], (a, b) {
-          if (a.status == Status.running && b.status != Status.running) {
-            return -1;
-          } else if (a.status != Status.running && b.status == Status.running) {
-            return 1;
-          } else {
-            return b.updatedAt.compareTo(a.updatedAt);
-          }
-        });
+        ], (a, b) => b.createdAt.compareTo(a.createdAt));
 }

ui/flutter/lib/app/modules/task/controllers/task_files_controller.dart

@@ -1,5 +1,5 @@
 import 'package:get/get.dart';
-import '../../../../api/api.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/resource.dart';
 import '../../../../api/model/task.dart';
 
@@ -31,7 +31,7 @@ class TaskFilesController extends GetxController {
     super.onInit();
 
     final taskId = Get.rootDelegate.parameters['id'];
-    final tasks = await getTasks([]);
+    final tasks = await LibgopeedBoot.instance.getTasks(null);
     task.value = tasks.firstWhere((element) => element.id == taskId);
     parseDirMap(task.value!.meta.res!.files);
     toDir("/");

ui/flutter/lib/app/modules/task/controllers/task_list_controller.dart

@@ -2,8 +2,9 @@ import 'dart:async';
 
 import 'package:get/get.dart';
 
-import '../../../../api/api.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../api/model/task.dart';
+import '../../../../api/model/task_filter.dart';
 
 abstract class TaskListController extends GetxController {
   List<Status> statuses;
@@ -12,7 +13,6 @@ abstract class TaskListController extends GetxController {
   TaskListController(this.statuses, this.compare);
 
   final tasks = <Task>[].obs;
-  final selectedTaskIds = <String>[].obs;
   final isRunning = false.obs;
 
   late final Timer _timer;
@@ -45,7 +45,8 @@ abstract class TaskListController extends GetxController {
   }
 
   getTasksState() async {
-    final tasks = await getTasks(statuses);
+    final tasks =
+        await LibgopeedBoot.instance.getTasks(TaskFilter(status: statuses));
     // sort tasks by create time
     tasks.sort(compare);
     this.tasks.value = tasks;

ui/flutter/lib/app/modules/task/views/task_downloaded_view.dart

@@ -9,7 +9,6 @@ class TaskDownloadedView extends GetView<TaskDownloadedController> {
 
   @override
   Widget build(BuildContext context) {
-    return BuildTaskListView(
-        tasks: controller.tasks, selectedTaskIds: controller.selectedTaskIds);
+    return BuildTaskListView(tasks: controller.tasks);
   }
 }

ui/flutter/lib/app/modules/task/views/task_downloading_view.dart

@@ -9,7 +9,6 @@ class TaskDownloadingView extends GetView<TaskDownloadingController> {
 
   @override
   Widget build(BuildContext context) {
-    return BuildTaskListView(
-        tasks: controller.tasks, selectedTaskIds: controller.selectedTaskIds);
+    return BuildTaskListView(tasks: controller.tasks);
   }
 }

ui/flutter/lib/app/modules/task/views/task_files_view.dart

@@ -5,11 +5,13 @@ import 'package:path/path.dart';
 import 'package:share_plus/share_plus.dart';
 import 'package:url_launcher/url_launcher.dart';
 
-import '../../../../api/api.dart' as api;
+import '../../../../api/entry/libgopeed_boot_web.dart';
+import '../../../../api/libgopeed_boot.dart';
 import '../../../../util/browser_download/browser_download.dart';
+import '../../../../util/file_icon.dart';
+import '../../../../util/icons.dart';
 import '../../../../util/util.dart';
 import '../../../views/breadcrumb_view.dart';
-import '../../../views/file_icon.dart';
 import '../controllers/task_files_controller.dart';
 
 class TaskFilesView extends GetView<TaskFilesController> {
@@ -64,8 +66,9 @@ class TaskFilesView extends GetView<TaskFilesController> {
                         [meta.opts.path, meta.res!.name, fileRelativePath]);
                     final fileName = basename(filePath);
                     return ListTile(
-                      leading:
-                          Icon(fileIcon(fileName, isFolder: file.isDirectory)),
+                      leading: file.isDirectory
+                          ? const Icon(Icons.folder)
+                          : Icon(FaIcons.allIcons[findIcon(fileName)]),
                       title: Text(fileName),
                       subtitle: file.isDirectory
                           ? Text('items'.trParams({
@@ -82,8 +85,10 @@ class TaskFilesView extends GetView<TaskFilesController> {
                                 mainAxisAlignment: MainAxisAlignment.end,
                                 children: Util.isWeb()
                                     ? () {
-                                        final accessUrl = api.join(
-                                            "/fs/tasks/${controller.task.value!.id}$fileRelativePath");
+                                        final accessUrl = (LibgopeedBoot
+                                                .instance as LibgopeedBootWeb)
+                                            .join(
+                                                "/fs/tasks/${controller.task.value!.id}$fileRelativePath");
                                         return [
                                           IconButton(
                                               icon:

ui/flutter/lib/app/views/buid_task_list_view.dart

@@ -1,28 +1,24 @@
-import 'package:contextmenu/contextmenu.dart';
 import 'package:flutter/material.dart';
 import 'package:get/get.dart';
 import 'package:styled_widget/styled_widget.dart';
 
-import '../../api/api.dart';
+import '../../api/libgopeed_boot.dart';
 import '../../api/model/task.dart';
+import '../../util/file_icon.dart';
+import '../../util/icons.dart';
 import '../../util/message.dart';
 import '../../util/util.dart';
 import '../modules/app/controllers/app_controller.dart';
 import '../modules/task/controllers/task_controller.dart';
-import '../modules/task/controllers/task_downloaded_controller.dart';
-import '../modules/task/controllers/task_downloading_controller.dart';
 import '../modules/task/views/task_view.dart';
 import '../routes/app_pages.dart';
-import 'file_icon.dart';
 
 class BuildTaskListView extends GetView {
   final List<Task> tasks;
-  final List<String> selectedTaskIds;
 
   const BuildTaskListView({
     Key? key,
     required this.tasks,
-    required this.selectedTaskIds,
   }) : super(key: key);
 
   @override
@@ -61,15 +57,11 @@ class BuildTaskListView extends GetView {
       return task.status == Status.running;
     }
 
-    bool isSelect() {
-      return selectedTaskIds.contains(task.id);
-    }
-
     bool isFolderTask() {
       return task.isFolder;
     }
 
-    Future<void> showDeleteDialog(List<String> ids) {
+    Future<void> showDeleteDialog(String id) {
       final appController = Get.find<AppController>();
 
       final context = Get.context!;
@@ -78,8 +70,7 @@ class BuildTaskListView extends GetView {
           context: context,
           barrierDismissible: false,
           builder: (_) => AlertDialog(
-                title: Text(
-                    'deleteTask'.trParams({'count': ids.length.toString()})),
+                title: Text('deleteTask'.tr),
                 content: Obx(() => CheckboxListTile(
                     value: appController
                         .downloaderConfig.value.extra.lastDeleteTaskKeep,
@@ -104,8 +95,9 @@ class BuildTaskListView extends GetView {
                       try {
                         final force = !appController
                             .downloaderConfig.value.extra.lastDeleteTaskKeep;
-                        await appController.saveConfig();
-                        await deleteTasks(ids, force);
+                        LibgopeedBoot.instance
+                            .putConfig(appController.downloaderConfig.value);
+                        await LibgopeedBoot.instance.deleteTask(id, force);
                         Get.back();
                       } catch (e) {
                         showErrorMessage(e);
@@ -131,7 +123,7 @@ class BuildTaskListView extends GetView {
             icon: const Icon(Icons.pause),
             onPressed: () async {
               try {
-                await pauseTask(task.id);
+                await LibgopeedBoot.instance.pauseTask(task.id);
               } catch (e) {
                 showErrorMessage(e);
               }
@@ -142,7 +134,7 @@ class BuildTaskListView extends GetView {
             icon: const Icon(Icons.play_arrow),
             onPressed: () async {
               try {
-                await continueTask(task.id);
+                await LibgopeedBoot.instance.continueTask(task.id);
               } catch (e) {
                 showErrorMessage(e);
               }
@@ -153,35 +145,12 @@ class BuildTaskListView extends GetView {
       list.add(IconButton(
         icon: const Icon(Icons.delete),
         onPressed: () {
-          showDeleteDialog([task.id]);
+          showDeleteDialog(task.id);
         },
       ));
       return list;
     }
 
-    Widget buildContextItem(IconData icon, String label, Function() onTap,
-        {bool enabled = true}) {
-      return ListTile(
-        dense: true,
-        visualDensity: const VisualDensity(vertical: -1),
-        minLeadingWidth: 12,
-        leading: Icon(icon, size: 18),
-        title: Text(label,
-            style: const TextStyle(
-              fontWeight: FontWeight.bold, // Make the text bold
-            )),
-        onTap: () async {
-          Get.back();
-          try {
-            await onTap();
-          } catch (e) {
-            showErrorMessage(e);
-          }
-        },
-        enabled: enabled,
-      );
-    }
-
     double getProgress() {
       final totalSize = task.meta.res?.size ?? 0;
       return totalSize <= 0 ? 0 : task.progress.downloaded / totalSize;
@@ -200,127 +169,53 @@ class BuildTaskListView extends GetView {
     }
 
     final taskController = Get.find<TaskController>();
-    final taskListController = taskController.tabIndex.value == 0
-        ? Get.find<TaskDownloadingController>()
-        : Get.find<TaskDownloadedController>();
 
-    // Filter selected task ids that are still in the task list
-    filterSelectedTaskIds(Iterable<String> selectedTaskIds) => selectedTaskIds
-        .where((id) => tasks.any((task) => task.id == id))
-        .toList();
-
-    return ContextMenuArea(
-      width: 140,
-      builder: (context) => [
-        buildContextItem(Icons.checklist, 'selectAll'.tr, () {
-          if (tasks.isEmpty) return;
-
-          if (selectedTaskIds.isNotEmpty) {
-            taskListController.selectedTaskIds([]);
-          } else {
-            taskListController.selectedTaskIds(tasks.map((e) => e.id).toList());
-          }
-        }),
-        buildContextItem(Icons.check, 'select'.tr, () {
-          if (isSelect()) {
-            taskListController.selectedTaskIds(taskListController
-                .selectedTaskIds
-                .where((element) => element != task.id)
-                .toList());
-          } else {
-            taskListController.selectedTaskIds(
-                [...taskListController.selectedTaskIds, task.id]);
-          }
-        }),
-        const Divider(
-          indent: 8,
-          endIndent: 8,
-        ),
-        buildContextItem(Icons.play_arrow, 'continue'.tr, () async {
-          try {
-            await continueAllTasks(filterSelectedTaskIds(
-                {...taskListController.selectedTaskIds, task.id}));
-          } finally {
-            taskListController.selectedTaskIds([]);
-          }
-        }, enabled: !isDone() && !isRunning()),
-        buildContextItem(Icons.pause, 'pause'.tr, () async {
-          try {
-            await pauseAllTasks(filterSelectedTaskIds(
-                {...taskListController.selectedTaskIds, task.id}));
-          } finally {
-            taskListController.selectedTaskIds([]);
-          }
-        }, enabled: !isDone() && isRunning()),
-        buildContextItem(Icons.delete, 'delete'.tr, () async {
-          try {
-            await showDeleteDialog(filterSelectedTaskIds(
-                {...taskListController.selectedTaskIds, task.id}));
-          } finally {
-            taskListController.selectedTaskIds([]);
-          }
-        }),
-      ],
-      child: Obx(
-        () => Card(
-            elevation: 4.0,
-            shape: isSelect()
-                ? RoundedRectangleBorder(
-                    borderRadius: BorderRadius.circular(8.0),
-                    side: BorderSide(
-                      color: Theme.of(context).colorScheme.primary,
-                      width: 2.0,
-                    ),
-                  )
-                : null,
-            child: InkWell(
-              onTap: () {
-                taskController.scaffoldKey.currentState?.openEndDrawer();
-                taskController.selectTask.value = task;
-              },
-              onDoubleTap: () {
-                task.open();
-              },
-              child: Column(
-                mainAxisSize: MainAxisSize.min,
+    return Card(
+        elevation: 4.0,
+        child: InkWell(
+          onTap: () {
+            taskController.scaffoldKey.currentState?.openEndDrawer();
+            taskController.selectTask.value = task;
+          },
+          onDoubleTap: () {
+            task.open();
+          },
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              ListTile(
+                  title: Text(task.name),
+                  leading: isFolderTask()
+                      ? const Icon(FaIcons.folder)
+                      : Icon(FaIcons.allIcons[findIcon(task.name)])),
+              Row(
                 children: [
-                  ListTile(
-                      title: Text(task.name),
-                      leading: Icon(
-                        fileIcon(task.name,
-                            isFolder: isFolderTask(),
-                            isBitTorrent: task.protocol == Protocol.bt),
+                  Expanded(
+                      flex: 1,
+                      child: Text(
+                        getProgressText(),
+                        style: Get.textTheme.bodyLarge
+                            ?.copyWith(color: Get.theme.disabledColor),
+                      ).padding(left: 18)),
+                  Expanded(
+                      flex: 1,
+                      child: Row(
+                        mainAxisAlignment: MainAxisAlignment.end,
+                        children: [
+                          Text("${Util.fmtByte(task.progress.speed)} / s",
+                              style: Get.textTheme.titleSmall),
+                          ...buildActions()
+                        ],
                       )),
-                  Row(
-                    children: [
-                      Expanded(
-                          flex: 1,
-                          child: Text(
-                            getProgressText(),
-                            style: Get.textTheme.bodyLarge
-                                ?.copyWith(color: Get.theme.disabledColor),
-                          ).padding(left: 18)),
-                      Expanded(
-                          flex: 1,
-                          child: Row(
-                            mainAxisAlignment: MainAxisAlignment.end,
-                            children: [
-                              Text("${Util.fmtByte(task.progress.speed)} / s",
-                                  style: Get.textTheme.titleSmall),
-                              ...buildActions()
-                            ],
-                          )),
-                    ],
-                  ),
-                  isDone()
-                      ? Container()
-                      : LinearProgressIndicator(
-                          value: getProgress(),
-                        ),
                 ],
               ),
-            )).padding(horizontal: 14, top: 8),
-      ),
-    );
+              isDone()
+                  ? Container()
+                  : LinearProgressIndicator(
+                      value: getProgress(),
+                    ),
+            ],
+          ),
+        )).padding(horizontal: 14, top: 8);
   }
 }

ui/flutter/lib/app/views/file_icon.dart

@@ -1,76 +0,0 @@
-import 'package:flutter/material.dart';
-
-import '../../icon/gopeed_icons.dart';
-
-final Map<IconData, List<String>> iconConfigMap = {
-  Gopeed.install: ['exe', 'msi', 'dmg', 'deb', 'rpm'],
-  Gopeed.android: ['apk'],
-  Gopeed.app_store_ios: ['ipa'],
-  Gopeed.file_bt: ['torrent'],
-  Gopeed.cd: ['iso'],
-  Gopeed.html5: ['html', 'htm'],
-  Gopeed.file_alt: ['txt', 'md', 'log', 'csv', 'tsv', 'json', 'yaml', 'yml'],
-  Gopeed.file_pdf: ['pdf'],
-  Gopeed.file_word: ['doc', 'docx'],
-  Gopeed.file_excel: ['xls', 'xlsx'],
-  Gopeed.file_powerpoint: ['ppt', 'pptx'],
-  Gopeed.file_archive: ['zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz'],
-  Gopeed.file_image: [
-    'jpg',
-    'jpeg',
-    'png',
-    'gif',
-    'bmp',
-    'tiff',
-    'svg',
-    'webp'
-  ],
-  Gopeed.file_audio: ['mp3', 'wav', 'flac', 'aac', 'ogg', 'wma', 'm4a'],
-  Gopeed.file_video: ['mp4', 'avi', 'mkv', 'mov', 'wmv', 'flv', 'webm'],
-  Gopeed.file_code: [
-    'js',
-    'css',
-    'json',
-    'xml',
-    'java',
-    'cpp',
-    'dart',
-    'py',
-    'rb',
-    'php',
-    'ts',
-    'swift',
-    'go',
-    'rs'
-  ],
-  Gopeed.file: [''],
-};
-
-final Map<String, IconData> _iconCache = Map.fromEntries(
-  iconConfigMap.entries.expand(
-    (entry) => entry.value.map((ext) => MapEntry(ext, entry.key)),
-  ),
-);
-
-String fileExt(String? name) {
-  if (name == null) {
-    return '';
-  }
-
-  final ext = name.split('.').last;
-  if (ext.length > 8) {
-    return '';
-  }
-
-  return ext.toLowerCase();
-}
-
-IconData fileIcon(String? name,
-    {bool isFolder = false, bool isBitTorrent = false}) {
-  if (isFolder) {
-    return isBitTorrent ? Gopeed.folder_bt : Gopeed.folder;
-  }
-
-  final ext = fileExt(name);
-  return _iconCache[ext] ?? Gopeed.file;
-}

ui/flutter/lib/app/views/file_list_view.dart

@@ -0,0 +1,303 @@
+import 'dart:ui' as ui;
+
+import 'package:fluent_ui/fluent_ui.dart' as fluent;
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import '../../api/model/resource.dart';
+import 'package:path/path.dart' as path;
+
+import '../../util/file_icon.dart';
+import '../../util/icons.dart';
+import '../../util/util.dart';
+import '../modules/app/controllers/app_controller.dart';
+import '../modules/create/controllers/create_controller.dart';
+
+class FileListView extends GetView {
+  final List<FileInfo> files;
+
+  FileListView({
+    Key? key,
+    required this.files,
+  }) : super(key: key);
+  final parentController = Get.find<CreateController>();
+  final appController = Get.find<AppController>();
+
+  List findChildFileIdsR(List children) {
+    List res = [];
+    for (var k in children) {
+      if (parentController.fileInfos[k]['type'] == 'folder') {
+        res.addAll(
+            findChildFileIdsR(parentController.fileInfos[k]['children']));
+      } else {
+        res.add(parentController.fileInfos[k]['fileId']);
+      }
+    }
+    return res;
+  }
+
+  void clearDescendantFolderSizeR(int id) {
+    if (parentController.fileInfos[id]['type'] == 'folder') {
+      parentController.fileInfos[id]['size'] = 0;
+      for (var childId in parentController.fileInfos[id]['children']) {
+        clearDescendantFolderSizeR(childId);
+      }
+    }
+  }
+
+  void reduceAncestorFolderSizeR(int id, int size) {
+    int parentId = parentController.fileInfos[id]['parentId'];
+
+    if (parentId != -1) {
+      parentController.fileInfos[parentId]['size'] -= size;
+      reduceAncestorFolderSizeR(parentId, size);
+    }
+  }
+
+  int addDescendantFolderSizeR(int id) {
+    if (parentController.fileInfos[id]['type'] == 'folder') {
+      for (var childId in parentController.fileInfos[id]['children']) {
+        parentController.fileInfos[id]['size'] +=
+            addDescendantFolderSizeR(childId);
+      }
+    }
+    return parentController.fileInfos[id]['size'];
+  }
+
+  void addAncestorFolderSizeR(int id, int size) {
+    int parentId = parentController.fileInfos[id]['parentId'];
+    if (parentId != -1) {
+      parentController.fileInfos[parentId]['size'] += size;
+      addAncestorFolderSizeR(parentId, size);
+    }
+  }
+
+  List<fluent.TreeViewItem> buildTreeViewItemsR(int level, int parentId) {
+    List<fluent.TreeViewItem> res = [];
+    List children = parentController.fileInfos
+        .where((e) => e['level'] == level && e['parentId'] == parentId)
+        .toList();
+    for (int j = 0; j < children.length; j++) {
+      Map fileInfo = children[j];
+
+      if (fileInfo['type'] == 'folder') {
+        // folder
+        res.add(fluent.TreeViewItem(
+            // expanded: false, bug on init
+            value: fileInfo['id'],
+            onInvoked: (item, reason) async {
+              if (reason == fluent.TreeViewItemInvokeReason.selectionToggle) {
+                List childrenIds = findChildFileIdsR(fileInfo['children']);
+                if (item.selected == true) {
+                  parentController.selectedIndexes.addAll(childrenIds.cast());
+                  parentController.fileInfos[fileInfo['id']]['size'] = 0;
+                  addDescendantFolderSizeR(item.value);
+                  addAncestorFolderSizeR(item.value, fileInfo['size']);
+                  parentController.fileInfos.refresh();
+                } else {
+                  parentController.selectedIndexes
+                      .removeWhere((index) => childrenIds.contains(index));
+                  reduceAncestorFolderSizeR(item.value, fileInfo['size']);
+                  clearDescendantFolderSizeR(item.value);
+
+                  parentController.fileInfos.refresh();
+                }
+              }
+            },
+            leading: Obx(() {
+              return parentController.openedFolders.contains(fileInfo['id'])
+                  ? const Icon(FaIcons.folder_open,
+                      color: Colors.lightBlueAccent)
+                  : const Icon(FaIcons.folder, color: Colors.lightBlueAccent);
+            }),
+            onExpandToggle: (fluent.TreeViewItem item, bool getExpanded) async {
+              getExpanded
+                  ? parentController.openedFolders.add(item.value)
+                  : parentController.openedFolders.remove(item.value);
+            },
+            content: Row(mainAxisAlignment: MainAxisAlignment.end, children: [
+              Expanded(
+                child: Text(
+                  fileInfo['name'],
+                  overflow: TextOverflow.ellipsis,
+                  // style: context.textTheme.titleSmall,
+                ),
+              ),
+              Obx(() {
+                return parentController.fileInfos[fileInfo['id']]['size'] != 0
+                    ? Text(
+                        Util.fmtByte(
+                            parentController.fileInfos[fileInfo['id']]['size']),
+                        // style: context.textTheme.labelMedium,
+                        overflow: TextOverflow.ellipsis,
+                      )
+                    : const SizedBox.shrink();
+              })
+            ]),
+            children: buildTreeViewItemsR(
+                // parentController.fileInfos.where((e) => e['level'] > level).toList(),
+                level + 1,
+                fileInfo['id'])));
+      } else {
+        // file
+        res.add(fluent.TreeViewItem(
+          value: {'id': fileInfo['id'], 'fileId': fileInfo['fileId']},
+          selected: fileInfo['selected'],
+          onInvoked: (item, reason) async {
+            if (reason == fluent.TreeViewItemInvokeReason.selectionToggle) {
+              if (item.selected == true) {
+                parentController.selectedIndexes.add(item.value['fileId']);
+                addAncestorFolderSizeR(item.value['id'], fileInfo['size']);
+                parentController.fileInfos.refresh();
+              } else {
+                parentController.selectedIndexes.remove(item.value['fileId']);
+                reduceAncestorFolderSizeR(item.value['id'], fileInfo['size']);
+                parentController.fileInfos.refresh();
+              }
+            }
+          },
+          collapsable: false,
+          leading: fileInfo['name'].lastIndexOf('.') == -1
+              ? Icon(
+                  FaIcons.doc,
+                  color: appController.downloaderConfig.value.extra.themeMode ==
+                          'dark'
+                      ? Colors.white
+                      : Colors.black45,
+                )
+              : Icon(
+                  FaIcons.allIcons[findIcon(fileInfo['name'])],
+                  color: appController.downloaderConfig.value.extra.themeMode ==
+                          'dark'
+                      ? Colors.white
+                      : Colors.black45,
+                ),
+          content: Row(mainAxisAlignment: MainAxisAlignment.end, children: [
+            Expanded(
+                child: Text(
+              fileInfo['name'],
+              overflow: TextOverflow.ellipsis,
+              // style: context.textTheme.titleSmall,
+            )),
+            fileInfo['size'] > 0
+                ? Text(
+                    Util.fmtByte(
+                      fileInfo['size'],
+                    ),
+                    // style: context.textTheme.labelMedium,
+                    overflow: TextOverflow.ellipsis,
+                  )
+                : const SizedBox.shrink(),
+          ]),
+        ));
+      }
+    }
+
+    return res;
+  }
+
+  List<fluent.TreeViewItem> get items {
+    List infos = [];
+    int idNext = 0;
+    List selectedFileIds = [];
+    List openedFolders = [];
+    //make fileInfos list
+    for (var i = 0; i < files.length; i++) {
+      //parentId -1 means path root
+      int parentId = -1;
+      List folders = path.split(files[i].path);
+      for (var folder in folders) {
+        int indexInInfos = infos.lastIndexWhere((fileInfo) =>
+            fileInfo['name'] == folder && fileInfo['parentId'] == parentId);
+
+        if (indexInInfos != -1) {
+          //  folder exists
+          parentId = infos[indexInInfos]['id'];
+          // add size
+          infos[indexInInfos]['size'] += files[i].size;
+        } else {
+          // parent not exist
+          // create one and add index to parent's children
+          infos.add({
+            'level': folders.indexOf(folder),
+            'id': idNext,
+            'type': 'folder',
+            'name': folder,
+            'size': files[i].size,
+            'parentId': parentId,
+            'children': [],
+          });
+          openedFolders.add(idNext);
+          if (parentId != -1) {
+            infos[parentId]['children'].add(idNext);
+          }
+          parentId = idNext;
+          idNext++;
+        }
+      }
+      //add one file, add index to parent
+      infos.add({
+        'id': idNext,
+        'type': 'file',
+        'fileId': i,
+        'level': folders.length,
+        'name': files[i].name,
+        'size': files[i].size,
+        'parentId': parentId,
+        //TODO add unselected logic
+        'selected': true
+      });
+      selectedFileIds.add(i);
+      if (parentId != -1) {
+        infos[parentId]['children'].add(idNext);
+      }
+      idNext++;
+    }
+    parentController.fileInfos.value = infos;
+    parentController.selectedIndexes.value = selectedFileIds.cast();
+    parentController.openedFolders.value = openedFolders;
+    List<fluent.TreeViewItem> treeItems = buildTreeViewItemsR(0, -1);
+    return treeItems;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return fluent.FluentTheme(
+        data: appController.downloaderConfig.value.extra.themeMode == 'system'
+            ? fluent.FluentThemeData(brightness: ui.window.platformBrightness)
+            : appController.downloaderConfig.value.extra.themeMode == 'light'
+                ? fluent.FluentThemeData(brightness: Brightness.light)
+                : fluent.FluentThemeData(brightness: Brightness.dark),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            const Padding(padding: EdgeInsets.only(top: 10)),
+            Text(
+              'selectFile'.tr,
+              // style: TextStyle(color: themeData.hintColor),
+            ),
+            Expanded(
+                child: Container(
+                    margin: const EdgeInsets.only(top: 10),
+                    decoration: BoxDecoration(
+                        border: Border.all(color: Colors.grey, width: 1),
+                        borderRadius: BorderRadius.circular(5)),
+                    child: fluent.TreeView(
+                      selectionMode: fluent.TreeViewSelectionMode.multiple,
+                      shrinkWrap: false,
+                      // addRepaintBoundaries: false,
+                      usePrototypeItem: true,
+                      // cacheExtent: 20,
+                      // onItemInvoked: (item, reason) async => {},
+                      onSecondaryTap: (item, details) async {
+                        debugPrint(
+                            'onSecondaryTap $item at ${details.globalPosition}');
+                      },
+                      // onSelectionChanged: (selectedItems) async => {},
+                      narrowSpacing: true,
+                      items: items,
+                      // scrollPrimary: true,
+                    ))),
+          ],
+        ));
+  }
+}

ui/flutter/lib/app/views/file_tree_view.dart

@@ -1,292 +0,0 @@
-import 'package:checkable_treeview/checkable_treeview.dart';
-import 'package:flutter/material.dart';
-import 'package:get/get.dart';
-import 'package:toggle_switch/toggle_switch.dart';
-
-import '../../api/model/resource.dart';
-import '../../icon/gopeed_icons.dart';
-import '../../util/util.dart';
-import 'file_icon.dart';
-import 'sort_icon_button.dart';
-
-const _toggleSwitchIcons = [
-  Gopeed.file_video,
-  Gopeed.file_audio,
-  Gopeed.file_image,
-];
-const _sizeGapWidth = 72.0;
-
-class FileTreeView extends StatefulWidget {
-  final List<FileInfo> files;
-  final List<int> initialValues;
-  final Function(List<int>) onSelectionChanged;
-
-  const FileTreeView(
-      {Key? key,
-      required this.files,
-      required this.initialValues,
-      required this.onSelectionChanged})
-      : super(key: key);
-
-  @override
-  State<FileTreeView> createState() => _FileTreeViewState();
-}
-
-class _FileTreeViewState extends State<FileTreeView> {
-  late GlobalKey<TreeViewState<int>> key;
-  late int totalSize;
-  int? toggleSwitchIndex;
-
-  @override
-  void initState() {
-    super.initState();
-    key = GlobalKey<TreeViewState<int>>();
-    totalSize = widget.files
-        .fold(0, (previousValue, element) => previousValue + element.size);
-    widget.onSelectionChanged(widget.initialValues);
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final selectedFileCount =
-        key.currentState?.getSelectedValues().where((e) => e != null).length ??
-            widget.files.length;
-    final selectedFileSize = calcSelectedSize(null);
-
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: [
-        Expanded(
-          child: Container(
-            decoration: BoxDecoration(
-              border: Border.all(color: Theme.of(context).dividerColor),
-              borderRadius: BorderRadius.circular(4),
-            ),
-            child: TreeView(
-              key: key,
-              nodes: buildTreeNodes(),
-              showExpandCollapseButton: true,
-              showSelectAll: true,
-              onSelectionChanged: (selectedValues) {
-                setState(() {});
-                widget.onSelectionChanged(selectedValues
-                    .where((e) => e != null)
-                    .map((e) => e!)
-                    .toList());
-              },
-              selectAllTrailing: (context) {
-                return Row(
-                  mainAxisAlignment: MainAxisAlignment.spaceBetween,
-                  children: [
-                    Row(
-                      mainAxisAlignment: MainAxisAlignment.end,
-                      children: [
-                        Text('name'.tr),
-                        SortIconButton(
-                          onStateChanged: (state) {
-                            switch (state) {
-                              case SortState.asc:
-                                key.currentState?.sort((p0, p1) {
-                                  return (p0.label as Text)
-                                      .data!
-                                      .compareTo((p1.label as Text).data!);
-                                });
-                                break;
-                              case SortState.desc:
-                                key.currentState?.sort((p0, p1) {
-                                  return (p1.label as Text)
-                                      .data!
-                                      .compareTo((p0.label as Text).data!);
-                                });
-                                break;
-                              default:
-                                key.currentState?.sort(null);
-                                break;
-                            }
-                          },
-                        ),
-                      ],
-                    ),
-                    Row(
-                      mainAxisAlignment: MainAxisAlignment.end,
-                      children: [
-                        Text('size'.tr),
-                        SortIconButton(
-                          onStateChanged: (state) {
-                            switch (state) {
-                              case SortState.asc:
-                                key.currentState?.sort((p0, p1) {
-                                  return calcSelectedSize(p0)
-                                      .compareTo(calcSelectedSize(p1));
-                                });
-                                break;
-                              case SortState.desc:
-                                key.currentState?.sort((p0, p1) {
-                                  return calcSelectedSize(p1)
-                                      .compareTo(calcSelectedSize(p0));
-                                });
-                                break;
-                              default:
-                                key.currentState?.sort(null);
-                                break;
-                            }
-                          },
-                        ),
-                      ],
-                    )
-                  ],
-                );
-              },
-            ),
-          ),
-        ),
-        const SizedBox(height: 12),
-        Row(
-          mainAxisAlignment: MainAxisAlignment.spaceBetween,
-          crossAxisAlignment: CrossAxisAlignment.center,
-          children: [
-            Flexible(
-              flex: 4,
-              child: InkWell(
-                onTap: () {},
-                child: ToggleSwitch(
-                  minHeight: 32,
-                  cornerRadius: 8,
-                  doubleTapDisable: true,
-                  inactiveBgColor: Theme.of(context).dividerColor,
-                  activeBgColor: [Theme.of(context).colorScheme.primary],
-                  initialLabelIndex: toggleSwitchIndex,
-                  icons: _toggleSwitchIcons,
-                  onToggle: (index) {
-                    toggleSwitchIndex = index;
-                    if (index == null) {
-                      key.currentState?.setSelectedValues(List.empty());
-                      return;
-                    }
-
-                    final iconFileExtArr =
-                        iconConfigMap[_toggleSwitchIcons[index]] ?? [];
-                    final selectedFileIndexes = widget.files
-                        .asMap()
-                        .entries
-                        .where((e) =>
-                            iconFileExtArr.contains(fileExt(e.value.name)))
-                        .map((e) => e.key)
-                        .toList();
-                    key.currentState?.setSelectedValues(selectedFileIndexes);
-                  },
-                ),
-              ),
-            ),
-            Flexible(
-              flex: 6,
-              child: Row(
-                mainAxisAlignment: MainAxisAlignment.end,
-                children: [
-                  Text('fileSelectedCount'.tr),
-                  Text(
-                    selectedFileCount.toString(),
-                    style: Theme.of(context).textTheme.bodySmall,
-                  ),
-                  const SizedBox(width: 12),
-                  Text('fileSelectedSize'.tr),
-                  Text(
-                    selectedFileCount > 0 && selectedFileSize == 0
-                        ? 'unknown'.tr
-                        : Util.fmtByte(selectedFileSize),
-                    style: Theme.of(context).textTheme.bodySmall,
-                  ),
-                ],
-              ),
-            ),
-          ],
-        ),
-      ],
-    );
-  }
-
-  int calcSelectedSize(TreeNode<int>? node) {
-    if (key.currentState == null) {
-      return widget.files
-          .fold(0, (previousValue, element) => previousValue + element.size);
-    }
-
-    final selectedFileIndexes = node == null
-        ? key.currentState?.getSelectedValues()
-        : (node.value != null
-            ? [node.value]
-            : key.currentState?.getChildSelectedValues(node));
-
-    if (selectedFileIndexes == null) return 0;
-    return selectedFileIndexes.where((e) => e != null).map((e) => e!).fold(0,
-        (previousValue, element) => previousValue + widget.files[element].size);
-  }
-
-  List<TreeNode<int>> buildTreeNodes() {
-    final List<TreeNode<int>> rootNodes = [];
-    final Map<String, TreeNode<int>> dirNodes = {};
-
-    for (var i = 0; i < widget.files.length; i++) {
-      final file = widget.files[i];
-      final parts = file.path.split('/');
-      String currentPath = '';
-      TreeNode<int>? parentNode;
-
-      // Create or get directory nodes
-      for (final part in parts) {
-        if (part.isEmpty) continue;
-
-        currentPath += '/$part';
-        if (!dirNodes.containsKey(currentPath)) {
-          final node = TreeNode<int>(
-            label: Text(part),
-            icon: Icon(
-              fileIcon(part, isFolder: true),
-              size: 18,
-            ),
-            trailing: (context, node) {
-              final size = calcSelectedSize(node);
-              return size > 0
-                  ? Text(Util.fmtByte(calcSelectedSize(node)),
-                      style: Theme.of(context).textTheme.bodySmall)
-                  : const SizedBox(width: _sizeGapWidth);
-            },
-            children: [],
-          );
-          dirNodes[currentPath] = node;
-
-          if (parentNode == null) {
-            rootNodes.add(node);
-          } else {
-            parentNode.children.add(node);
-          }
-        }
-        parentNode = dirNodes[currentPath];
-      }
-
-      // Create file node using file.name
-      final fileNode = TreeNode<int>(
-        label: Text(file.name),
-        value: i,
-        icon: Icon(fileIcon(file.name, isFolder: false), size: 18),
-        trailing: (context, node) {
-          return file.size > 0
-              ? Text(Util.fmtByte(file.size),
-                  style: Theme.of(context).textTheme.bodySmall)
-              : const SizedBox(width: _sizeGapWidth);
-        },
-        isSelected: widget.initialValues.contains(i),
-        children: [],
-      );
-
-      // Add file node to parent or root
-      if (parentNode != null) {
-        parentNode.children.add(fileNode);
-      } else {
-        rootNodes.add(fileNode);
-      }
-    }
-
-    return rootNodes;
-  }
-}

ui/flutter/lib/app/views/sort_icon_button.dart

@@ -1,102 +0,0 @@
-import 'package:flutter/material.dart';
-
-import '../../icon/gopeed_icons.dart';
-
-enum SortState { none, asc, desc }
-
-class SortIconButton extends StatefulWidget {
-  final double size;
-  final Color? color;
-  final Color? activeColor;
-  final SortState initialState;
-  final Function(SortState) onStateChanged;
-
-  const SortIconButton({
-    Key? key,
-    this.size = 18.0,
-    this.color,
-    this.activeColor,
-    this.initialState = SortState.none,
-    required this.onStateChanged,
-  }) : super(key: key);
-
-  @override
-  State<SortIconButton> createState() => _SortIconState();
-}
-
-class _SortIconState extends State<SortIconButton> {
-  late SortState _currentState;
-
-  @override
-  void initState() {
-    super.initState();
-    _currentState = widget.initialState;
-  }
-
-  void _toggleState() {
-    setState(() {
-      switch (_currentState) {
-        case SortState.none:
-          _currentState = SortState.asc;
-          break;
-        case SortState.asc:
-          _currentState = SortState.desc;
-          break;
-        case SortState.desc:
-          _currentState = SortState.none;
-          break;
-      }
-    });
-    widget.onStateChanged(_currentState);
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return InkWell(
-      customBorder: const CircleBorder(),
-      onTap: _toggleState,
-      child: SizedBox(
-        width: widget.size,
-        height: widget.size,
-        child: _currentState == SortState.none
-            ? Icon(
-                Gopeed.sort,
-                size: widget.size,
-                color: widget.color,
-              )
-            : Column(
-                children: [
-                  ClipRect(
-                    child: Align(
-                      alignment: Alignment.topCenter,
-                      heightFactor: 0.5,
-                      child: Icon(
-                        Gopeed.sort,
-                        size: widget.size,
-                        color: _currentState == SortState.asc
-                            ? (widget.activeColor ??
-                                Theme.of(context).colorScheme.primary)
-                            : widget.color,
-                      ),
-                    ),
-                  ),
-                  ClipRect(
-                    child: Align(
-                      alignment: Alignment.bottomCenter,
-                      heightFactor: 0.5,
-                      child: Icon(
-                        Gopeed.sort,
-                        size: widget.size,
-                        color: _currentState == SortState.desc
-                            ? (widget.activeColor ??
-                                Theme.of(context).colorScheme.primary)
-                            : widget.color,
-                      ),
-                    ),
-                  ),
-                ],
-              ),
-      ),
-    );
-  }
-}

ui/flutter/lib/core/common/libgopeed_channel.dart

@@ -1,23 +0,0 @@
-import 'dart:convert';
-
-import 'package:flutter/services.dart';
-
-import 'libgopeed_interface.dart';
-import 'start_config.dart';
-
-class LibgopeedChannel implements LibgopeedInterface {
-  static const _channel = MethodChannel('gopeed.com/libgopeed');
-
-  @override
-  Future<int> start(StartConfig cfg) async {
-    final port = await _channel.invokeMethod('start', {
-      'cfg': jsonEncode(cfg),
-    });
-    return port as int;
-  }
-
-  @override
-  Future<void> stop() async {
-    return await _channel.invokeMethod('stop');
-  }
-}

ui/flutter/lib/core/common/libgopeed_ffi.dart

@@ -1,37 +0,0 @@
-import 'dart:async';
-import 'dart:convert';
-import 'dart:ffi';
-
-import 'package:ffi/ffi.dart';
-
-import '../ffi/libgopeed_bind.dart';
-import 'libgopeed_interface.dart';
-import 'start_config.dart';
-
-class LibgopeedFFi implements LibgopeedInterface {
-  late LibgopeedBind _libgopeed;
-
-  LibgopeedFFi(LibgopeedBind libgopeed) {
-    _libgopeed = libgopeed;
-  }
-
-  @override
-  Future<int> start(StartConfig cfg) {
-    var completer = Completer<int>();
-    var result = _libgopeed.Start(jsonEncode(cfg).toNativeUtf8().cast());
-    if (result.r1 != nullptr) {
-      completer.completeError(Exception(result.r1.cast<Utf8>().toDartString()));
-    } else {
-      completer.complete(result.r0);
-    }
-    return completer.future;
-  }
-
-  @override
-  Future<void> stop() {
-    var completer = Completer<void>();
-    _libgopeed.Stop();
-    completer.complete();
-    return completer.future;
-  }
-}

ui/flutter/lib/core/common/libgopeed_interface.dart

@@ -1,7 +0,0 @@
-import 'start_config.dart';
-
-abstract class LibgopeedInterface {
-  Future<int> start(StartConfig cfg);
-
-  Future<void> stop();
-}

ui/flutter/lib/core/entry/libgopeed_boot_browser.dart

@@ -1,18 +0,0 @@
-import 'dart:async';
-
-import '../common/start_config.dart';
-
-import '../libgopeed_boot.dart';
-
-LibgopeedBoot create() => LibgopeedBootBrowser();
-
-class LibgopeedBootBrowser implements LibgopeedBoot {
-  // do nothing
-  @override
-  Future<int> start(StartConfig cfg) async {
-    return 0;
-  }
-
-  @override
-  Future<void> stop() async {}
-}

ui/flutter/lib/core/entry/libgopeed_boot_native.dart

@@ -1,49 +0,0 @@
-import 'dart:async';
-import 'dart:ffi';
-import 'dart:io';
-
-import '../../util/util.dart';
-import '../common/libgopeed_channel.dart';
-import '../common/libgopeed_ffi.dart';
-import '../common/libgopeed_interface.dart';
-import '../common/start_config.dart';
-import '../ffi/libgopeed_bind.dart';
-import '../libgopeed_boot.dart';
-
-LibgopeedBoot create() => LibgopeedBootNative();
-
-class LibgopeedBootNative implements LibgopeedBoot {
-  late LibgopeedInterface _libgopeed;
-
-  LibgopeedBootNative() {
-    if (Util.isDesktop()) {
-      var libName = "libgopeed.";
-      if (Platform.isWindows) {
-        libName += "dll";
-      }
-      if (Platform.isMacOS) {
-        libName += "dylib";
-      }
-      if (Platform.isLinux) {
-        libName += "so";
-      }
-      _libgopeed = LibgopeedFFi(LibgopeedBind(DynamicLibrary.open(libName)));
-    } else {
-      _libgopeed = LibgopeedChannel();
-    }
-  }
-
-  @override
-  Future<int> start(StartConfig cfg) async {
-    cfg.storage = 'bolt';
-    cfg.storageDir = Util.getStorageDir();
-    cfg.refreshInterval = 0;
-    var port = await _libgopeed.start(cfg);
-    return port;
-  }
-
-  @override
-  Future<void> stop() async {
-    await _libgopeed.stop();
-  }
-}

ui/flutter/lib/core/libgopeed_boot.dart

@@ -1,19 +0,0 @@
-import 'common/start_config.dart';
-import "libgopeed_boot_stub.dart"
-    if (dart.library.html) 'entry/libgopeed_boot_browser.dart'
-    if (dart.library.io) 'entry/libgopeed_boot_native.dart';
-
-abstract class LibgopeedBoot {
-  static LibgopeedBoot? _instance;
-
-  static LibgopeedBoot get instance {
-    _instance ??= LibgopeedBoot();
-    return _instance!;
-  }
-
-  factory LibgopeedBoot() => create();
-
-  Future<int> start(StartConfig cfg);
-
-  Future<void> stop();
-}

ui/flutter/lib/i18n/langs/en_us.dart

@@ -8,7 +8,6 @@ const enUS = {
     'on': 'On',
     'off': 'Off',
     'selectAll': 'Select All',
-    'select': 'Select',
     'task': 'Tasks',
     'downloading': 'downloading',
     'downloaded': 'downloaded',
@@ -21,7 +20,8 @@ const enUS = {
     'followSettings': 'Follow Settings',
     'downloadLink': 'Download Link',
     'downloadLinkValid': 'Please enter the download link',
-    'downloadLinkHit': 'Please enter the download link, one per line@append',
+    'downloadLinkHit':
+        'Please enter the download link, HTTP/HTTPS/MAGNET supported@append',
     'downloadLinkHitDesktop': ', or drag the torrent file here directly',
     'download': 'Download',
     'noFileSelected': 'Please select at least one file to continue.',
@@ -65,20 +65,18 @@ const enUS = {
     'developer': 'Developer',
     'logDirectory': 'Log Directory',
     'show': 'Show',
-    'continue': 'Continue',
-    'pause': 'Pause',
     'startAll': 'Start All',
     'pauseAll': 'Pause All',
-    'deleteTask': 'Delete @count tasks',
+    'deleteTask': 'Delete Task',
     'deleteTaskTip': 'Keep downloaded files',
     'delete': 'Delete',
     'newVersionTitle': 'Discover new version @version',
-    'newVersionUpdate': 'Update Now',
+    'newVersionUpgrade': 'Update Now',
     'newVersionLater': 'Later',
     'extensions': 'Extensions',
     'extensionInstallUrl': 'Install URL',
     'extensionInstallSuccess': 'Installed successfully',
-    'extensionUpdateSuccess': 'Updated successfully',
+    'extensionUpgradeSuccess': 'Updated successfully',
     'extensionDelete': 'Delete Extension',
     'extensionAlreadyLatest': 'It\'s already the latest version',
     'extensionFind': 'Find Extensions',
@@ -110,10 +108,5 @@ const enUS = {
     'taskUrl': 'Task URL',
     'downloadPath': 'Download Path',
     'skipVerifyCert': 'Skip Certificate Verification',
-    'name': 'Name',
-    'size': 'Size',
-    'unknown': 'Unknown',
-    'fileSelectedCount': 'Files: ',
-    'fileSelectedSize': 'Size: ',
   },
 };

ui/flutter/lib/i18n/langs/es_es.dart

@@ -21,9 +21,11 @@ const esES = {
     'downloadLinkValid': 'Por favor, introduce el enlace de descarga',
     'downloadLinkHit':
         'Por favor, introduce el enlace de descarga, se admite HTTP/HTTPS/MAGNET@append',
-    'downloadLinkHitDesktop': ', o arrastra el archivo torrent aquí directamente',
+    'downloadLinkHitDesktop':
+        ', o arrastra el archivo torrent aquí directamente',
     'download': 'Descargar',
-    'noFileSelected': 'Por favor, selecciona al menos un archivo para continuar.',
+    'noFileSelected':
+        'Por favor, selecciona al menos un archivo para continuar.',
     'noStoragePermission': 'Se requiere permiso de almacenamiento',
     'selectFile': 'Seleccionar Archivo',
     'rename': 'Renombrar',
@@ -43,7 +45,8 @@ const esES = {
     'updateDaily': 'Actualizar diariamente',
     'lastUpdate': 'Última actualización: @time',
     'addTracker': 'Añadir Tracker',
-    'addTrackerHit': 'Por favor, introduce la URL del servidor tracker, una por línea',
+    'addTrackerHit':
+        'Por favor, introduce la URL del servidor tracker, una por línea',
     'ui': 'Interfaz',
     'theme': 'Tema',
     'themeSystem': 'Sistema',
@@ -63,16 +66,16 @@ const esES = {
     'show': 'Mostrar',
     'startAll': 'Iniciar Todo',
     'pauseAll': 'Pausar Todo',
-    'deleteTask': 'Eliminar @count tareas',
+    'deleteTask': 'Eliminar Tarea',
     'deleteTaskTip': 'Mantener archivos descargados',
     'delete': 'Eliminar',
     'newVersionTitle': 'Nueva versión @version disponible',
-    'newVersionUpdate': 'Actualizar Ahora',
+    'newVersionUpgrade': 'Actualizar Ahora',
     'newVersionLater': 'Más tarde',
     'extensions': 'Extensiones',
     'extensionInstallUrl': 'URL de instalación',
     'extensionInstallSuccess': 'Instalado con éxito',
-    'extensionUpdateSuccess': 'Actualizado con éxito',
+    'extensionUpgradeSuccess': 'Actualizado con éxito',
     'extensionDelete': 'Eliminar Extensión',
     'extensionAlreadyLatest': 'Ya es la versión más reciente',
     'extensionFind': 'Buscar Extensiones',
@@ -105,4 +108,4 @@ const esES = {
     'downloadPath': 'Ruta de Descarga',
     'skipVerifyCert': 'Omitir Verificación de Certificado',
   },
-};
+};

ui/flutter/lib/i18n/langs/fa_ir.dart

@@ -51,11 +51,11 @@ const faIR = {
     'effectAfterRestart': 'Effect after restart',
     'startAll': 'شروع همه',
     'pauseAll': 'توقف همه',
-    'deleteTask': 'حذف @count کار',
+    'deleteTask': 'پاک کردن کار',
     'deleteTaskTip': 'فایل های دانلود شده را نگه دارد',
     'delete': 'پاک کردن',
     'newVersionTitle': '@version عنوان: کشف نسخه جدید',
-    'newVersionUpdate': 'بروزرسانی',
+    'newVersionUpgrade': 'بروزرسانی',
     'newVersionLater': 'بعداً',
     'thanks': 'تشکر',
     'thanksDesc':

ui/flutter/lib/i18n/langs/fr_fr.dart

@@ -19,10 +19,12 @@ const frFR = {
     'advancedOptions': 'Options avancées',
     'downloadLink': 'Lien de téléchargement',
     'downloadLinkValid': 'Veuillez entrer le lien de téléchargement',
-    'downloadLinkHit': 'Veuillez entrer le lien de téléchargement, HTTP/HTTPS/MAGNET pris en charge',
+    'downloadLinkHit':
+        'Veuillez entrer le lien de téléchargement, HTTP/HTTPS/MAGNET pris en charge',
     'downloadLinkHitDesktop': ', ou glissez directement le fichier torrent ici',
     'download': 'Télécharger',
-    'noFileSelected': 'Veuillez sélectionner au moins un fichier pour continuer.',
+    'noFileSelected':
+        'Veuillez sélectionner au moins un fichier pour continuer.',
     'noStoragePermission': 'Permission de stockage requise',
     'selectFile': 'Sélectionner un fichier',
     'rename': 'Renommer',
@@ -32,16 +34,19 @@ const frFR = {
     'downloadDir': 'Répertoire de téléchargement',
     'downloadDirValid': 'Veuillez sélectionner le répertoire de téléchargement',
     'connections': 'Connexions',
-    'useServerCtime': 'Utiliser l\'heure du serveur pour la création de fichier',
+    'useServerCtime':
+        'Utiliser l\'heure du serveur pour la création de fichier',
     'maxRunning': 'Tâches en cours maximum',
     'items': '@count éléments',
     'subscribeTracker': 'S\'abonner au tracker',
-    'subscribeFail': 'Abonnement échoué, veuillez vérifier le réseau ou réessayer plus tard',
+    'subscribeFail':
+        'Abonnement échoué, veuillez vérifier le réseau ou réessayer plus tard',
     'update': 'Mettre à jour',
     'updateDaily': 'Mettre à jour quotidiennement',
     'lastUpdate': 'Dernière mise à jour : @time',
     'addTracker': 'Ajouter un tracker',
-    'addTrackerHit': 'Veuillez entrer l\'URL du serveur de tracker, une par ligne',
+    'addTrackerHit':
+        'Veuillez entrer l\'URL du serveur de tracker, une par ligne',
     'ui': 'Interface utilisateur',
     'theme': 'Thème',
     'themeSystem': 'Système',
@@ -61,16 +66,16 @@ const frFR = {
     'show': 'Afficher',
     'startAll': 'Tout démarrer',
     'pauseAll': 'Tout suspendre',
-    'deleteTask': 'Supprimer @count tâches',
+    'deleteTask': 'Supprimer la tâche',
     'deleteTaskTip': 'Conserver les fichiers téléchargés',
     'delete': 'Supprimer',
     'newVersionTitle': 'Nouvelle version @version disponible',
-    'newVersionUpdate': 'Mettre à jour maintenant',
+    'newVersionUpgrade': 'Mettre à jour maintenant',
     'newVersionLater': 'Plus tard',
     'extensions': 'Extensions',
     'extensionInstallUrl': 'URL d\'installation',
     'extensionInstallSuccess': 'Installé avec succès',
-    'extensionUpdateSuccess': 'Mis à jour avec succès',
+    'extensionUpgradeSuccess': 'Mis à jour avec succès',
     'extensionDelete': 'Supprimer l\'extension',
     'extensionAlreadyLatest': 'C\'est déjà la dernière version',
     'extensionFind': 'Trouver des extensions',
@@ -89,7 +94,8 @@ const frFR = {
     'username': 'Nom d\'utilisateur',
     'password': 'Mot de passe',
     'thanks': 'Merci',
-    'thanksDesc': 'Merci à tous les contributeurs qui ont aidé à construire et développer la communauté Gopeed !',
+    'thanksDesc':
+        'Merci à tous les contributeurs qui ont aidé à construire et développer la communauté Gopeed !',
     'browserExtension': 'Extension du navigateur',
     'launchAtStartup': 'Lancer au démarrage',
     'skipVerifyCert': 'Bypass Verifikasi Sertifikat',

ui/flutter/lib/i18n/langs/id_id.dart

@@ -22,7 +22,8 @@ const idID = {
     'downloadLinkValid': 'Silakan masukkan tautan unduhan',
     'downloadLinkHit':
         'Tolong masukkan tautan unduhan, HTTP/HTTPS/MAGNET didukung@append',
-    'downloadLinkHitDesktop': ', atau seret file torrent ke sini secara langsung',
+    'downloadLinkHitDesktop':
+        ', atau seret file torrent ke sini secara langsung',
     'download': 'Download',
     'noFileSelected': 'Silakan pilih setidaknya satu file untuk melanjutkan.',
     'noStoragePermission': 'Izin penyimpanan diperlukan',
@@ -67,16 +68,16 @@ const idID = {
     'show': 'Tampilkan',
     'startAll': 'Mulai Semua',
     'pauseAll': 'Jeda Semua',
-    'deleteTask': 'Hapus @count Tugas',
+    'deleteTask': 'Hapus Tugas',
     'deleteTaskTip': 'Simpan file yang terunduh',
     'delete': 'Hapus',
     'newVersionTitle': 'Temukan versi batu @version',
-    'newVersionUpdate': 'Perbarui Sekarang',
+    'newVersionUpgrade': 'Perbarui Sekarang',
     'newVersionLater': 'Nanti',
     'extensions': 'Ekstensi',
     'extensionInstallUrl': 'URL Instal',
     'extensionInstallSuccess': 'Diinstal dengan sukses',
-    'extensionUpdateSuccess': 'Diperbaruhi dengan sukses',
+    'extensionUpgradeSuccess': 'Diperbaruhi dengan sukses',
     'extensionDelete': 'Hapus Ekstensi',
     'extensionAlreadyLatest': 'Ini sudah versi terbaru',
     'extensionFind': 'Temukan Ekstensi',

ui/flutter/lib/i18n/langs/it_it.dart

@@ -64,16 +64,16 @@ const itIT = {
     'show': 'Mostra',
     'startAll': 'Avvia tutti',
     'pauseAll': 'Mtti in pausa tutti',
-    'deleteTask': 'Elimina @count attività',
+    'deleteTask': 'Elimina attività',
     'deleteTaskTip': 'Conserva i file scaricati',
     'delete': 'Elimina',
     'newVersionTitle': 'Scopri la nuova versione @version',
-    'newVersionUpdate': 'Aggiorna ora',
+    'newVersionUpgrade': 'Aggiorna ora',
     'newVersionLater': 'Dopo',
     'extensions': 'Estensioni',
     'extensionInstallUrl': 'Installa URL',
     'extensionInstallSuccess': 'Installato con successo',
-    'extensionUpdateSuccess': 'Aggiornato con successo',
+    'extensionUpgradeSuccess': 'Aggiornato con successo',
     'extensionDelete': 'Elimina estensione',
     'extensionAlreadyLatest': "È già l'ultima versione",
     'extensionFind': 'Trova estensioni',

ui/flutter/lib/i18n/langs/ja_jp.dart

@@ -53,11 +53,11 @@ const jaJP = {
     'effectAfterRestart': '再起動後の効果',
     'startAll': 'すべてを開始',
     'pauseAll': 'すべてを一時停止',
-    'deleteTask': '@count タスクを削除',
+    'deleteTask': 'タスクを削除',
     'deleteTaskTip': 'ダウンロードしたファイルを保持',
     'delete': '削除',
     'newVersionTitle': '新しいバージョン @version を発見する',
-    'newVersionUpdate': 'アップデート',
+    'newVersionUpgrade': 'アップデート',
     'newVersionLater': '後で',
     'thanks': '感謝',
     'thanksDesc': 'Gopeedコミュニティの建設に協力してくださったすべての貢献者の方々に感謝します！',

ui/flutter/lib/i18n/langs/pl_pl.dart

@@ -62,16 +62,16 @@ const plPL = {
     'show': 'Pokaż',
     'startAll': 'Zacznij wszystkie',
     'pauseAll': 'Zatrzymaj wszystkie',
-    'deleteTask': 'Usuń @count zadania',
+    'deleteTask': 'Usuń zadanie',
     'deleteTaskTip': 'Zachowaj pobrane pliki',
     'delete': 'Usuń',
     'newVersionTitle': 'Sprawdź aktualizację @version',
-    'newVersionUpdate': 'Aktualizuj teraz',
+    'newVersionUpgrade': 'Aktualizuj teraz',
     'newVersionLater': 'Później',
     'extensions': 'Wtyczki',
     'extensionInstallUrl': 'Instaluj z url',
     'extensionInstallSuccess': 'Instalacja zakończona',
-    'extensionUpdateSuccess': 'Aktualizacja zakończona',
+    'extensionUpgradeSuccess': 'Aktualizacja zakończona',
     'extensionDelete': 'Usuń wtyczkę',
     'extensionAlreadyLatest': 'Wtyczka w aktualnej wersji',
     'extensionFind': 'Wyszukaj wtyczkę',

ui/flutter/lib/i18n/langs/ru_ru.dart

@@ -57,15 +57,15 @@ const ruRU = {
     'effectAfterRestart': 'Эффект после перезагрузки',
     'startAll': 'Запустить все',
     'pauseAll': 'Приостановить все',
-    'deleteTask': 'Удалить @count задач',
+    'deleteTask': 'Удалить задачу',
     'deleteTaskTip': 'Сохранить загруженные файлы',
     'delete': 'Удалить',
     'newVersionTitle': 'Обнаружена новая версия @version',
-    'newVersionUpdate': 'Обновить',
+    'newVersionUpgrade': 'Обновить',
     'newVersionLater': 'позже',
     'extensions': 'Расширения',
     'extensionInstallSuccess': 'Установка завершена',
-    'extensionUpdateSuccess': 'Обновление завершено',
+    'extensionUpgradeSuccess': 'Обновление завершено',
     'extensionDelete': 'Удалить расширение',
     'extensionAlreadyLatest': 'Это последняя версия',
     'extensionFind': 'Найти расширения',

ui/flutter/lib/i18n/langs/ta_ta.dart

@@ -21,7 +21,8 @@ const taTA = {
     'downloadLinkValid': 'பதிவிறக்க இணைப்பை உள்ளிடவும்',
     'downloadLinkHit':
         'பதிவிறக்க இணைப்பை உள்ளிடவும், HTTP/HTTPS/MAGNET ஆகியவற்றை ஏற்கும்@append',
-    'downloadLinkHitDesktop': ', அல்லது torrent கோப்பை நேரடியாக இங்கே இழுக்கவும்',
+    'downloadLinkHitDesktop':
+        ', அல்லது torrent கோப்பை நேரடியாக இங்கே இழுக்கவும்',
     'download': 'பதிவிறக்கு',
     'noFileSelected': 'குறைந்தபட்சம் ஒரு கோப்பைத் தேர்ந்தெடுக்கவும்.',
     'noStoragePermission': 'சேமிப்பக அனுமதி தேவை',
@@ -63,16 +64,16 @@ const taTA = {
     'show': 'காட்டு',
     'startAll': 'அனைத்தையும் தொடங்கு',
     'pauseAll': 'அனைத்தையும் நிறுத்திவை',
-    'deleteTask': 'பணிகளை நீக்கு @count',
+    'deleteTask': 'பணியை நீக்கு',
     'deleteTaskTip': 'பதிவிறக்கம் செய்யப்பட்ட கோப்புகளை வைத்திரு',
     'delete': 'நீக்கு',
     'newVersionTitle': 'புதிய பதிப்பைக் கண்டறியவும் @version',
-    'newVersionUpdate': 'இப்பொழுது புதுப்பி',
+    'newVersionUpgrade': 'இப்பொழுது புதுப்பி',
     'newVersionLater': 'பின்னர்',
     'extensions': 'நீட்டிப்புகள்',
     'extensionInstallUrl': 'நிறுவப்படும் URL',
     'extensionInstallSuccess': 'வெற்றிகரமாக நிறுவப்பட்டது',
-    'extensionUpdateSuccess': 'வெற்றிகரமாக புதுப்பிக்கப்பட்டது',
+    'extensionUpgradeSuccess': 'வெற்றிகரமாக புதுப்பிக்கப்பட்டது',
     'extensionDelete': 'நீட்டிப்பை நீக்கு',
     'extensionAlreadyLatest': 'இது ஏற்கனவே சமீபத்திய பதிப்பாகும்',
     'extensionFind': 'நீட்டிப்புகளைக் கண்டறியவும்',

ui/flutter/lib/i18n/langs/tr_tr.dart

@@ -20,8 +20,10 @@ const trTR = {
     'followSettings': 'Ayarları takip et',
     'downloadLink': 'İndirme bağlantısı',
     'downloadLinkValid': 'Lütfen indirme bağlantısını girin',
-    'downloadLinkHit': 'Lütfen indirme bağlantısını girin, HTTP/HTTPS/MAGNET desteklenir@append',
-    'downloadLinkHitDesktop': ', veya torrent dosyasını doğrudan buraya sürükleyin',
+    'downloadLinkHit':
+        'Lütfen indirme bağlantısını girin, HTTP/HTTPS/MAGNET desteklenir@append',
+    'downloadLinkHitDesktop':
+        ', veya torrent dosyasını doğrudan buraya sürükleyin',
     'download': 'İndir',
     'noFileSelected': 'Devam etmek için lütfen en az bir dosya seçin.',
     'noStoragePermission': 'Depolama izni gerekli',
@@ -38,12 +40,14 @@ const trTR = {
     'defaultDirectDownload': 'Doğrudan indir seçili olsun',
     'items': '@count tane',
     'subscribeTracker': 'İzleyiciye abone ol',
-    'subscribeFail': 'Abone olunamadı, lütfen ağı kontrol edin veya daha sonra tekrar deneyin',
+    'subscribeFail':
+        'Abone olunamadı, lütfen ağı kontrol edin veya daha sonra tekrar deneyin',
     'update': 'Güncelle',
     'updateDaily': 'Günlük olarak güncelle',
     'lastUpdate': 'Son güncellenme tarihi: @time',
     'addTracker': 'İzleyici ekle',
-    'addTrackerHit': 'Lütfen her satıra bir tane olmak üzere izleyici sunucusu bağlantısını girin',
+    'addTrackerHit':
+        'Lütfen her satıra bir tane olmak üzere izleyici sunucusu bağlantısını girin',
     'ui': 'Arayüz',
     'theme': 'Tema',
     'themeSystem': 'Sistem',
@@ -58,23 +62,24 @@ const trTR = {
     'apiToken': 'API anahtarı',
     'notSet': 'AYARLI DEĞİL',
     'set': 'AYARLI',
-    'portInUse': 'Bağlantı noktası [@port] kullanımda, lütfen bağlantı noktasını değiştirin',
+    'portInUse':
+        'Bağlantı noktası [@port] kullanımda, lütfen bağlantı noktasını değiştirin',
     'effectAfterRestart': 'Yeniden başlatma sonrası etki edecektir',
     'developer': 'Geliştirici',
     'logDirectory': 'Kayıt dizini',
     'show': 'Göster',
     'startAll': 'Hepsini başlat',
     'pauseAll': 'Hepsini durdur',
-    'deleteTask': '@count görevi sil',
+    'deleteTask': 'Görevleri sil',
     'deleteTaskTip': 'İndirilen dosyaları sakla',
     'delete': 'Sil',
     'newVersionTitle': 'Yeni sürümü keşfet @version',
-    'newVersionUpdate': 'Şimdi güncelle',
+    'newVersionUpgrade': 'Şimdi güncelle',
     'newVersionLater': 'Sonra',
     'extensions': 'Uzantılar',
     'extensionInstallUrl': 'İndirme bağlantısı',
     'extensionInstallSuccess': 'Başarıyla indirildi',
-    'extensionUpdateSuccess': 'Başarıyla güncellendi',
+    'extensionUpgradeSuccess': 'Başarıyla güncellendi',
     'extensionDelete': 'Uzantıyı sil',
     'extensionAlreadyLatest': 'Bu zaten en son sürüm',
     'extensionFind': 'Uzantı ara',
@@ -93,7 +98,8 @@ const trTR = {
     'username': 'Kullanıcı adı',
     'password': 'Şifre',
     'thanks': 'Teşekkürler',
-    'thanksDesc': 'Gopeed topluluğunun oluşmasına ve gelişmesine yardımcı olan tüm katılımcılara teşekkürler!',
+    'thanksDesc':
+        'Gopeed topluluğunun oluşmasına ve gelişmesine yardımcı olan tüm katılımcılara teşekkürler!',
     'browserExtension': 'Tarayıcı uzantısı',
     'launchAtStartup': 'Başlangıçta başlat',
     'seedConfig': 'Seed ayarları',