├── errors.go
├── test_types
    └── config.go
├── .idea
    ├── vcs.xml
    └── .gitignore
├── DEV_README.md
├── Makefile
├── go.mod
├── logging.go
├── LICENSE
├── feed_online_test.go
├── wss_online_test.go
├── feed.go
├── .gitignore
├── options.go
├── live_online_test.go
├── go.sum
├── http_proxy.go
├── const.go
├── requests.go
├── tiktok_online_test.go
├── proto
    ├── enums.proto
    ├── webcast.proto
    └── data.proto
├── wss.go
├── tiktok.go
├── utils.go
├── live.go
├── README.md
└── types.go


/errors.go:
--------------------------------------------------------------------------------
1 | package gotiktoklive
2 | 
3 | type UserNotFound struct{}
4 | 
5 | func (u UserNotFound) Error() string {
6 | 	return "User not found"
7 | }
8 | 


--------------------------------------------------------------------------------
/test_types/config.go:
--------------------------------------------------------------------------------
1 | package test_types
2 | 
3 | const (
4 | 	USERNAME       = "judas_risen"
5 | 	APIKEY         = ""
6 | 	PROXY          = ""
7 | 	PROXY_INSECURE = true
8 | )
9 | 


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 | 


--------------------------------------------------------------------------------
/DEV_README.md:
--------------------------------------------------------------------------------
1 | ## Generating Protobuf
2 | ```bash
3 | protoc --go_out=. -I .\proto --go-grpc_out=. .\proto\enums.proto
4 | protoc --go_out=. -I .\proto --go-grpc_out=. .\proto\data.proto
5 | protoc --go_out=. -I .\proto  --go-grpc_out=. .\proto\webcast.proto
6 | ```
7 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | GOPATH:=$(shell go env GOPATH)
 2 | 
 3 | .PHONY: init
 4 | init:
 5 | 	@go get -u google.golang.org/protobuf/proto
 6 | 	@go install github.com/golang/protobuf/protoc-gen-go@latest
 7 | 
 8 | .PHONY: proto
 9 | proto:
10 | 	@protoc \
11 | 		--proto_path=. \
12 | 		--go_out=:. \
13 | 		proto/tiktok.proto
14 | 
15 | .PHONY: update
16 | update:
17 | 	@go get -u
18 | 
19 | .PHONY: tidy
20 | tidy:
21 | 	@go mod tidy
22 | 
23 | .PHONY: test
24 | test:
25 | 	@go test -v ./... -cover -coverprofile coverage.out -count=1
26 | 
27 | .PHONY: cov
28 | cov:
29 | 	@gocovsh --profile coverage.out
30 | 
31 | 
32 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/steampoweredtaco/gotiktoklive
 2 | 
 3 | go 1.23.0
 4 | 
 5 | require (
 6 | 	github.com/erni27/imcache v1.2.1
 7 | 	github.com/gobwas/ws v1.1.0
 8 | 	github.com/stretchr/testify v1.9.0
 9 | 	go.uber.org/ratelimit v0.3.1
10 | )
11 | 
12 | retract (
13 | 	v1.0.8 // retration only update.
14 | 	v1.0.7 // Published accidently.
15 | )
16 | 
17 | require (
18 | 	github.com/benbjohnson/clock v1.3.0 // indirect
19 | 	github.com/davecgh/go-spew v1.1.1 // indirect
20 | 	github.com/google/go-cmp v0.6.0 // indirect
21 | 	github.com/pmezard/go-difflib v1.0.0 // indirect
22 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
23 | )
24 | 
25 | require (
26 | 	github.com/gobwas/httphead v0.1.0 // indirect
27 | 	github.com/gobwas/pool v0.2.1 // indirect
28 | 	github.com/pkg/errors v0.9.1
29 | 	golang.org/x/net v0.25.0
30 | 	golang.org/x/sys v0.20.0 // indirect
31 | 	google.golang.org/protobuf v1.33.0
32 | )
33 | 


--------------------------------------------------------------------------------
/logging.go:
--------------------------------------------------------------------------------
 1 | package gotiktoklive
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"log/slog"
 6 | 	"net/http"
 7 | 	"net/http/httputil"
 8 | 	"strings"
 9 | )
10 | 
11 | type loggingTransport struct {
12 | 	Transport http.RoundTripper
13 | }
14 | 
15 | func (s *loggingTransport) RoundTrip(r *http.Request) (*http.Response, error) {
16 | 	bytes, _ := httputil.DumpRequestOut(r, true)
17 | 
18 | 	resp, err := s.Transport.RoundTrip(r)
19 | 	// err is returned after dumping the response
20 | 	if err != nil && strings.Contains(err.Error(), "malformed HTTP response") {
21 | 		httputil.DumpResponse(resp, false)
22 | 		slog.Debug(fmt.Sprintf("%s\n", bytes))
23 | 		return resp, err
24 | 	}
25 | 	if resp == nil {
26 | 		return resp, err
27 | 	}
28 | 	respBytes, _ := httputil.DumpResponse(resp, true)
29 | 	bytes = append(bytes, respBytes...)
30 | 
31 | 	slog.Debug(fmt.Sprintf("%s\n", bytes))
32 | 
33 | 	return resp, err
34 | }
35 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Ahmadreza Zibaei
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/feed_online_test.go:
--------------------------------------------------------------------------------
 1 | //go:build requiresOnline
 2 | 
 3 | package gotiktoklive
 4 | 
 5 | import (
 6 | 	"github.com/stretchr/testify/assert"
 7 | 	"sort"
 8 | 	"testing"
 9 | )
10 | 
11 | func TestFeedItem(t *testing.T) {
12 | 	tiktok, err := NewTikTok()
13 | 	if !assert.NoError(t, err) {
14 | 		return
15 | 	}
16 | 	feed := tiktok.NewFeed()
17 | 
18 | 	items := []*LiveStream{}
19 | 	i := 0
20 | 	for {
21 | 		feedItem, err := feed.Next()
22 | 		if err != nil {
23 | 			t.Fatal(err)
24 | 		}
25 | 		items = append(items, feedItem.LiveStreams...)
26 | 		i++
27 | 		t.Logf("%d : %d, %v", feedItem.Extra.MaxTime, len(feedItem.LiveStreams), feedItem.Extra.HasMore)
28 | 		for _, stream := range feedItem.LiveStreams {
29 | 			t.Logf("%s : %d viewers, %s", stream.Room.Owner.Nickname, stream.Room.UserCount, stream.LiveReason)
30 | 		}
31 | 
32 | 		if !feedItem.Extra.HasMore || i > 5 {
33 | 			break
34 | 		}
35 | 	}
36 | 	t.Logf("Found %d items, over %d requests", len(items), i)
37 | 
38 | 	sort.Slice(items, func(i, j int) bool {
39 | 		return items[i].Room.UserCount > items[j].Room.UserCount
40 | 	})
41 | 
42 | 	t.Logf("Setting username to %s", items[0].Room.Owner.Username)
43 | }
44 | 


--------------------------------------------------------------------------------
/wss_online_test.go:
--------------------------------------------------------------------------------
 1 | //go:build requiresOnline
 2 | 
 3 | package gotiktoklive
 4 | 
 5 | import (
 6 | 	"github.com/stretchr/testify/assert"
 7 | 	"sync"
 8 | 	"testing"
 9 | 	"time"
10 | 
11 | 	"github.com/steampoweredtaco/gotiktoklive/test_types"
12 | 	"golang.org/x/net/context"
13 | )
14 | 
15 | func TestWebsocket(t *testing.T) {
16 | 	tiktok, err := NewTikTok()
17 | 	if !assert.NoError(t, err) {
18 | 		return
19 | 	}
20 | 	tiktok.Debug = true
21 | 	tiktok.debugHandler = func(i ...interface{}) {
22 | 		t.Log(i...)
23 | 	}
24 | 	id, err := tiktok.getRoomID(test_types.USERNAME)
25 | 	if !assert.NoError(t, err) {
26 | 		return
27 | 	}
28 | 
29 | 	live := Live{
30 | 		t:      tiktok,
31 | 		ID:     id,
32 | 		wg:     &sync.WaitGroup{},
33 | 		Events: make(chan Event, 100),
34 | 	}
35 | 
36 | 	ctx, cancel := context.WithCancel(context.Background())
37 | 	live.done = ctx.Done
38 | 	live.close = func() {
39 | 		cancel()
40 | 		close(live.Events)
41 | 	}
42 | 
43 | 	err = live.getRoomData()
44 | 	if !assert.NoError(t, err) {
45 | 		return
46 | 	}
47 | 
48 | 	if live.wsURL == "" {
49 | 		t.Fatal("No websocket url provided")
50 | 	}
51 | 	t.Logf("Ws url: %s, %+v", live.wsURL, live.wsParams)
52 | 
53 | 	if err := live.connect(live.wsURL, live.wsParams); err != nil {
54 | 		t.Fatal(err)
55 | 	}
56 | 
57 | 	tiktok.wg.Add(2)
58 | 	go live.readSocket()
59 | 	go live.sendPing()
60 | 
61 | 	timeout := time.After(5 * time.Second)
62 | 	for {
63 | 		select {
64 | 		case <-timeout:
65 | 			return
66 | 		case event := <-live.Events:
67 | 			switch e := event.(type) {
68 | 			case UserEvent:
69 | 				t.Logf("%T: %s (%s) %s", e, e.User.Nickname, e.User.Nickname, e.Event)
70 | 			default:
71 | 				t.Logf("%T: %+v", e, e)
72 | 			}
73 | 		}
74 | 	}
75 | }
76 | 


--------------------------------------------------------------------------------
/feed.go:
--------------------------------------------------------------------------------
 1 | package gotiktoklive
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"strconv"
 6 | )
 7 | 
 8 | // Feed allows you to fetch reccomended livestreams.
 9 | type Feed struct {
10 | 	t *TikTok
11 | 
12 | 	// All collected reccomended livestreams
13 | 	LiveStreams []*LiveStream
14 | 
15 | 	HasMore bool
16 | 	maxTime int64
17 | }
18 | 
19 | // NewFeed creates a new Feed instance. Start fetching recommended livestreams
20 | // with Feed.Next().
21 | func (t *TikTok) NewFeed() *Feed {
22 | 	return &Feed{
23 | 		t:           t,
24 | 		LiveStreams: []*LiveStream{},
25 | 		HasMore:     true,
26 | 	}
27 | }
28 | 
29 | // Next fetches the next couple of recommended live streams, if available.
30 | // You can call this as long as Feed.HasMore = true. All items will be added
31 | //
32 | //	to the Feed.LiveStreams list.
33 | func (f *Feed) Next() (*FeedItem, error) {
34 | 	if !f.HasMore {
35 | 		return nil, ErrNoMoreFeedItems
36 | 	}
37 | 
38 | 	params := copyMap(defaultGETParams)
39 | 	params["channel"] = "tiktok_web"
40 | 	params["channel_id"] = "86"
41 | 	if f.maxTime != 0 {
42 | 		params["max_time"] = strconv.FormatInt(f.maxTime, 10)
43 | 	}
44 | 
45 | 	body, _, err := f.t.sendRequest(&reqOptions{
46 | 		Endpoint: urlFeed,
47 | 		Query:    params,
48 | 	}, nil)
49 | 	if err != nil {
50 | 		return nil, err
51 | 	}
52 | 
53 | 	var rsp FeedItem
54 | 	if err := json.Unmarshal(body, &rsp); err != nil {
55 | 		return nil, err
56 | 	}
57 | 
58 | 	f.HasMore = rsp.Extra.HasMore
59 | 	f.maxTime = rsp.Extra.MaxTime
60 | 	for _, s := range rsp.LiveStreams {
61 | 		s.t = f.t
62 | 	}
63 | 
64 | 	return &rsp, nil
65 | }
66 | 
67 | // Track stars tracking the livestream obtained from the Feed, and returns
68 | // a Live instance, just as if you would start tracking the user with
69 | // tiktok.TrackUser(<user>).
70 | func (s *LiveStream) Track() (*Live, error) {
71 | 	return s.t.TrackRoom(s.Rid)
72 | }
73 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Created by https://www.toptal.com/developers/gitignore/api/goland+iml
 2 | # Edit at https://www.toptal.com/developers/gitignore?templates=goland+iml
 3 | 
 4 | ### GoLand+iml ###
 5 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
 6 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 7 | 
 8 | # User-specific stuff
 9 | .idea/**/workspace.xml
10 | .idea/**/tasks.xml
11 | .idea/**/usage.statistics.xml
12 | .idea/**/dictionaries
13 | .idea/**/shelf
14 | 
15 | # AWS User-specific
16 | .idea/**/aws.xml
17 | 
18 | # Generated files
19 | .idea/**/contentModel.xml
20 | 
21 | # Sensitive or high-churn files
22 | .idea/**/dataSources/
23 | .idea/**/dataSources.ids
24 | .idea/**/dataSources.local.xml
25 | .idea/**/sqlDataSources.xml
26 | .idea/**/dynamic.xml
27 | .idea/**/uiDesigner.xml
28 | .idea/**/dbnavigator.xml
29 | 
30 | # Gradle
31 | .idea/**/gradle.xml
32 | .idea/**/libraries
33 | 
34 | # Gradle and Maven with auto-import
35 | # When using Gradle or Maven with auto-import, you should exclude module files,
36 | # since they will be recreated, and may cause churn.  Uncomment if using
37 | # auto-import.
38 | # .idea/artifacts
39 | # .idea/compiler.xml
40 | # .idea/jarRepositories.xml
41 | # .idea/modules.xml
42 | # .idea/*.iml
43 | # .idea/modules
44 | # *.iml
45 | # *.ipr
46 | 
47 | # CMake
48 | cmake-build-*/
49 | 
50 | # Mongo Explorer plugin
51 | .idea/**/mongoSettings.xml
52 | 
53 | # File-based project format
54 | *.iws
55 | 
56 | # IntelliJ
57 | out/
58 | 
59 | # mpeltonen/sbt-idea plugin
60 | .idea_modules/
61 | 
62 | # JIRA plugin
63 | atlassian-ide-plugin.xml
64 | 
65 | # Cursive Clojure plugin
66 | .idea/replstate.xml
67 | 
68 | # SonarLint plugin
69 | .idea/sonarlint/
70 | 
71 | # Crashlytics plugin (for Android Studio and IntelliJ)
72 | com_crashlytics_export_strings.xml
73 | crashlytics.properties
74 | crashlytics-build.properties
75 | fabric.properties
76 | 
77 | # Editor-based Rest Client
78 | .idea/httpRequests
79 | 
80 | # Android studio 3.1+ serialized cache file
81 | .idea/caches/build_file_checksums.ser
82 | 
83 | ### GoLand+iml Patch ###
84 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
85 | 
86 | *.iml
87 | modules.xml
88 | .idea/misc.xml
89 | *.ipr
90 | 
91 | # End of https://www.toptal.com/developers/gitignore/api/goland+iml
92 | 
93 | vendor/


--------------------------------------------------------------------------------
/options.go:
--------------------------------------------------------------------------------
 1 | package gotiktoklive
 2 | 
 3 | import "net/http"
 4 | 
 5 | type TikTokLiveOption func(t *TikTok) error
 6 | 
 7 | // SigningApiKey sets the singer API key.
 8 | func SigningApiKey(apiKey string) TikTokLiveOption {
 9 | 	return func(t *TikTok) error {
10 | 		t.apiKey = apiKey
11 | 		return nil
12 | 	}
13 | }
14 | 
15 | // SigningUrl defines the signer. The default is https://tiktok.eulerstream.com. Supports any signer that supports the
16 | // signing api as defined by https://www.eulerstream.com/docs/openapi
17 | func SigningUrl(url string) TikTokLiveOption {
18 | 	return func(t *TikTok) error {
19 | 		t.signerUrl = url
20 | 		return nil
21 | 	}
22 | }
23 | 
24 | // DisableSigningLimitsValidation will disable querying the signer for limits and using those as the reasonable limits
25 | // for signing requests per second. Instead, this library will be limited to signing only 5 signing requests per minute
26 | // and may limit functionality compared to the request limit the signer provides.
27 | func DisableSigningLimitsValidation(t *TikTok) error {
28 | 	t.getLimits = false
29 | 	return nil
30 | }
31 | 
32 | // EnableExperimentalEvents enables experimental events that have not been figured out yet and the API for them is not
33 | // stable. It may also induce additional logging that might be undesirable.
34 | func EnableExperimentalEvents(t *TikTok) error {
35 | 	t.enableExperimentalEvents = true
36 | 	return nil
37 | }
38 | 
39 | // EnableExtraWebCastDebug an unreasonable amount of debug for library development and troubleshooting. This option
40 | // makes no guarantee of ever having the same output and is only for development and triage purposes.
41 | func EnableExtraWebCastDebug(t *TikTok) error {
42 | 	t.enableExtraDebug = true
43 | 	t.c.Transport = &loggingTransport{Transport: http.DefaultTransport}
44 | 	return nil
45 | }
46 | 
47 | // EnableWSTrace will put traces for all websocket messages into the given file. The file will be overwritten so
48 | // if you want multiple traces make sure handle giving a unique filename each startup.
49 | func EnableWSTrace(file string) TikTokLiveOption {
50 | 	return func(t *TikTok) error {
51 | 		t.enableWSTrace = true
52 | 		t.wsTraceFile = file
53 | 		t.wsTraceChan = make(chan struct{ direction, hex string }, 50)
54 | 		return nil
55 | 	}
56 | }
57 | 
58 | // Proxy will set a proxy for both the http client and the websocket. You can
59 | // manually set a proxy with option or by using the HTTPS_PROXY environment variable.
60 | // ALL_PROXY can be used to set a proxy only for the websocket.
61 | func Proxy(url string, insecure bool) TikTokLiveOption {
62 | 	if url == "" {
63 | 		return func(t *TikTok) error {
64 | 			return nil
65 | 		}
66 | 	}
67 | 	return func(t *TikTok) error {
68 | 		return t.setProxy(url, insecure)
69 | 	}
70 | }
71 | 


--------------------------------------------------------------------------------
/live_online_test.go:
--------------------------------------------------------------------------------
  1 | //go:build requiresOnline
  2 | 
  3 | package gotiktoklive
  4 | 
  5 | import (
  6 | 	"log/slog"
  7 | 	"testing"
  8 | 	"time"
  9 | 
 10 | 	"github.com/steampoweredtaco/gotiktoklive/test_types"
 11 | )
 12 | 
 13 | func TestLiveTrackUser(t *testing.T) {
 14 | 	tiktok, err := NewTikTok()
 15 | 	if err != nil {
 16 | 		t.Fatal(err)
 17 | 	}
 18 | 	live, err := tiktok.TrackUser(test_types.USERNAME)
 19 | 	if err != nil {
 20 | 		t.Fatal(err)
 21 | 	}
 22 | 
 23 | 	timeout := time.After(5 * time.Second)
 24 | 
 25 | 	eventCounter := 0
 26 | 	for {
 27 | 		select {
 28 | 		case event := <-live.Events:
 29 | 			t.Logf("%T", event)
 30 | 			eventCounter++
 31 | 		case <-timeout:
 32 | 			if eventCounter < 10 {
 33 | 				t.Fatal("Less than 10 events received.. Something seems off")
 34 | 			}
 35 | 			return
 36 | 		}
 37 | 	}
 38 | }
 39 | 
 40 | func TestLivePriceList(t *testing.T) {
 41 | 	tiktok, err := NewTikTok()
 42 | 	if err != nil {
 43 | 		t.Fatal(err)
 44 | 	}
 45 | 	priceList, err := tiktok.GetPriceList()
 46 | 	if err != nil {
 47 | 		t.Fatal(err)
 48 | 	}
 49 | 
 50 | 	t.Logf("Fetched %d prices", len(priceList.PriceList))
 51 | }
 52 | 
 53 | func TestLiveDownload(t *testing.T) {
 54 | 	slog.SetLogLoggerLevel(slog.LevelDebug)
 55 | 	tiktok, err := NewTikTok(SigningApiKey(test_types.APIKEY))
 56 | 	if err != nil {
 57 | 		t.Fatal(err)
 58 | 	}
 59 | 	live, err := tiktok.TrackUser(test_types.USERNAME)
 60 | 	if err != nil {
 61 | 		t.Fatal(err)
 62 | 	}
 63 | 	done := make(chan struct{})
 64 | 	go func() {
 65 | 		defer func() {
 66 | 			done <- struct{}{}
 67 | 		}()
 68 | 		err = live.DownloadStream()
 69 | 		if err != nil {
 70 | 			t.Fatal(err)
 71 | 		}
 72 | 	}()
 73 | 
 74 | 	select {
 75 | 	case _ = <-done:
 76 | 		t.Log("command exited")
 77 | 	case <-time.After(12 * time.Second):
 78 | 		t.Log("test complete")
 79 | 	}
 80 | 	live.Close()
 81 | 
 82 | 	live, err = tiktok.TrackUser(test_types.USERNAME)
 83 | 	if err != nil {
 84 | 		t.Fatal(err)
 85 | 	}
 86 | 
 87 | 	done = make(chan struct{})
 88 | 	go func() {
 89 | 		defer func() {
 90 | 			done <- struct{}{}
 91 | 		}()
 92 | 		err = live.DownloadStream("my-test-download.mkv")
 93 | 		if err != nil {
 94 | 			t.Fatal(err)
 95 | 		}
 96 | 	}()
 97 | 	select {
 98 | 	case _ = <-done:
 99 | 		t.Log("command exited")
100 | 	case <-time.After(4 * time.Hour):
101 | 		t.Log("test complete")
102 | 	}
103 | 	live.Close()
104 | }
105 | 
106 | // func TestRankList(t *testing.T) {
107 | // 	tiktok := gotiktoklive.NewTikTok()
108 | // 	live, err := tiktok.TrackUser(USERNAME)
109 | // 	if err != nil {
110 | // 		t.Fatal(err)
111 | // 	}
112 | //
113 | // 	tiktok.LogRequests = true
114 | // 	rankList, err := live.GetRankList()
115 | // 	if err != nil {
116 | // 		t.Fatal(err)
117 | // 	}
118 | //
119 | // 	if len(rankList.Ranks) == 0 {
120 | // 		t.Fatal("No ranked users found")
121 | // 	}
122 | //
123 | // 	topUser := rankList.Ranks[0]
124 | // 	t.Logf("Top user (%s) has donated %d coins", topUser.User.Nickname, topUser.Score)
125 | // }
126 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A=
 2 | github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 4 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 5 | github.com/erni27/imcache v1.2.1 h1:hDPesOxGMO8tV+wAUVsC2KVPB3BPjXS2xP+PgdevbRc=
 6 | github.com/erni27/imcache v1.2.1/go.mod h1:KNUCBr1U9nOFTyUEC9CsMKZE33NboYTPavsQsuEufoA=
 7 | github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 8 | github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 9 | github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
10 | github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
11 | github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
12 | github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
13 | github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
14 | github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
15 | github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
16 | github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
17 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
18 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
19 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
20 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
21 | go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
22 | go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
23 | go.uber.org/ratelimit v0.3.1 h1:K4qVE+byfv/B3tC+4nYWP7v/6SimcO7HzHekoMNBma0=
24 | go.uber.org/ratelimit v0.3.1/go.mod h1:6euWsTB6U/Nb3X++xEUXA8ciPJvr19Q/0h1+oDcJhRk=
25 | golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
26 | golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
27 | golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
28 | golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
29 | golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
30 | google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
31 | google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
32 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
33 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
34 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
35 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
36 | 


--------------------------------------------------------------------------------
/http_proxy.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | // Copied from: https://gist.github.com/jim3ma/3750675f141669ac4702bc9deaf31c6b
  4 | 
  5 | import (
  6 | 	"bufio"
  7 | 	"crypto/tls"
  8 | 	"fmt"
  9 | 	"net"
 10 | 	"net/http"
 11 | 	"net/url"
 12 | 
 13 | 	"golang.org/x/net/proxy"
 14 | )
 15 | 
 16 | type direct struct{}
 17 | 
 18 | // Direct is a direct proxy: one that makes network connections directly.
 19 | var Direct = direct{}
 20 | 
 21 | func (direct) Dial(network, addr string) (net.Conn, error) {
 22 | 	return net.Dial(network, addr)
 23 | }
 24 | 
 25 | // httpsDialer
 26 | type httpsDialer struct{}
 27 | 
 28 | // HTTPSDialer is a https proxy: one that makes network connections on tls.
 29 | var HttpsDialer = httpsDialer{}
 30 | var TlsConfig = &tls.Config{}
 31 | 
 32 | func (d httpsDialer) Dial(network, addr string) (c net.Conn, err error) {
 33 | 	c, err = tls.Dial("tcp", addr, TlsConfig)
 34 | 	if err != nil {
 35 | 		fmt.Println(err)
 36 | 	}
 37 | 	return
 38 | }
 39 | 
 40 | // httpProxy is a HTTP/HTTPS connect proxy.
 41 | type httpProxy struct {
 42 | 	host     string
 43 | 	haveAuth bool
 44 | 	username string
 45 | 	password string
 46 | 	forward  proxy.Dialer
 47 | }
 48 | 
 49 | func newHTTPProxy(uri *url.URL, forward proxy.Dialer) (proxy.Dialer, error) {
 50 | 	s := new(httpProxy)
 51 | 	s.host = uri.Host
 52 | 	s.forward = forward
 53 | 	if uri.User != nil {
 54 | 		s.haveAuth = true
 55 | 		s.username = uri.User.Username()
 56 | 		s.password, _ = uri.User.Password()
 57 | 	}
 58 | 
 59 | 	return s, nil
 60 | }
 61 | 
 62 | func (s *httpProxy) Dial(network, addr string) (net.Conn, error) {
 63 | 	// Dial and create the https client connection.
 64 | 	c, err := s.forward.Dial("tcp", s.host)
 65 | 	if err != nil {
 66 | 		return nil, err
 67 | 	}
 68 | 
 69 | 	// HACK. http.ReadRequest also does this.
 70 | 	reqURL, err := url.Parse("http://" + addr)
 71 | 	if err != nil {
 72 | 		c.Close()
 73 | 		return nil, err
 74 | 	}
 75 | 	reqURL.Scheme = ""
 76 | 
 77 | 	req, err := http.NewRequest("CONNECT", reqURL.String(), nil)
 78 | 	if err != nil {
 79 | 		c.Close()
 80 | 		return nil, err
 81 | 	}
 82 | 	req.Close = false
 83 | 	if s.haveAuth {
 84 | 		req.SetBasicAuth(s.username, s.password)
 85 | 	}
 86 | 	// req.Header.Set("User-Agent", "Powerby Gota")
 87 | 
 88 | 	err = req.Write(c)
 89 | 	if err != nil {
 90 | 		c.Close()
 91 | 		return nil, err
 92 | 	}
 93 | 
 94 | 	resp, err := http.ReadResponse(bufio.NewReader(c), req)
 95 | 	if err != nil {
 96 | 		// TODO close resp body ?
 97 | 		resp.Body.Close()
 98 | 		c.Close()
 99 | 		return nil, err
100 | 	}
101 | 	resp.Body.Close()
102 | 	if resp.StatusCode != 200 {
103 | 		c.Close()
104 | 		err = fmt.Errorf("Connect server using proxy error, StatusCode [%d]", resp.StatusCode)
105 | 		return nil, err
106 | 	}
107 | 
108 | 	return c, nil
109 | }
110 | 
111 | func FromURL(u *url.URL, forward proxy.Dialer) (proxy.Dialer, error) {
112 | 	return proxy.FromURL(u, forward)
113 | }
114 | 
115 | func FromEnvironment() proxy.Dialer {
116 | 	return proxy.FromEnvironment()
117 | }
118 | 
119 | func init() {
120 | 	proxy.RegisterDialerType("http", newHTTPProxy)
121 | 	proxy.RegisterDialerType("https", newHTTPProxy)
122 | }
123 | 


--------------------------------------------------------------------------------
/const.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"regexp"
  6 | )
  7 | 
  8 | const (
  9 | 	// Base URL
 10 | 	tiktokBaseUrl = "https://www.tiktok.com/"
 11 | 	tiktokAPIUrl  = "https://webcast.tiktok.com/webcast/"
 12 | 
 13 | 	// Endpoints
 14 | 	urlLive      = "live/"
 15 | 	urlFeed      = "feed/"
 16 | 	urlRankList  = "ranklist/online_audience/"
 17 | 	urlPriceList = "wallet_api/fs/diamond"
 18 | 	urlUser      = "@%s/"
 19 | 	// Think this changed to room/enter/
 20 | 	urlRoomInfo = "room/info/"
 21 | 	urlRoomData = "webcast/fetch/"
 22 | 	urlGiftInfo = "gift/list/"
 23 | 	// added slash is intention to simplify the base signer url which is now configurable.
 24 | 	urlSignReq = "/webcast/fetch/"
 25 | 
 26 | 	urlCheckLive      = "room/check_alive/"
 27 | 	clientNameDefault = "gotiktok_live"
 28 | 	apiKeyDefault     = ""
 29 | 	// For some reason the user info needs user agent this way but wsUserAgent doesn't want it
 30 | 	userAgent   = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36"
 31 | 	wsUserAgent = "5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36"
 32 | 	referer     = "https://www.tiktok.com/"
 33 | 	// webcast backend will fail if origin is an ending /
 34 | 	origin = "https://www.tiktok.com"
 35 | )
 36 | 
 37 | var (
 38 | 	// Used for webcast messages that don't require anything fancy
 39 | 	minGetParams = map[string]string{
 40 | 		"aid":          "1988",
 41 | 		"app_language": "en-US",
 42 | 		"app_name":     "tiktok_web",
 43 | 	}
 44 | 	defaultGETParams = map[string]string{
 45 | 		"aid":                 "1988",
 46 | 		"app_language":        "en-US",
 47 | 		"app_name":            "tiktok_web",
 48 | 		"browser_language":    "en",
 49 | 		"browser_name":        "Mozilla",
 50 | 		"browser_online":      "true",
 51 | 		"browser_platform":    "Win32",
 52 | 		"browser_version":     userAgent,
 53 | 		"cookie_enabled":      "true",
 54 | 		"cursor":              "",
 55 | 		"internal_ext":        "",
 56 | 		"device_platform":     "web",
 57 | 		"focus_state":         "true",
 58 | 		"from_page":           "user",
 59 | 		"history_len":         "4",
 60 | 		"is_fullscreen":       "false",
 61 | 		"is_page_visible":     "true",
 62 | 		"did_rule":            "3",
 63 | 		"fetch_rule":          "1",
 64 | 		"last_rtt":            "0",
 65 | 		"live_id":             "12",
 66 | 		"resp_content_type":   "protobuf",
 67 | 		"screen_height":       "1152",
 68 | 		"screen_width":        "2048",
 69 | 		"tz_name":             "Europe/Berlin",
 70 | 		"referer":             referer,
 71 | 		"root_referer":        origin,
 72 | 		"msToken":             "",
 73 | 		"version_code":        "180800",
 74 | 		"webcast_sdk_version": "1.3.0",
 75 | 		"update_version_code": "1.3.0",
 76 | 	}
 77 | 	defaultRequestHeaders = map[string]string{
 78 | 		"Connection":    "keep-alive",
 79 | 		"Cache-control": "max-age=0",
 80 | 		"User-Agent":    userAgent,
 81 | 		"Accept":        "text/html,application/json,application/protobuf",
 82 | 		"Referer":       referer,
 83 | 		"Origin":        origin,
 84 | 		// clientId:  = "ttlive-golang"
 85 | 		"Accept-Language": "en-US,en;q=0.9",
 86 | 		"Accept-Encoding": "gzip, deflate",
 87 | 	}
 88 | 	wsOverrideHeaders = map[string]string{
 89 | 		"User-Agent": wsUserAgent,
 90 | 	}
 91 | 	reJsonData = []*regexp.Regexp{
 92 | 		regexp.MustCompile(`<script id="SIGI_STATE"[^>]+>(.*?)</script>`),
 93 | 		regexp.MustCompile(`<script id="sigi-persisted-data">window\['SIGI_STATE'\]=(.*);w`),
 94 | 	}
 95 | 	reVerify = regexp.MustCompile(`tiktok-verify-page`)
 96 | )
 97 | 
 98 | var (
 99 | 	ErrUserOffline       = errors.New("user might be offline, Room ID not found")
100 | 	ErrLiveHasEnded      = errors.New("livestream has ended")
101 | 	ErrMsgNotImplemented = errors.New("message protobuf type has not been implemented, please report")
102 | 	ErrNoMoreFeedItems   = errors.New("no more feed items available")
103 | 	ErrUserNotFound      = errors.New("user not found")
104 | 	ErrCaptcha           = errors.New("captcha detected, unable to proceed")
105 | 	ErrURLNotFound       = errors.New("unable to download stream, URL not found")
106 | 	ErrFFMPEGNotFound    = errors.New("please install ffmpeg before downloading")
107 | 	ErrRateLimitExceeded = errors.New("you have exceeded the rate limit, please wait a few min")
108 | 	ErrUserInfoNotFound  = errors.New("user info not found")
109 | )
110 | 
111 | type ErrIPBlockedOrBanned struct{}
112 | 
113 | func (e ErrIPBlockedOrBanned) Error() string {
114 | 	return "your IP or country might be blocked by TikTok or Signer service or you might be banned, please try again with a vpn, proxy, or different credentials"
115 | }
116 | 


--------------------------------------------------------------------------------
/requests.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"compress/gzip"
  6 | 	"encoding/json"
  7 | 	"fmt"
  8 | 	"io"
  9 | 	"net/http"
 10 | 	"net/url"
 11 | )
 12 | 
 13 | type reqOptions struct {
 14 | 	// Endpoint is the request path of tiktok api
 15 | 	Endpoint string
 16 | 
 17 | 	// IsPost set to true will send request with POST method.
 18 | 	//
 19 | 	// By default this option is false.
 20 | 	IsPost bool
 21 | 
 22 | 	// Compress post form data with gzip
 23 | 	Gzip bool
 24 | 
 25 | 	// Query is the parameters of the request
 26 | 	//
 27 | 	// This parameters are independents of the request method (POST|GET)
 28 | 	Query map[string]string
 29 | 
 30 | 	// List of headers to ignore
 31 | 	IgnoreHeaders []string
 32 | 
 33 | 	// Extra headers to add
 34 | 	ExtraHeaders map[string]string
 35 | 
 36 | 	// Use base tiktok URi instead of webcast api
 37 | 	OmitAPI bool
 38 | 
 39 | 	// Specifiy base URI
 40 | 	URI                string
 41 | 	ExtraTikTokCookies string
 42 | }
 43 | 
 44 | func (t *TikTok) sendRequest(o *reqOptions, customValidate func(response *http.Response) error) ([]byte, http.Header, error) {
 45 | 	var err error
 46 | 
 47 | 	defer func() {
 48 | 		if err != nil {
 49 | 			err = fmt.Errorf("Failed to send request to %s: %w", o.Endpoint, err)
 50 | 		}
 51 | 	}()
 52 | 	method := "GET"
 53 | 	if o.IsPost {
 54 | 		method = "POST"
 55 | 	}
 56 | 
 57 | 	uri := tiktokAPIUrl
 58 | 	if o.OmitAPI {
 59 | 		uri = tiktokBaseUrl
 60 | 	}
 61 | 	if o.URI != "" {
 62 | 		uri = o.URI
 63 | 	}
 64 | 	uri = uri + o.Endpoint
 65 | 
 66 | 	u, err := url.Parse(uri)
 67 | 	if err != nil {
 68 | 		return nil, nil, err
 69 | 	}
 70 | 
 71 | 	vs := url.Values{}
 72 | 	for k, v := range o.Query {
 73 | 		if v != "" {
 74 | 			vs.Add(k, v)
 75 | 		}
 76 | 	}
 77 | 
 78 | 	reqData := bytes.NewBuffer([]byte{})
 79 | 	if o.IsPost {
 80 | 		reqData.WriteString(vs.Encode())
 81 | 	} else {
 82 | 		u.RawQuery = vs.Encode()
 83 | 	}
 84 | 
 85 | 	ua := userAgent
 86 | 	fullUrl := u.String()
 87 | 	if !o.OmitAPI && o.URI == "" && o.Endpoint == urlRoomData {
 88 | 		t.debugHandler("signing for url ", fullUrl)
 89 | 		return t.signURL(fullUrl, o)
 90 | 	}
 91 | 
 92 | 	var req *http.Request
 93 | 	req, err = http.NewRequest(method, fullUrl, reqData)
 94 | 	if err != nil {
 95 | 		return nil, nil, err
 96 | 	}
 97 | 
 98 | 	ignoreHeader := func(h string) bool {
 99 | 		for _, k := range o.IgnoreHeaders {
100 | 			if k == h {
101 | 				return true
102 | 			}
103 | 		}
104 | 		return false
105 | 	}
106 | 
107 | 	setHeaders := func(h map[string]string) {
108 | 		for k, v := range h {
109 | 			if v != "" && !ignoreHeader(k) {
110 | 				req.Header.Set(k, v)
111 | 			}
112 | 		}
113 | 	}
114 | 
115 | 	headers := map[string]string{
116 | 		// "Connection":      "keep-alive",
117 | 		"Connection":      "close",
118 | 		"Cache-Control":   "max-age=0",
119 | 		"User-Agent":      ua,
120 | 		"Accept":          "text/html,application/json,application/protobuf",
121 | 		"Referer":         referer,
122 | 		"Origin":          origin,
123 | 		"Accept-Language": "en-US,en;q=0.9",
124 | 		"Accept-Encoding": "gzip, deflate",
125 | 	}
126 | 
127 | 	setHeaders(headers)
128 | 	setHeaders(o.ExtraHeaders)
129 | 
130 | 	resp, err := t.c.Do(req)
131 | 	if err != nil {
132 | 		return nil, nil, err
133 | 	}
134 | 	defer resp.Body.Close()
135 | 
136 | 	var bb bytes.Buffer
137 | 	_, err = io.Copy(&bb, resp.Body)
138 | 	if err != nil {
139 | 		return nil, nil, err
140 | 	}
141 | 	body := bb.Bytes()
142 | 
143 | 	if resp.StatusCode == 429 {
144 | 		err = ErrRateLimitExceeded
145 | 		return body, nil, err
146 | 	} else if resp.StatusCode >= 400 {
147 | 		if resp.StatusCode == 403 {
148 | 			return nil, nil, &ErrIPBlockedOrBanned{}
149 | 		}
150 | 		err = fmt.Errorf("received status code %d", resp.StatusCode)
151 | 		return body, nil, err
152 | 	}
153 | 	if customValidate != nil {
154 | 		if err = customValidate(resp); err != nil {
155 | 			return body, nil, err
156 | 		}
157 | 	}
158 | 	// Decode gzip encoded responses
159 | 	encoding := resp.Header.Get("Content-Encoding")
160 | 	if encoding == "gzip" {
161 | 		buf := bytes.NewBuffer(body)
162 | 		zr, err := gzip.NewReader(buf)
163 | 		if err != nil {
164 | 			return nil, nil, err
165 | 		}
166 | 		var bb bytes.Buffer
167 | 		_, err = io.Copy(&bb, zr)
168 | 		body = bb.Bytes()
169 | 		if err != nil {
170 | 			return body, nil, err
171 | 		}
172 | 		if err := zr.Close(); err != nil {
173 | 			return body, nil, err
174 | 		}
175 | 	}
176 | 	ttCookie := resp.Header.Get("X-Set-TT-Cookie")
177 | 
178 | 	// Log complete response body
179 | 	if t.LogRequests {
180 | 		r := map[string]interface{}{
181 | 			"status":     resp.StatusCode,
182 | 			"endpoint":   o.Endpoint,
183 | 			"body":       string(body),
184 | 			"tts cookie": ttCookie,
185 | 		}
186 | 
187 | 		b, err := json.MarshalIndent(r, "", "  ")
188 | 		if err != nil {
189 | 			return nil, nil, err
190 | 		}
191 | 		t.debugHandler(string(b))
192 | 	}
193 | 	return body, resp.Header, nil
194 | }
195 | 


--------------------------------------------------------------------------------
/tiktok_online_test.go:
--------------------------------------------------------------------------------
  1 | //go:build requiresOnline
  2 | 
  3 | package gotiktoklive
  4 | 
  5 | import (
  6 | 	"github.com/stretchr/testify/assert"
  7 | 	"testing"
  8 | 
  9 | 	"github.com/steampoweredtaco/gotiktoklive/test_types"
 10 | )
 11 | 
 12 | func TestRoomID(t *testing.T) {
 13 | 	type test struct {
 14 | 		username string
 15 | 	}
 16 | 	tests := map[string]test{
 17 | 		"basic test": {
 18 | 			username: test_types.USERNAME,
 19 | 		},
 20 | 		"@ test": {
 21 | 			username: "@" + test_types.USERNAME,
 22 | 		},
 23 | 	}
 24 | 
 25 | 	for testName, test := range tests {
 26 | 		t.Run(testName, func(tt *testing.T) {
 27 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
 28 | 			if !assert.NoError(tt, err) {
 29 | 				return
 30 | 			}
 31 | 			id, err := tiktok.getRoomID(test.username)
 32 | 			if !assert.NoError(tt, err) {
 33 | 				return
 34 | 			}
 35 | 			t.Logf("Found Room ID: %s ", id)
 36 | 		})
 37 | 	}
 38 | }
 39 | 
 40 | func TestRoomInfo(t *testing.T) {
 41 | 	type test struct {
 42 | 		username string
 43 | 	}
 44 | 	tests := map[string]test{
 45 | 		"basic test": {
 46 | 			username: test_types.USERNAME,
 47 | 		},
 48 | 		"@ test": {
 49 | 			username: "@" + test_types.USERNAME,
 50 | 		},
 51 | 	}
 52 | 
 53 | 	for testName, test := range tests {
 54 | 		t.Run(testName, func(tt *testing.T) {
 55 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
 56 | 			if !assert.NoError(tt, err) {
 57 | 				return
 58 | 			}
 59 | 			id, err := tiktok.getRoomID(test.username)
 60 | 			if !assert.NoError(tt, err) {
 61 | 				return
 62 | 			}
 63 | 			live := Live{
 64 | 				t:  tiktok,
 65 | 				ID: id,
 66 | 			}
 67 | 			info, err := live.getRoomInfo()
 68 | 			if !assert.NoError(tt, err) {
 69 | 				return
 70 | 			}
 71 | 			tt.Log(info.Title)
 72 | 		})
 73 | 	}
 74 | }
 75 | 
 76 | func TestGiftInfo(t *testing.T) {
 77 | 	type test struct {
 78 | 		username string
 79 | 	}
 80 | 	tests := map[string]test{
 81 | 		"basic test": {
 82 | 			username: test_types.USERNAME,
 83 | 		},
 84 | 		"@ test": {
 85 | 			username: "@" + test_types.USERNAME,
 86 | 		},
 87 | 	}
 88 | 
 89 | 	for testName, test := range tests {
 90 | 		t.Run(testName, func(tt *testing.T) {
 91 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
 92 | 			if !assert.NoError(tt, err) {
 93 | 				return
 94 | 			}
 95 | 			id, err := tiktok.getRoomID(test.username)
 96 | 			if !assert.NoError(tt, err) {
 97 | 				return
 98 | 			}
 99 | 
100 | 			live := Live{
101 | 				t:  tiktok,
102 | 				ID: id,
103 | 			}
104 | 
105 | 			info, err := live.getGiftInfo()
106 | 			if !assert.NoError(tt, err) {
107 | 				return
108 | 			}
109 | 			t.Logf("Found %d gifts", len(info.Gifts))
110 | 		})
111 | 	}
112 | }
113 | 
114 | func TestRoomData(t *testing.T) {
115 | 	type test struct {
116 | 		username string
117 | 	}
118 | 	tests := map[string]test{
119 | 		"basic test": {
120 | 			username: test_types.USERNAME,
121 | 		},
122 | 		"@ test": {
123 | 			username: "@" + test_types.USERNAME,
124 | 		},
125 | 	}
126 | 
127 | 	for testName, test := range tests {
128 | 		t.Run(testName, func(tt *testing.T) {
129 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
130 | 			if !assert.NoError(tt, err) {
131 | 				return
132 | 			}
133 | 			id, err := tiktok.getRoomID(test.username)
134 | 			if !assert.NoError(tt, err) {
135 | 				return
136 | 			}
137 | 			tiktok.streams++
138 | 			live := Live{
139 | 				t:      tiktok,
140 | 				ID:     id,
141 | 				Events: make(chan Event, 100),
142 | 			}
143 | 
144 | 			err = live.getRoomData()
145 | 			if !assert.NoError(tt, err) {
146 | 				return
147 | 			}
148 | 			t.Logf("Ws url: %s, %+v", live.wsURL, live.wsParams)
149 | 		})
150 | 	}
151 | }
152 | 
153 | func TestUserInfo(t *testing.T) {
154 | 	type test struct {
155 | 		username string
156 | 	}
157 | 	tests := map[string]test{
158 | 		"basic test": {
159 | 			username: test_types.USERNAME,
160 | 		},
161 | 		"@ test": {
162 | 			username: "@" + test_types.USERNAME,
163 | 		},
164 | 	}
165 | 
166 | 	for testName, test := range tests {
167 | 		t.Run(testName, func(tt *testing.T) {
168 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
169 | 			if !assert.NoError(tt, err) {
170 | 				return
171 | 			}
172 | 
173 | 			info, err := tiktok.GetUserInfo(test.username)
174 | 			if !assert.NoError(tt, err) {
175 | 				return
176 | 			}
177 | 
178 | 			t.Logf("Got user info: %+v", info)
179 | 		})
180 | 	}
181 | }
182 | 
183 | func TestLiveRoomUser(t *testing.T) {
184 | 	type test struct {
185 | 		username string
186 | 	}
187 | 	tests := map[string]test{
188 | 		"basic test": {
189 | 			username: test_types.USERNAME,
190 | 		},
191 | 		"@ test": {
192 | 			username: "@" + test_types.USERNAME,
193 | 		},
194 | 	}
195 | 
196 | 	for testName, test := range tests {
197 | 		t.Run(testName, func(tt *testing.T) {
198 | 			tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
199 | 
200 | 			if !assert.NoError(tt, err) {
201 | 				return
202 | 			}
203 | 
204 | 			info, err := tiktok.GetLiveRoomUserInfo(test.username)
205 | 			if !assert.NoError(tt, err) {
206 | 				return
207 | 			}
208 | 
209 | 			t.Logf("Got user info: %+v", info)
210 | 		})
211 | 	}
212 | }
213 | 
214 | func TestIsLive(t *testing.T) {
215 | 	tiktok, err := NewTikTok(Proxy(test_types.PROXY, test_types.PROXY_INSECURE))
216 | 	if !assert.NoError(t, err) {
217 | 		return
218 | 	}
219 | 
220 | 	info, err := tiktok.GetLiveRoomUserInfo(test_types.USERNAME)
221 | 	if !assert.NoError(t, err) {
222 | 		return
223 | 	}
224 | 	t.Logf("Got user info: %+v", info)
225 | 	isLive, err := tiktok.IsLive(info)
226 | 	if !assert.NoError(t, err) {
227 | 		return
228 | 	}
229 | 	t.Logf("User is live: %+v", isLive)
230 | }
231 | 


--------------------------------------------------------------------------------
/proto/enums.proto:
--------------------------------------------------------------------------------
  1 | syntax = "proto3";
  2 | option go_package = "./proto;gotiktoklive";
  3 | enum AuditStatus {
  4 |   AUDITSTATUSUNKNOWN = 0;
  5 |   AUDITSTATUSPASS = 1;
  6 |   AUDITSTATUSFAILED = 2;
  7 |   AUDITSTATUSREVIEWING = 3;
  8 |   AUDITSTATUSFORBIDDEN = 4;
  9 | }
 10 | enum EmoteType {
 11 |   EMOTETYPENORMAL = 0;
 12 |   EMOTETYPEWITHSTICKER = 1;
 13 | }
 14 | enum ContentSource {
 15 |   CONTENTSOURCEUNKNOWN = 0;
 16 |   CONTENTSOURCENORMAL = 1;
 17 |   CONTENTSOURCECAMERA = 2;
 18 | }
 19 | enum EmotePrivateType {
 20 |   EMOTE_PRIVATE_TYPE_NORMAL = 0;
 21 |   EMOTE_PRIVATE_TYPE_SUB_WAVE = 1;
 22 | }
 23 | 
 24 | enum TextType {
 25 |   DISPLAY_TEXT = 0;
 26 |   CONTENT = 1;
 27 | }
 28 | 
 29 | enum LinkmicApplierSortSetting {
 30 |   LINKMIC_APPLIER_SORT_SETTING_NONE = 0;
 31 |   LINKMIC_APPLIER_SORT_SETTING_BY_GIFT_SCORE = 1;
 32 | }
 33 | 
 34 | enum LinkMicBattleStatus {
 35 |   BATTLE_ARMY_UNKNOWN = 0;
 36 |   ARMY_ONGOING = 1;
 37 |   ARMY_FINISHED = 2;
 38 |   BATTLE_ONGOING = 4;
 39 |   BATTLE_FINISHED = 5;
 40 | }
 41 | 
 42 | enum HashtagNamespace {
 43 |   GLOBAL = 0;
 44 |   GAMING = 1;
 45 | }
 46 | 
 47 | enum AgreeStatus {
 48 |   AGREE_UNKNOWN = 0;
 49 |   AGREE = 1;
 50 |   REJECT = 2;
 51 | }
 52 | 
 53 | enum KickoutReason {
 54 |   KICKOUT_REASON_UNKNOWN = 0;
 55 |   KICKOUT_REASON_FIRST_FRAME_TIMEOUT = 1;
 56 |   KICKOUT_REASON_BY_HOST = 2;
 57 |   KICKOUT_REASON_RTC_LOST_CONNECTION = 3;
 58 |   KICKOUT_REASON_BY_PUNISH = 4;
 59 |   KICKOUT_REASON_BY_ADMIN = 5;
 60 |   KICKOUT_REASON_HOST_REMOVE_ALL_GUESTS = 6;
 61 | }
 62 | 
 63 | 
 64 | enum GroupStatus {
 65 |   GROUP_STATUS_UNKNOWN = 0;
 66 |   GROUP_STATUS_WAITING = 1;
 67 |   GROUP_STATUS_LINKED = 3;
 68 | }
 69 | 
 70 | enum BusinessCase {
 71 |   BUSINESS_NOT_SET = 0;
 72 |   APPLY_BIZ_CONTENT = 1;
 73 |   INVITE_BIZ_CONTENT = 2;
 74 |   REPLY_BIZ_CONTENT = 3;
 75 |   PERMIT_BIZ_CONTENT = 4;
 76 |   JOIN_DIRECT_BIZ_CONTENT = 5;
 77 |   KICK_OUT_BIZ_CONTENT = 6;
 78 |   LIST_CHANGE_BIZ_CONTENT = 11;
 79 |   MULTI_LIVE_CONTENT = 100;
 80 |   COHOST_CONTENT = 200;
 81 | }
 82 | 
 83 | enum ReplyStatus {
 84 |   REPLY_STATUS_UNKNOWN = 0;
 85 |   REPLY_STATUS_AGREE = 1;
 86 |   REPLY_STATUS_REFUSE_PERSONALLY = 2;
 87 |   REPLY_STATUS_REFUSE_TYPE_NOT_SUPPORT = 3;
 88 |   REPLY_STATUS_REFUSE_PROCESSING_INVITATION = 4;
 89 |   REPLY_STATUS_REFUSE_BY_TIMEOUT = 5;
 90 |   REPLY_STATUS_REFUSE_EXCEPTION = 6;
 91 |   REPLY_STATUS_REFUSE_SYSTEM_NOT_SUPPORTED = 7;
 92 |   REPLY_STATUS_REFUSE_SUBTYPE_DIFFERENCE = 8;
 93 |   REPLY_STATUS_REFUSE_IN_MICROOM = 9;
 94 |   REPLY_STATUS_REFUSE_NOT_LOAD_PLUGIN = 10;
 95 |   REPLY_STATUS_REFUSE_IN_MULTI_GUEST = 11;
 96 |   REPLY_STATUS_REFUSE_PAUSE_LIVE = 12;
 97 |   REPLY_STATUS_REFUSE_OPEN_CAMERA_DIALOG_SHOWING = 13;
 98 |   REPLY_STATUS_REFUSE_DRAW_GUESSING = 14;
 99 |   REPLY_STATUS_REFUSE_RANDOM_MATCHING = 15;
100 |   REPLY_STATUS_REFUSE_IN_MATCH_PROCESSING = 16;
101 |   REPLY_STATUS_REFUSE_IN_MICROOM_FOR_MULTI_COHOST = 17;
102 |   REPLY_STATUS_REFUSE_COHOST_FINISHED = 18;
103 |   REPLY_STATUS_REFUSE_NOT_CONNECTED = 19;
104 |   REPLY_STATUS_REFUSE_LINKMIC_FULL = 20;
105 |   REPLY_STATUS_REFUSE_ARC_INCOMPATIBLE = 21;
106 |   REPLY_STATUS_REFUSE_PROCESSING_OTHER_INVITE = 22;
107 |   REPLY_STATUS_REFUSE_PROCESSING_OTHER_APPLY = 23;
108 |   REPLY_STATUS_REFUSE_IN_ANCHOR_COHOST = 24;
109 |   REPLY_STATUS_REFUSE_TOPIC_PAIRING = 25;
110 | }
111 | 
112 | enum SubscribeType {
113 |   SUBSCRIBETYPE_ONCE = 0;
114 |   SUBSCRIBETYPE_AUTO = 1;
115 |   SUBSCRIBETYPE_DEFAULT = 100;
116 | }
117 | enum OldSubscribeStatus {
118 |   OLDSUBSCRIBESTATUS_FIRST = 0;
119 |   OLDSUBSCRIBESTATUS_RESUB = 1;
120 |   OLDSUBSCRIBESTATUS_SUBINGRACEPERIOD = 2;
121 |   OLDSUBSCRIBESTATUS_SUBNOTINGRACEPERIOD = 3;
122 |   OLDSUBSCRIBESTATUS_DEFAULT = 100;
123 | }
124 | enum SubscribingStatus {
125 |   SUBSCRIBINGSTATUS_UNKNOWN = 0;
126 |   SUBSCRIBINGSTATUS_ONCE = 1;
127 |   SUBSCRIBINGSTATUS_CIRCLE = 2;
128 |   SUBSCRIBINGSTATUS_CIRCLECANCEL = 3;
129 |   SUBSCRIBINGSTATUS_REFUND = 4;
130 |   SUBSCRIBINGSTATUS_INGRACEPERIOD = 5;
131 |   SUBSCRIBINGSTATUS_NOTINGRACEPERIOD = 6;
132 | }
133 | enum LinkmicStatus
134 | {
135 |   Disable = 0;
136 |   Enable = 1;
137 |   Just_Following = 2;
138 |   Multi_Linking = 3;
139 |   Multi_Linking_Only_Following = 4;
140 | }
141 | 
142 | enum MemberMessageAction {
143 |   UNKNOWN = 0;
144 |   JOINED = 1; // User Joined the Stream
145 |   SUBSCRIBED = 3; // User Subscribed to the Host
146 |   //?? = 26
147 |   //?? = 27
148 |   //?? = 50 (share?)
149 | }
150 | 
151 | enum ControlAction {
152 |   ControlActionUNKNOWN = 0;
153 |   STREAM_PAUSED = 1; // Stream Paused by Host
154 |   STREAM_UNPAUSED = 2;
155 |   STREAM_ENDED = 3; // Stream Ended by Host
156 |   STREAM_ENDED_BAN = 4; // Stream ended due to ban
157 | }
158 | 
159 | enum LinkLayerMessageType
160 | {
161 |   Linker_Unknown = 0;
162 |   Linker_Create = 1;
163 |   Linker_Invite = 2;
164 |   Linker_Apply = 3;
165 |   Linker_Permit = 4;
166 |   Linker_Reply = 5;
167 |   Linker_Kick_Out = 6;
168 |   Linker_Cancel_Apply = 7;
169 |   Linker_Cancel_Invite = 8;
170 |   Linker_Leave = 9;
171 |   Linker_Finish = 10;
172 |   Linker_List_Change = 11;
173 |   Linker_Join_Direct = 12;
174 |   Linker_Join_Group = 13;
175 |   Linker_Permit_Group = 14;
176 |   Linker_Cancel_Group = 15;
177 |   Linker_Leave_Group = 16;
178 |   Linker_P2P_Group_Change = 17;
179 |   Linker_Group_Change = 18;
180 | }
181 | 
182 | 
183 | enum BarrageType
184 | {
185 |   BarrageType_Unknown = 0;
186 |   EComOrdering = 1;
187 |   EComBuying = 2;
188 |   Normal = 3;
189 |   Subscribe = 4;
190 |   EventView = 5;
191 |   EventRegistered = 6;
192 |   SubscribeGift = 7;
193 |   UserUpgrade = 8;
194 |   GradeUserEntranceNotification = 9;
195 |   FansLevelUpgrade = 10;
196 |   FansLevelEntrance = 11;
197 |   GamePartnership = 12;
198 | }
199 | 
200 | enum EnvelopeBusinessType
201 | {
202 |   BusinessTypeUnknown = 0;
203 |   BusinessTypeUserDiamond = 1;
204 |   BusinessTypePlatformDiamond = 2;
205 |   BusinessTypePlatformShell = 3;
206 |   BusinessTypePortal = 4;
207 |   BusinessTypePlatformMerch = 5;
208 |   BusinessTypeEoYDiamond = 6;
209 |   BusinessTypeFanClubGtM = 7;
210 | }
211 | enum EnvelopeFollowShowStatus
212 | {
213 |   EnvelopeFollowShowUnknown = 0;
214 |   EnvelopeFollowShow = 1;
215 |   EnvelopeFollowNotShow = 2;
216 | }
217 | 
218 | enum EnvelopeDisplay
219 | {
220 |   EnvelopeDisplayUnknown = 0;
221 |   EnvelopeDisplayNew = 1;
222 |   EnvelopeDisplayHide = 2;
223 | }
224 | 
225 | 
226 | enum CommonContentCase {
227 |   COMMON_CONTENT_NOT_SET = 0;
228 |   CREATE_CHANNEL_CONTENT = 100;
229 |   LIST_CHANGE_CONTENT = 102;
230 |   INVITE_CONTENT = 103;
231 |   APPLY_CONTENT = 104;
232 |   PERMIT_APPLY_CONTENT = 105;
233 |   REPLY_INVITE_CONTENT = 106;
234 |   KICK_OUT_CONTENT = 107;
235 |   CANCEL_APPLY_CONTENT = 108;
236 |   CANCEL_INVITE_CONTENT = 109;
237 |   LEAVE_CONTENT = 110;
238 |   FINISH_CONTENT = 111;
239 |   JOIN_DIRECT_CONTENT = 112;
240 |   JOIN_GROUP_CONTENT = 113;
241 |   PERMIT_GROUP_CONTENT = 114;
242 |   CANCEL_GROUP_CONTENT = 115;
243 |   LEAVE_GROUP_CONTENT = 116;
244 |   P2P_GROUP_CHANGE_CONTENT = 117;
245 |   GROUP_CHANGE_CONTENT = 118;
246 | }
247 | 
248 | 
249 | enum LinkMessageType {
250 |   TYPE_LINKER_UNKNOWN = 0;
251 |   TYPE_LINKER_CREATE = 1;
252 |   TYPE_LINKER_CLOSE = 2;
253 |   TYPE_LINKER_INVITE = 3;
254 |   TYPE_LINKER_APPLY = 4;
255 |   TYPE_LINKER_REPLY = 5;
256 |   TYPE_LINKER_ENTER = 6;
257 |   TYPE_LINKER_LEAVE = 7;
258 |   TYPE_LINKER_PERMIT = 8;
259 |   TYPE_LINKER_CANCEL_INVITE = 9;
260 |   TYPE_LINKER_WAITING_LIST_CHANGE = 10;
261 |   TYPE_LINKER_LINKED_LIST_CHANGE = 11;
262 |   TYPE_LINKER_UPDATE_USER = 12;
263 |   TYPE_LINKER_KICK_OUT = 13;
264 |   TYPE_LINKER_CANCEL_APPLY = 14;
265 |   TYPE_LINKER_MUTE = 15;
266 |   TYPE_LINKER_MATCH = 16;
267 |   TYPE_LINKER_UPDATE_USER_SETTING = 17;
268 |   TYPE_LINKER_MIC_IDX_UPDATE = 18;
269 |   TYPE_LINKER_LEAVE_V2 = 19;
270 |   TYPE_LINKER_WAITING_LIST_CHANGE_V2 = 20;
271 |   TYPE_LINKER_LINKED_LIST_CHANGE_V2 = 21;
272 |   TYPE_LINKER_COHOST_LIST_CHANGE = 22;
273 |   TYPE_LINKER_MEDIA_CHANGE = 23;
274 |   TYPE_LINKER_ACCEPT_NOTICE = 24;
275 |   TYPE_LINKER_SYS_KICK_OUT = 101;
276 |   TYPE_LINKMIC_USER_TOAST = 102;
277 | }
278 | 
279 | enum MessageType {
280 |   MESSAGETYPE_SUBSUCCESS = 0;
281 |   MESSAGETYPE_ANCHORREMINDER = 1;
282 |   MESSAGETYPE_ENTERROOMEXPIRESOON = 2;
283 |   MESSAGETYPE_SUBGOALCREATETOANCHOR = 3;
284 |   MESSAGETYPE_SUBGOALCOMPLETETOAUDIENCE = 4;
285 |   MESSAGETYPE_SUBGOALCOMPLETETOANCHOR = 5;
286 |   MESSAGETYPE_SUBGIFTTIKTOK2USERNOTICE = 6;
287 |   MESSAGETYPE_SUBGIFTTIKTOK2ANCHORNOTICE = 7;
288 |   MESSAGETYPE_SUBGIFTTRECEIVESENDNOTICE = 8;
289 |   MESSAGETYPE_SUBGIFTSENDSUCCEEDROOMMESSAGE = 9;
290 |   MESSAGETYPE_SUBGIFTSENDSUCCEEDANCHORNOTICE = 10;
291 |   MESSAGETYPE_SUBGIFTLOWVERSIONUPGRADENOTICE = 11;
292 |   MESSAGETYPE_SUBGIFTUSERBUYAUTHNOTICE = 12;
293 | }
294 | 
295 | enum Scene {
296 |   SCENE_UNKNOWN = 0;
297 |   SCENE_CO_HOST = 2;
298 |   SCENE_MULTI_LIVE = 4;
299 | }


--------------------------------------------------------------------------------
/wss.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"encoding/hex"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"net"
  9 | 	"net/http"
 10 | 	"net/url"
 11 | 	"os"
 12 | 	"time"
 13 | 
 14 | 	pb "github.com/steampoweredtaco/gotiktoklive/proto"
 15 | 
 16 | 	"github.com/gobwas/ws"
 17 | 	"github.com/gobwas/ws/wsutil"
 18 | 	"golang.org/x/net/proxy"
 19 | 	"google.golang.org/protobuf/proto"
 20 | )
 21 | 
 22 | func (l *Live) connect(addr string, params map[string]string) error {
 23 | 	u, err := url.Parse("https://tiktok.com/")
 24 | 	if err != nil {
 25 | 		return nil
 26 | 	}
 27 | 
 28 | 	// Take the cookies from the HTTP client cookie jar and pass them as a GET parameter.
 29 | 	cookies := l.t.c.Jar.Cookies(u)
 30 | 	headers := http.Header{}
 31 | 	var s string
 32 | 	for _, cookie := range cookies {
 33 | 		if s == "" {
 34 | 			s = cookie.String()
 35 | 		} else {
 36 | 			s += "; " + cookie.String()
 37 | 		}
 38 | 	}
 39 | 	if len(cookies) > 0 {
 40 | 		headers.Set("Cookie", s)
 41 | 	}
 42 | 
 43 | 	vs := url.Values{}
 44 | 	for key, value := range defaultGETParams {
 45 | 		vs.Add(key, value)
 46 | 	}
 47 | 	for key, value := range params {
 48 | 		vs.Add(key, value)
 49 | 	}
 50 | 	for key, value := range wsOverrideHeaders {
 51 | 		vs.Set(key, value)
 52 | 	}
 53 | 	vs.Add("room_id", l.ID)
 54 | 
 55 | 	wsURL := fmt.Sprintf("%s?%s", addr, vs.Encode())
 56 | 
 57 | 	// Read proxies from HTTP env variables, HTTPS takes precedent
 58 | 	var proxyURI *url.URL
 59 | 	envVars := []string{"HTTP_PROXY", "HTTPS_PROXY"}
 60 | 	for _, envVar := range envVars {
 61 | 		if httpProxy := os.Getenv(envVar); httpProxy != "" {
 62 | 			uri, err := url.Parse(httpProxy)
 63 | 			if err != nil {
 64 | 				l.t.warnHandler(fmt.Errorf("Failed to parse %s url: %w", envVar, err))
 65 | 			} else {
 66 | 				proxyURI = uri
 67 | 			}
 68 | 		}
 69 | 	}
 70 | 
 71 | 	// If proxy manually defined, use that
 72 | 	if l.t.proxy != nil {
 73 | 		proxyURI = l.t.proxy
 74 | 	}
 75 | 
 76 | 	// Default proxy net dial
 77 | 	proxyNetDial := proxy.FromEnvironment()
 78 | 
 79 | 	// If custom URI is defined, genereate proxy net dial from that
 80 | 	if proxyURI != nil {
 81 | 		dial, err := proxy.FromURL(proxyURI, Direct)
 82 | 		if err != nil {
 83 | 			l.t.warnHandler(fmt.Errorf("Failed to configure proxy dialer: %w", err))
 84 | 		} else {
 85 | 			proxyNetDial = dial
 86 | 		}
 87 | 	}
 88 | 
 89 | 	dialer := ws.Dialer{
 90 | 		Header: ws.HandshakeHeaderHTTP(headers),
 91 | 		NetDial: func(ctx context.Context, a, b string) (net.Conn, error) {
 92 | 			return proxyNetDial.Dial(a, b)
 93 | 		},
 94 | 		// NetDial:   proxy.Dial,
 95 | 		Protocols: []string{"echo-protocol"},
 96 | 	}
 97 | 	conn, _, _, err := dialer.Dial(context.Background(), wsURL)
 98 | 	if err != nil {
 99 | 		return fmt.Errorf("Failed to connect to %s: %w", wsURL, err)
100 | 	}
101 | 	l.wss = conn
102 | 	return nil
103 | }
104 | 
105 | func (l *Live) readSocket() {
106 | 	defer l.wss.Close()
107 | 	defer func() {
108 | 		select {
109 | 		case <-time.After(5 * time.Second):
110 | 		case l.Events <- &DisconnectEvent{created: time.Now()}:
111 | 		}
112 | 	}()
113 | 	defer l.cancel()
114 | 
115 | 	want := ws.OpBinary
116 | 	s := ws.StateClientSide
117 | 
118 | 	controlHandler := wsutil.ControlFrameHandler(l.wss, s)
119 | 	rd := wsutil.Reader{
120 | 		Source:          l.wss,
121 | 		State:           s,
122 | 		CheckUTF8:       true,
123 | 		SkipHeaderCheck: false,
124 | 		OnIntermediate:  controlHandler,
125 | 	}
126 | 
127 | 	for {
128 | 		hdr, err := rd.NextFrame()
129 | 		if err != nil {
130 | 			l.t.errHandler(fmt.Errorf("failed to read websocket from server: %w", err))
131 | 			l.wss.Close()
132 | 			return
133 | 		}
134 | 		// If msg is ping or close
135 | 		if hdr.OpCode.IsControl() {
136 | 			if err := controlHandler(hdr, &rd); err != nil {
137 | 				l.t.errHandler(fmt.Errorf("websocket control handler failed: %w", err))
138 | 			}
139 | 			continue
140 | 		}
141 | 
142 | 		if hdr.OpCode == ws.OpClose {
143 | 			l.t.warnHandler("Websocket connection was closed by server.")
144 | 			if l.t.enableWSTrace {
145 | 				l.t.wsTraceChan <- struct{ direction, hex string }{direction: "<=", hex: "websocket closed"}
146 | 			}
147 | 			return
148 | 		}
149 | 
150 | 		// Wrong OpCode
151 | 		if hdr.OpCode&want == 0 {
152 | 			msgBytes, err := io.ReadAll(&rd)
153 | 			if err != nil {
154 | 				l.t.errHandler(fmt.Errorf("Failed to read websocket message: %w", err))
155 | 			}
156 | 			if l.t.enableWSTrace {
157 | 				l.t.wsTraceChan <- struct{ direction, hex string }{direction: fmt.Sprintf("<= (unexpected opcode %02x)", hdr.OpCode), hex: hex.EncodeToString(msgBytes)}
158 | 			}
159 | 
160 | 			continue
161 | 		}
162 | 
163 | 		// Read message
164 | 		msgBytes, err := io.ReadAll(&rd)
165 | 		if l.t.enableWSTrace {
166 | 			l.t.wsTraceChan <- struct{ direction, hex string }{direction: "<=", hex: hex.EncodeToString(msgBytes)}
167 | 		}
168 | 
169 | 		if err != nil {
170 | 			l.t.errHandler(fmt.Errorf("Failed to read websocket message: %w", err))
171 | 		}
172 | 
173 | 		if err := l.parseWssMsg(msgBytes); err != nil {
174 | 			l.t.errHandler(fmt.Errorf("Failed to parse websocket message: %w", err))
175 | 		}
176 | 
177 | 		// Gracefully shutdown
178 | 		select {
179 | 		case <-l.done():
180 | 			return
181 | 		case <-l.t.done():
182 | 			l.t.infoHandler("Close websocket, global context done")
183 | 			return
184 | 		default:
185 | 		}
186 | 	}
187 | }
188 | 
189 | func (l *Live) parseWssMsg(wssMsg []byte) error {
190 | 	var rsp pb.WebcastPushFrame
191 | 	if err := proto.Unmarshal(wssMsg, &rsp); err != nil {
192 | 		return fmt.Errorf("Failed to unmarshal proto WebcastWebsocketMessage: %w", err)
193 | 	}
194 | 
195 | 	if rsp.PayloadType == "msg" {
196 | 		var response pb.WebcastResponse
197 | 		if err := proto.Unmarshal(rsp.Payload, &response); err != nil {
198 | 			return fmt.Errorf("Failed to unmarshal proto WebcastResponse: %w", err)
199 | 		}
200 | 		if response.NeedsAck {
201 | 			if err := l.sendAck(rsp.LogId, response.InternalExt); err != nil {
202 | 				// Might as well finishing processing all messages, the connection reset will be
203 | 				// caught later
204 | 				l.t.warnHandler("Failed to send websocket ack msg, likely connection reset: %w", err)
205 | 			}
206 | 		}
207 | 		l.cursor = response.Cursor
208 | 
209 | 		if l.t.Debug {
210 | 			l.t.debugHandler(fmt.Sprintf("Got %d messages, %s", len(response.Messages), response.Cursor))
211 | 		}
212 | 
213 | 		for _, rawMsg := range response.Messages {
214 | 			msg, err := parseMsg(rawMsg, l.t.warnHandler, l.t.debugHandler, l.t.enableExperimentalEvents)
215 | 			if err != nil {
216 | 				return fmt.Errorf("Failed to parse response message: %w", err)
217 | 			}
218 | 			if msg != nil {
219 | 				// TODO, let's fix this
220 | 				// If channel is full, discard the first message
221 | 				if len(l.Events) == l.chanSize {
222 | 					<-l.Events
223 | 				}
224 | 				l.Events <- msg
225 | 			}
226 | 
227 | 			// If livestream has ended
228 | 			if m, ok := msg.(ControlEvent); ok &&
229 | 				(pb.ControlAction(m.Action) == pb.ControlAction_STREAM_ENDED ||
230 | 					pb.ControlAction(m.Action) == pb.ControlAction_STREAM_ENDED_BAN) {
231 | 				l.t.warnHandler(fmt.Sprintf("live has ended due to %s, closing event stream", pb.ControlAction(m.Action).String()))
232 | 				l.cancel()
233 | 			}
234 | 		}
235 | 		return nil
236 | 	}
237 | 	if l.t.Debug {
238 | 		l.t.debugHandler(fmt.Sprintf("Message type unknown, %s : '%s\n%s", rsp.PayloadType, string(rsp.Payload), hex.EncodeToString(wssMsg)))
239 | 	}
240 | 	return nil
241 | }
242 | 
243 | func (l *Live) sendPing() {
244 | 	const helloHex = "3a026862"
245 | 	b, err := hex.DecodeString(helloHex)
246 | 	if err != nil {
247 | 		l.t.errHandler(err)
248 | 	}
249 | 
250 | 	t := time.NewTicker(10000 * time.Millisecond)
251 | 	defer t.Stop()
252 | 
253 | 	for {
254 | 		select {
255 | 		case <-l.done():
256 | 			return
257 | 		case <-l.t.done():
258 | 			return
259 | 		case <-t.C:
260 | 			if err := wsutil.WriteClientBinary(l.wss, b); err != nil {
261 | 				l.t.errHandler(fmt.Errorf("Failed to send ping: %w", err))
262 | 			} else {
263 | 				if l.t.enableWSTrace {
264 | 					l.t.wsTraceChan <- struct{ direction, hex string }{direction: "=>", hex: helloHex}
265 | 				}
266 | 			}
267 | 		}
268 | 	}
269 | }
270 | 
271 | func (l *Live) sendAck(id uint64, extra []byte) error {
272 | 	msg := pb.WebcastPushFrame{
273 | 		LogId:       id,
274 | 		PayloadType: "ack",
275 | 		Payload:     extra,
276 | 	}
277 | 
278 | 	b, err := proto.Marshal(&msg)
279 | 	if err != nil {
280 | 		return err
281 | 	}
282 | 
283 | 	if err := wsutil.WriteClientBinary(l.wss, b); err != nil {
284 | 		return err
285 | 	}
286 | 	if l.t.enableWSTrace {
287 | 		l.t.wsTraceChan <- struct{ direction, hex string }{direction: "=>", hex: hex.EncodeToString(b)}
288 | 	}
289 | 	return nil
290 | }
291 | 
292 | func (l *Live) tryConnectionUpgrade() error {
293 | 	if l.wsURL == "" {
294 | 		return fmt.Errorf("cannot upgrade connection without a wsURL")
295 | 	}
296 | 	if l.wsParams == nil {
297 | 		return fmt.Errorf("cannot upgrade connection without a wsURL")
298 | 	}
299 | 	err := l.connect(l.wsURL, l.wsParams)
300 | 	if err != nil {
301 | 		close(l.Events)
302 | 		return fmt.Errorf("Connection upgrade failed: %w", err)
303 | 	}
304 | 	if l.t.Debug {
305 | 		l.t.debugHandler("Connected to websocket")
306 | 	}
307 | 
308 | 	l.wg.Add(2)
309 | 	go func() {
310 | 		defer l.wg.Done()
311 | 		defer close(l.Events)
312 | 		l.readSocket()
313 | 	}()
314 | 	go func() {
315 | 		defer l.wg.Done()
316 | 		l.sendPing()
317 | 	}()
318 | 
319 | 	l.t.infoHandler("Connected to websocket")
320 | 	return nil
321 | }
322 | 


--------------------------------------------------------------------------------
/tiktok.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"context"
  6 | 	"crypto/tls"
  7 | 	"encoding/json"
  8 | 	"errors"
  9 | 	"fmt"
 10 | 	"go.uber.org/ratelimit"
 11 | 	"io"
 12 | 	"log/slog"
 13 | 	"maps"
 14 | 	"net/http"
 15 | 	"net/http/cookiejar"
 16 | 	neturl "net/url"
 17 | 	"os"
 18 | 	"os/signal"
 19 | 	"path/filepath"
 20 | 	"strings"
 21 | 	"sync"
 22 | 	"syscall"
 23 | 	"time"
 24 | )
 25 | 
 26 | const (
 27 | 	defaultSignerURL = "https://tiktok.eulerstream.com"
 28 | )
 29 | 
 30 | // TikTok allows you to track and discover current live streams.
 31 | type TikTok struct {
 32 | 	c    *http.Client
 33 | 	wg   *sync.WaitGroup
 34 | 	done func() <-chan struct{}
 35 | 
 36 | 	streams int
 37 | 	mu      *sync.Mutex
 38 | 
 39 | 	// Pass extra debug messages to debugHandler
 40 | 	Debug bool
 41 | 
 42 | 	// LogRequests when set to true will log all made requests in JSON to debugHandler
 43 | 	LogRequests bool
 44 | 
 45 | 	infoHandler  func(...interface{})
 46 | 	warnHandler  func(...interface{})
 47 | 	debugHandler func(...interface{})
 48 | 	errHandler   func(...interface{})
 49 | 
 50 | 	proxy                    *neturl.URL
 51 | 	apiKey                   string
 52 | 	clientName               string
 53 | 	shouldReconnect          bool
 54 | 	enableExperimentalEvents bool
 55 | 	enableExtraDebug         bool
 56 | 	enableWSTrace            bool
 57 | 	wsTraceFile              string
 58 | 	wsTraceChan              chan struct{ direction, hex string }
 59 | 	wsTraceOut               *bufio.Writer
 60 | 	signerUrl                string
 61 | 	getLimits                bool
 62 | 	limiter                  ratelimit.Limiter
 63 | }
 64 | 
 65 | // NewTikTok creates a tiktok instance that allows you to track live streams and
 66 | //
 67 | //	discover current livestreams.
 68 | func NewTikTok(options ...TikTokLiveOption) (*TikTok, error) {
 69 | 	return NewTikTokWithApiKey(clientNameDefault, apiKeyDefault, options...)
 70 | }
 71 | 
 72 | // NewTikTokWithApiKey allows to use an ApiKey with the default signer.
 73 | func NewTikTokWithApiKey(clientName, apiKey string, options ...TikTokLiveOption) (*TikTok, error) {
 74 | 	jar, _ := cookiejar.New(nil)
 75 | 	wg := sync.WaitGroup{}
 76 | 	ctx, cancel := context.WithCancel(context.Background())
 77 | 
 78 | 	tiktok := TikTok{
 79 | 		c: &http.Client{
 80 | 			Jar: jar,
 81 | 			CheckRedirect: func(req *http.Request, via []*http.Request) error {
 82 | 				return http.ErrUseLastResponse
 83 | 			},
 84 | 			// Transport: &loggingTransport{},
 85 | 		},
 86 | 		wg:              &wg,
 87 | 		done:            ctx.Done,
 88 | 		mu:              &sync.Mutex{},
 89 | 		infoHandler:     defaultLogHandler,
 90 | 		warnHandler:     defaultLogHandler,
 91 | 		debugHandler:    routineErrHandler,
 92 | 		errHandler:      routineErrHandler,
 93 | 		signerUrl:       defaultSignerURL,
 94 | 		clientName:      clientName,
 95 | 		apiKey:          apiKey,
 96 | 		shouldReconnect: true,
 97 | 		getLimits:       true,
 98 | 	}
 99 | 	envs := []string{"HTTP_PROXY", "HTTPS_PROXY"}
100 | 	var optionsErr []error
101 | 
102 | 	for _, env := range envs {
103 | 		if e := os.Getenv(env); e != "" {
104 | 			tiktok.setProxy(e, false)
105 | 		}
106 | 	}
107 | 	for _, option := range options {
108 | 		optionsErr = append(optionsErr, option(&tiktok))
109 | 	}
110 | 	err := errors.Join(optionsErr...)
111 | 	if err != nil {
112 | 		cancel()
113 | 		return nil, err
114 | 	}
115 | 	if tiktok.getLimits {
116 | 		limits, err := GetSignerLimits(tiktok.signerUrl, tiktok.apiKey)
117 | 		if err != nil {
118 | 			cancel()
119 | 			return nil, fmt.Errorf("cannot get signing limits: %w", err)
120 | 		}
121 | 		slog.Debug("limits found, using per minute limit", "day", limits.Day, "hour", limits.Hour, "minute", limits.Minute)
122 | 		limiter := ratelimit.New(limits.Minute.Max, ratelimit.Per(1*time.Minute), ratelimit.WithoutSlack)
123 | 		tiktok.limiter = limiter
124 | 	} else {
125 | 		slog.Debug("Request limits set to sane default of 10 per minute, for more enable GetLimits option to use signer specified limits")
126 | 		limiter := ratelimit.New(10, ratelimit.Per(1*time.Minute), ratelimit.WithoutSlack)
127 | 		tiktok.limiter = limiter
128 | 	}
129 | 
130 | 	if tiktok.enableWSTrace {
131 | 		var err error
132 | 		tiktok.wsTraceFile, err = filepath.Abs(tiktok.wsTraceFile)
133 | 		if err != nil {
134 | 			tiktok.errHandler(fmt.Errorf("cannot get info for ws trace file, it will not be enable: %w", err))
135 | 			tiktok.enableWSTrace = false
136 | 			goto continueSetup
137 | 		}
138 | 		f, err := os.Create(tiktok.wsTraceFile)
139 | 		tiktok.wsTraceOut = bufio.NewWriter(f)
140 | 
141 | 		wg.Add(1)
142 | 		go func() {
143 | 			defer func() {
144 | 				_ = f.Close()
145 | 			}()
146 | 			defer wg.Done()
147 | 			for {
148 | 				select {
149 | 				case <-ctx.Done():
150 | 					return
151 | 				case t := <-tiktok.wsTraceChan:
152 | 					timestamp := time.Now().UTC().Format("2006-01-02 15:04:05.000")
153 | 					tiktok.wsTraceOut.Write([]byte(timestamp))
154 | 					tiktok.wsTraceOut.Write([]byte(t.direction))
155 | 					tiktok.wsTraceOut.Write([]byte(" "))
156 | 					tiktok.wsTraceOut.Write([]byte(t.hex))
157 | 					tiktok.wsTraceOut.Write([]byte("\n"))
158 | 					tiktok.wsTraceOut.Flush()
159 | 				}
160 | 			}
161 | 		}()
162 | 	}
163 | continueSetup:
164 | 	setupInterruptHandler(
165 | 		func(c chan os.Signal) {
166 | 			<-c
167 | 			cancel()
168 | 			wg.Wait()
169 | 
170 | 			tiktok.infoHandler("Shutting down...")
171 | 			os.Exit(0)
172 | 		})
173 | 
174 | 	tiktok.sendRequest(&reqOptions{
175 | 		OmitAPI: true,
176 | 	}, nil)
177 | 
178 | 	return &tiktok, nil
179 | }
180 | 
181 | // GetLiveRoomUserInfo will fetch information about the user's live room which contains
182 | // information about the user and also the live room which contains their user ID, as well
183 | // as the RoomID, with which you can tell if they are live.
184 | func (t *TikTok) GetLiveRoomUserInfo(user string) (LiveRoomUserInfo, error) {
185 | 	user = cleanupUser(user)
186 | 	body, _, err := t.sendRequest(&reqOptions{
187 | 		Endpoint: fmt.Sprintf(urlUser+urlLive, user),
188 | 		Query:    defaultRequestHeaders,
189 | 		OmitAPI:  true,
190 | 	}, func(response *http.Response) error {
191 | 		if response.StatusCode != 200 {
192 | 			return UserNotFound{}
193 | 		}
194 | 		return nil
195 | 	})
196 | 	if err != nil {
197 | 		return LiveRoomUserInfo{}, err
198 | 	}
199 | 
200 | 	// Find json data in HTML page
201 | 	var matches [][]byte
202 | 	for _, re := range reJsonData {
203 | 		matches = re.FindSubmatch(body)
204 | 		if len(matches) != 0 {
205 | 			break
206 | 		}
207 | 	}
208 | 	if len(matches) == 0 {
209 | 		return LiveRoomUserInfo{}, &ErrIPBlockedOrBanned{}
210 | 	}
211 | 
212 | 	// Parse json data
213 | 	var res struct {
214 | 		LiveRoom *liveRoomContainer `json:"liveRoom,omitempty"`
215 | 	}
216 | 	if err := json.Unmarshal(matches[1], &res); err != nil {
217 | 		return LiveRoomUserInfo{}, err
218 | 	}
219 | 
220 | 	if res.LiveRoom == nil || res.LiveRoom.LiveRoomUserInfo == nil {
221 | 		return LiveRoomUserInfo{}, ErrUserNotFound
222 | 	}
223 | 
224 | 	return *res.LiveRoom.LiveRoomUserInfo, nil
225 | }
226 | 
227 | func cleanupUser(user string) string {
228 | 	return strings.TrimLeft(user, "@")
229 | }
230 | 
231 | // GetUserInfo will fetch information about the user, such as followers stats,
232 | //
233 | //	their user ID, as well as the RoomID, with which you can tell if they are live.
234 | func (t *TikTok) GetUserInfo(user string) (LiveRoomUser, error) {
235 | 	roomUserInfo, err := t.GetLiveRoomUserInfo(user)
236 | 	if err != nil {
237 | 		return LiveRoomUser{}, err
238 | 	}
239 | 	return *roomUserInfo.LiveRoomUser, nil
240 | }
241 | 
242 | // GetPriceList fetches the price list of tiktok coins. Prices will be given in
243 | //
244 | //	USD cents and the cents equivalent of the local currency of the IP location.
245 | //
246 | // To fetch a different currency, use a VPN or proxy to change your IP to a
247 | //
248 | //	different country.
249 | func (t *TikTok) GetPriceList() (*PriceList, error) {
250 | 	body, _, err := t.sendRequest(&reqOptions{
251 | 		Endpoint: urlPriceList,
252 | 		Query:    defaultGETParams,
253 | 	}, nil)
254 | 	if err != nil {
255 | 		return nil, err
256 | 	}
257 | 
258 | 	var rsp PriceList
259 | 	if err := json.Unmarshal(body, &rsp); err != nil {
260 | 		return nil, err
261 | 	}
262 | 
263 | 	return &rsp, nil
264 | }
265 | 
266 | func (t *TikTok) SetInfoHandler(f func(...interface{})) {
267 | 	t.infoHandler = f
268 | }
269 | 
270 | func (t *TikTok) SetWarnHandler(f func(...interface{})) {
271 | 	t.warnHandler = f
272 | }
273 | 
274 | func (t *TikTok) SetDebugHandler(f func(...interface{})) {
275 | 	t.debugHandler = f
276 | }
277 | 
278 | func (t *TikTok) SetErrorHandler(f func(...interface{})) {
279 | 	t.errHandler = f
280 | }
281 | 
282 | // setProxy will set a proxy for both the http client as well as the websocket.
283 | // You can manually set a proxy with this method, or by using the HTTPS_PROXY
284 | //
285 | //	environment variable.
286 | //
287 | // ALL_PROXY can be used to set a proxy only for the websocket.
288 | func (t *TikTok) setProxy(url string, insecure bool) error {
289 | 	uri, err := neturl.Parse(url)
290 | 	if err != nil {
291 | 		return err
292 | 	}
293 | 
294 | 	t.proxy = uri
295 | 
296 | 	tr := http.DefaultTransport.(*http.Transport).Clone()
297 | 	tr.TLSClientConfig = &tls.Config{
298 | 		InsecureSkipVerify: insecure,
299 | 	}
300 | 	tr.Proxy = http.ProxyURL(uri)
301 | 	if originalClient, ok := t.c.Transport.(*loggingTransport); ok {
302 | 		originalClient.Transport = tr
303 | 	} else {
304 | 		t.c.Transport = tr
305 | 	}
306 | 
307 | 	// t.c.Transport = &http.Transport{
308 | 	// 	Proxy: http.ProxyURL(uri),
309 | 	// 	TLSClientConfig: &tls.Config{
310 | 	// 		InsecureSkipVerify: insecure,
311 | 	// 	},
312 | 	// }
313 | 	return nil
314 | }
315 | 
316 | // IsLive can determine if the user is live. Use GetLiveRoomUserInfo first, if
317 | // user is not found that means there was never a live by that user in the first
318 | // place.
319 | func (t *TikTok) IsLive(info LiveRoomUserInfo) (bool, error) {
320 | 	minGetParams := maps.Clone(minGetParams)
321 | 	minGetParams["room_ids"] = info.LiveRoomUser.RoomID
322 | 
323 | 	type DataItem struct {
324 | 		Alive     bool   `json:"alive"`
325 | 		RoomID    int64  `json:"room_id"`
326 | 		RoomIDStr string `json:"room_id_str"`
327 | 	}
328 | 
329 | 	type Extra struct {
330 | 		Now int64 `json:"now"`
331 | 	}
332 | 
333 | 	type Response struct {
334 | 		Data       []DataItem `json:"data"`
335 | 		Extra      Extra      `json:"extra"`
336 | 		StatusCode int        `json:"status_code"`
337 | 	}
338 | 
339 | 	body, _, err := t.sendRequest(&reqOptions{
340 | 		Endpoint: urlCheckLive,
341 | 		Query:    minGetParams,
342 | 		OmitAPI:  false,
343 | 	}, nil)
344 | 	if err != nil {
345 | 		return false, err
346 | 	}
347 | 	var res Response
348 | 	if err := json.Unmarshal(body, &res); err != nil {
349 | 		return false, err
350 | 	}
351 | 
352 | 	for i := range res.Data {
353 | 		if res.Data[i].RoomIDStr == info.LiveRoomUser.RoomID {
354 | 			return res.Data[i].Alive, nil
355 | 		}
356 | 	}
357 | 	return false, fmt.Errorf("roomID not found in result")
358 | }
359 | 
360 | func setupInterruptHandler(f func(chan os.Signal)) {
361 | 	c := make(chan os.Signal)
362 | 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
363 | 	go f(c)
364 | }
365 | 
366 | // GetSignerLimits returns the limits as provided by the signer.  This supports eulerstream signer and any other signers that
367 | // support the same API endpoints
368 | //
369 | // Example:
370 | //
371 | //	limits, _ := GetSignerLimits("https://tiktok.eulerstream.com", "MyApiKey")
372 | //	fmt.Printf("limits Day: %d, Hour: %d, Minutes %d\n", limits.Day, limits.Hour, limits.Minute)
373 | func GetSignerLimits(signer string, apiKey string) (SigningLimits, error) {
374 | 	resp, err := http.Get(fmt.Sprintf("%s/webcast/rate_limits?apiKey=%s", signer, apiKey))
375 | 	if err != nil {
376 | 		return SigningLimits{}, fmt.Errorf("cannot get rate_limts: %s", err)
377 | 	}
378 | 	if resp.StatusCode != http.StatusOK {
379 | 		defer func(Body io.ReadCloser) {
380 | 			_ = Body.Close()
381 | 		}(resp.Body)
382 | 		body, err := io.ReadAll(resp.Body)
383 | 		if err != nil {
384 | 			return SigningLimits{}, fmt.Errorf("bad status getting rate_limts %s(%d), cannot read body: %w", resp.Status, resp.StatusCode, err)
385 | 		}
386 | 		return SigningLimits{}, fmt.Errorf("bad status getting rate_limits %s(%d), %s", resp.Status, resp.StatusCode, string(body))
387 | 	}
388 | 	jsonR := resp.Body
389 | 	defer func(jsonR io.ReadCloser) {
390 | 		_ = jsonR.Close()
391 | 	}(jsonR)
392 | 	limits := SigningLimits{}
393 | 	err = json.NewDecoder(jsonR).Decode(&limits)
394 | 	if err != nil {
395 | 		return SigningLimits{}, err
396 | 	}
397 | 	return limits, nil
398 | }
399 | 


--------------------------------------------------------------------------------
/utils.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"encoding/base64"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"log/slog"
  8 | 	"math/rand"
  9 | 	"time"
 10 | 
 11 | 	"github.com/erni27/imcache"
 12 | 	pb "github.com/steampoweredtaco/gotiktoklive/proto"
 13 | 	"google.golang.org/protobuf/proto"
 14 | 	"google.golang.org/protobuf/reflect/protoreflect"
 15 | 	"google.golang.org/protobuf/reflect/protoregistry"
 16 | )
 17 | 
 18 | const (
 19 | 	messageHistoryTimeout = 15 * time.Minute
 20 | )
 21 | 
 22 | var (
 23 | 	msgIDCache imcache.Cache[int64, struct{}]
 24 | )
 25 | 
 26 | func getRandomDeviceID() string {
 27 | 	const chars = "0123456789"
 28 | 	b := make([]byte, 20)
 29 | 	for i := range b {
 30 | 		b[i] = chars[rand.Intn(len(chars))]
 31 | 	}
 32 | 	return string(b)
 33 | }
 34 | 
 35 | func parseMsg(msg *pb.WebcastResponse_Message, warnHandler func(...interface{}), debugHandler func(...interface{}), enableExperimentalEvents bool) (out Event, err error) {
 36 | 	tReflect, err := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(msg.Method))
 37 | 	if err != nil {
 38 | 		base := base64.RawStdEncoding.EncodeToString(msg.Payload)
 39 | 		debugHandler(fmt.Sprintf("cannot find type %s:\n%s ", msg.Method, base))
 40 | 		return nil, nil
 41 | 	}
 42 | 	m := tReflect.New().Interface()
 43 | 	if err = proto.Unmarshal(msg.Payload, m); err != nil {
 44 | 		base := base64.RawStdEncoding.EncodeToString(msg.Payload)
 45 | 		err = fmt.Errorf("failed to unmarshal proto %T: %w\n%s", m, err, base)
 46 | 		debugHandler(err)
 47 | 		warnHandler(fmt.Errorf("failed to unmarshal proto %T: %w", m, err))
 48 | 		return nil, nil
 49 | 	}
 50 | 	switch pt := m.(type) {
 51 | 	case *pb.RoomMessage:
 52 | 		return RoomEvent{
 53 | 			MessageID: pt.Common.MsgId,
 54 | 			Timestamp: pt.Common.CreateTime,
 55 | 			Type:      pt.Common.Method,
 56 | 			Message:   pt.Content,
 57 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
 58 | 		}, nil
 59 | 	case *pb.WebcastRoomPinMessage:
 60 | 		{
 61 | 			tReflect, err := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(pt.OriginalMsgType))
 62 | 			if err != nil {
 63 | 				base := base64.RawStdEncoding.EncodeToString(msg.Payload)
 64 | 				debugHandler("cannot find proto type for pin message %s:\n%s ", msg.Method, base)
 65 | 				return RoomEvent{
 66 | 					MessageID: msg.MsgId,
 67 | 					Timestamp: pt.Common.CreateTime,
 68 | 					Type:      pt.OriginalMsgType,
 69 | 					Message:   "<unknown>",
 70 | 					isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
 71 | 				}, nil
 72 | 			}
 73 | 			m := tReflect.New().Interface()
 74 | 			if err = proto.Unmarshal(pt.PinnedMessage, m); err != nil {
 75 | 				base := base64.RawStdEncoding.EncodeToString(msg.Payload)
 76 | 				err = fmt.Errorf("failed to unmarshal proto %T: %w\n%s", m, err, base)
 77 | 				debugHandler(err)
 78 | 				warnHandler(fmt.Errorf("failed to unmarshal proto %T: %w", m, err))
 79 | 				return RoomEvent{
 80 | 					MessageID: msg.MsgId,
 81 | 					Timestamp: pt.Common.CreateTime,
 82 | 					Type:      pt.OriginalMsgType,
 83 | 					Message:   "<unknown>",
 84 | 					isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
 85 | 				}, nil
 86 | 			}
 87 | 
 88 | 			typeStr := pt.OriginalMsgType
 89 | 			msgPinned := "<unknown pinned type>"
 90 | 			switch pt2 := m.(type) {
 91 | 			// Todo make a pin return type
 92 | 			case *pb.WebcastChatMessage:
 93 | 				return ChatEvent{
 94 | 					MessageID: pt.Common.MsgId,
 95 | 					Timestamp: pt.Common.CreateTime,
 96 | 					Comment:   "<pinned>: " + pt2.Content,
 97 | 					User:      toUser(pt2.User),
 98 | 					isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
 99 | 				}, nil
100 | 			default:
101 | 				base := base64.RawStdEncoding.EncodeToString(pt.PinnedMessage)
102 | 				err = fmt.Errorf("unimplemented pinned message type %T\n%s", m, base)
103 | 				debugHandler(err)
104 | 				warnHandler(fmt.Sprintf("unimplemented pinned message type %T", m))
105 | 
106 | 			}
107 | 			return RoomEvent{
108 | 				MessageID: pt.Common.MsgId,
109 | 				Timestamp: pt.Common.CreateTime,
110 | 				Type:      typeStr,
111 | 				Message:   msgPinned,
112 | 				isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
113 | 			}, nil
114 | 		}
115 | 	case *pb.WebcastChatMessage:
116 | 		return ChatEvent{
117 | 			MessageID:    pt.Common.MsgId,
118 | 			Comment:      pt.Content,
119 | 			User:         toUser(pt.User),
120 | 			UserIdentity: toUserIdentity(pt.UserIdentity),
121 | 			Timestamp:    pt.Common.CreateTime,
122 | 			isHistory:    msg.IsHistory || cachedHistory(pt.Common.MsgId),
123 | 		}, nil
124 | 	case *pb.WebcastMemberMessage:
125 | 		return UserEvent{
126 | 			MessageID: pt.Common.MsgId,
127 | 			Timestamp: pt.Common.CreateTime,
128 | 			Event:     toUserType(pt.Action.String()),
129 | 			User:      toUser(pt.User),
130 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
131 | 		}, nil
132 | 	case *pb.WebcastLiveGameIntroMessage:
133 | 		return RoomEvent{
134 | 			MessageID: pt.Common.MsgId,
135 | 			Timestamp: pt.Common.CreateTime,
136 | 			Type:      pt.Common.Method,
137 | 			Message:   pt.GameText.DefaultPattern,
138 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
139 | 		}, nil
140 | 	case *pb.WebcastRoomMessage:
141 | 		return RoomEvent{
142 | 			MessageID: pt.Common.MsgId,
143 | 			Timestamp: pt.Common.CreateTime,
144 | 			Type:      pt.Common.Method,
145 | 			// TODO: Make this actually use pieces list and fill out the format text correctly.
146 | 			Message:   pt.Common.DisplayText.DefaultPattern,
147 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
148 | 		}, nil
149 | 	case *pb.WebcastRoomUserSeqMessage:
150 | 		return ViewersEvent{
151 | 			MessageID: pt.Common.MsgId,
152 | 			Timestamp: pt.Common.CreateTime,
153 | 			Viewers:   int(pt.Total),
154 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
155 | 		}, nil
156 | 	case *pb.WebcastSocialMessage:
157 | 		return UserEvent{
158 | 			MessageID: pt.Common.MsgId,
159 | 			Timestamp: pt.Common.CreateTime,
160 | 			Event:     toUserType(pt.Common.DisplayText.Key),
161 | 			User:      toUser(pt.User),
162 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
163 | 		}, nil
164 | 	case *pb.WebcastGiftMessage:
165 | 		if pt.GiftId == 0 && pt.User == nil {
166 | 			return nil, nil
167 | 		}
168 | 
169 | 		return GiftEvent{
170 | 			MessageID:    pt.Common.MsgId,
171 | 			Timestamp:    pt.Common.CreateTime,
172 | 			ID:           pt.GiftId,
173 | 			GroupID:      pt.GroupId,
174 | 			Name:         pt.Gift.Name,
175 | 			Describe:     pt.Gift.Describe,
176 | 			Diamonds:     int(pt.Gift.DiamondCount),
177 | 			RepeatCount:  int(pt.RepeatCount),
178 | 			RepeatEnd:    pt.RepeatEnd == 1,
179 | 			Type:         int(pt.Gift.Type),
180 | 			ToUserID:     int64(pt.UserGiftReciever.UserId),
181 | 			User:         toUser(pt.User),
182 | 			UserIdentity: toUserIdentity(pt.UserIdentity),
183 | 			isHistory:    msg.IsHistory || cachedHistory(pt.Common.MsgId),
184 | 			IsComboGift:  pt.GroupId != 0,
185 | 		}, nil
186 | 	case *pb.WebcastLikeMessage:
187 | 		return LikeEvent{
188 | 			MessageID:   pt.Common.MsgId,
189 | 			Timestamp:   pt.Common.CreateTime,
190 | 			Likes:       int(pt.Count),
191 | 			TotalLikes:  int(pt.Total),
192 | 			User:        toUser(pt.User),
193 | 			DisplayType: pt.Common.Method,
194 | 			Label:       pt.Common.DisplayText.String(),
195 | 			isHistory:   msg.IsHistory || cachedHistory(pt.Common.MsgId),
196 | 		}, nil
197 | 
198 | 	case *pb.WebcastQuestionNewMessage:
199 | 		return QuestionEvent{
200 | 			MessageID: pt.Common.MsgId,
201 | 			Timestamp: pt.Common.CreateTime,
202 | 			Quesion:   pt.Details.Text,
203 | 			User:      toUser(pt.Details.User),
204 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
205 | 		}, nil
206 | 
207 | 	case *pb.WebcastControlMessage:
208 | 		return ControlEvent{
209 | 			MessageID:   pt.Common.MsgId,
210 | 			Timestamp:   pt.Common.CreateTime,
211 | 			Action:      int(pt.Action),
212 | 			Description: pt.Action.String(),
213 | 			isHistory:   msg.IsHistory || cachedHistory(pt.Common.MsgId),
214 | 		}, nil
215 | 
216 | 	case *pb.WebcastLinkMicBattle:
217 | 		users := []*User{}
218 | 		for _, u := range pt.HostTeam {
219 | 			groups := u.HostGroup
220 | 			for _, group := range groups {
221 | 				for _, user := range group.Host {
222 | 					urls := make([]string, 5)
223 | 					for _, img := range user.Images {
224 | 						urls = append(urls, img.UrlList...)
225 | 					}
226 | 					users = append(users, &User{
227 | 						ID:       int64(user.Id),
228 | 						Username: user.ProfileId,
229 | 						Nickname: user.Name,
230 | 						ProfilePicture: &ProfilePicture{
231 | 							Urls: urls,
232 | 						},
233 | 					})
234 | 
235 | 				}
236 | 
237 | 			}
238 | 		}
239 | 		return MicBattleEvent{
240 | 			MessageID: pt.Common.MsgId,
241 | 			Timestamp: pt.Common.CreateTime,
242 | 			Users:     users,
243 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
244 | 		}, nil
245 | 
246 | 	case *pb.WebcastLinkMicArmies:
247 | 		battles := []*Battle{}
248 | 		for _, b := range pt.BattleItems {
249 | 			battle := &Battle{
250 | 				Host:   int64(b.HostUserId),
251 | 				Groups: []*BattleGroup{},
252 | 			}
253 | 			for _, g := range b.BattleGroups {
254 | 				group := BattleGroup{
255 | 					Points: int(g.Points),
256 | 					Users:  []*User{},
257 | 				}
258 | 				for _, u := range g.Users {
259 | 					group.Users = append(group.Users, toUser(u))
260 | 				}
261 | 				battle.Groups = append(battle.Groups, &group)
262 | 			}
263 | 			battles = append(battles, battle)
264 | 		}
265 | 		return BattlesEvent{
266 | 			MessageID: pt.Common.MsgId,
267 | 			Timestamp: pt.Common.CreateTime,
268 | 			Status:    int(pt.BattleStatus),
269 | 			Battles:   battles,
270 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
271 | 		}, nil
272 | 	case *pb.WebcastLiveIntroMessage:
273 | 		return IntroEvent{
274 | 			MessageID: pt.Common.MsgId,
275 | 			Timestamp: pt.Common.CreateTime,
276 | 			ID:        int(pt.RoomId),
277 | 			Title:     pt.Content,
278 | 			User:      toUser(pt.Host),
279 | 			isHistory: msg.IsHistory || cachedHistory(pt.Common.MsgId),
280 | 		}, nil
281 | 
282 | 	case *pb.WebcastInRoomBannerMessage:
283 | 		var data interface{}
284 | 		// TODO: should we make a type for this instead of unmarshalling to see it is an error then feeding it up?
285 | 		err = json.Unmarshal([]byte(pt.GetJson()), &data)
286 | 		if err != nil {
287 | 			return nil, fmt.Errorf("WebcastInRoomBannerMessage: %w\n%s", err, data)
288 | 		}
289 | 
290 | 		return RoomBannerEvent{
291 | 			MessageID: pt.Header.MsgId,
292 | 			Timestamp: pt.Header.CreateTime,
293 | 			Data:      data,
294 | 			isHistory: msg.IsHistory || cachedHistory(pt.Header.MsgId),
295 | 		}, nil
296 | 
297 | 	default:
298 | 		base := base64.RawStdEncoding.EncodeToString(msg.Payload)
299 | 		err = fmt.Errorf("unimplemented type %T\n%s", m, base)
300 | 		debugHandler(err)
301 | 		warnHandler(fmt.Sprintf("unimplemented type %T", m))
302 | 		return nil, nil
303 | 	}
304 | }
305 | 
306 | func cachedHistory(id int64) bool {
307 | 	_, present := msgIDCache.GetOrSet(id, struct{}{}, imcache.WithExpiration(messageHistoryTimeout))
308 | 	return present
309 | }
310 | 
311 | func defaultLogHandler(i ...interface{}) {
312 | 	slog.Debug(fmt.Sprint(i...), "logger", "gotiktoklive-default")
313 | }
314 | 
315 | func routineErrHandler(err ...interface{}) {
316 | 	slog.Debug(fmt.Sprint(err...), "logger", "gotiktoklive-default")
317 | }
318 | 
319 | func toUser(u *pb.User) *User {
320 | 	if u == nil {
321 | 		return &User{}
322 | 	}
323 | 	username := u.IdStr
324 | 	if u.IdStr == "" {
325 | 		username = u.Nickname
326 | 	}
327 | 	user := User{
328 | 		ID:       int64(u.Id),
329 | 		Username: username,
330 | 		Nickname: u.Nickname,
331 | 	}
332 | 
333 | 	if u.AvatarLarge != nil && u.AvatarJpg.UrlList != nil {
334 | 		user.ProfilePicture = &ProfilePicture{
335 | 			Urls: u.AvatarJpg.UrlList,
336 | 		}
337 | 	}
338 | 
339 | 	user.ExtraAttributes = &ExtraAttributes{
340 | 		FollowRole: int(u.UserRole),
341 | 	}
342 | 
343 | 	if u.BadgeList != nil {
344 | 		var badges []*UserBadge
345 | 		for _, badge := range u.BadgeList {
346 | 			badges = append(badges, &UserBadge{
347 | 				Type: badge.DisplayType.String(),
348 | 				Name: badge.String(),
349 | 			})
350 | 		}
351 | 		user.Badge = &BadgeAttributes{
352 | 			Badges: badges,
353 | 		}
354 | 	}
355 | 	return &user
356 | }
357 | 
358 | func toUserIdentity(uid *pb.UserIdentity) *UserIdentity {
359 | 	if uid == nil {
360 | 		return nil
361 | 	}
362 | 	return &UserIdentity{
363 | 		IsGiftGiver:       uid.IsGiftGiverOfAnchor,
364 | 		IsSubscriber:      uid.IsSubscriberOfAnchor,
365 | 		IsMutualFollowing: uid.IsMutualFollowingWithAnchor,
366 | 		IsFollower:        uid.IsFollowerOfAnchor,
367 | 		IsModerator:       uid.IsModeratorOfAnchor,
368 | 		IsAnchor:          uid.IsAnchor,
369 | 	}
370 | }
371 | 
372 | func copyMap(m map[string]string) map[string]string {
373 | 	out := make(map[string]string)
374 | 	for key, value := range m {
375 | 		out[key] = value
376 | 	}
377 | 	return out
378 | }
379 | 
380 | func toUserType(displayType string) userEventType {
381 | 	switch displayType {
382 | 	case "pm_main_follow_message_viewer_2":
383 | 		return USER_FOLLOW
384 | 	case "pm_mt_guidance_share":
385 | 		return USER_SHARE
386 | 	case "live_room_enter_toast":
387 | 		return USER_JOIN
388 | 	case "JOINED":
389 | 		return USER_JOIN
390 | 	}
391 | 	return userEventType(fmt.Sprintf("User type not implemented, please report: %s", displayType))
392 | }
393 | 


--------------------------------------------------------------------------------
/live.go:
--------------------------------------------------------------------------------
  1 | package gotiktoklive
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"net"
  9 | 	"net/http"
 10 | 	"net/url"
 11 | 	"os"
 12 | 	"os/exec"
 13 | 	"regexp"
 14 | 	"strconv"
 15 | 	"strings"
 16 | 	"sync"
 17 | 	"time"
 18 | 
 19 | 	"github.com/pkg/errors"
 20 | 	"golang.org/x/net/context"
 21 | 
 22 | 	pb "github.com/steampoweredtaco/gotiktoklive/proto"
 23 | 
 24 | 	"google.golang.org/protobuf/proto"
 25 | )
 26 | 
 27 | // TODO: check gift prices of gifts not in wish list
 28 | 
 29 | const (
 30 | 	DEFAULT_EVENTS_CHAN_SIZE = 100
 31 | )
 32 | 
 33 | // Live allows you to track a livestream.
 34 | // To track a user call tiktok.TrackUser(<user>).
 35 | type Live struct {
 36 | 	t *TikTok
 37 | 
 38 | 	cursor   string
 39 | 	wss      net.Conn
 40 | 	wsURL    string
 41 | 	wsParams map[string]string
 42 | 	close    func()
 43 | 	done     func() <-chan struct{}
 44 | 	cancel   context.CancelFunc
 45 | 
 46 | 	ID       string
 47 | 	Info     *RoomInfo
 48 | 	GiftInfo *GiftInfo
 49 | 	Events   chan Event
 50 | 	chanSize int
 51 | 	wg       *sync.WaitGroup
 52 | }
 53 | 
 54 | func (t *TikTok) newLive(roomId string) *Live {
 55 | 	live := Live{
 56 | 		t:        t,
 57 | 		ID:       roomId,
 58 | 		wg:       &sync.WaitGroup{},
 59 | 		Events:   make(chan Event, DEFAULT_EVENTS_CHAN_SIZE),
 60 | 		chanSize: DEFAULT_EVENTS_CHAN_SIZE,
 61 | 	}
 62 | 	t.mu.Lock()
 63 | 	t.streams += 1
 64 | 	t.mu.Unlock()
 65 | 
 66 | 	ctx, cancel := context.WithCancel(context.Background())
 67 | 	live.cancel = cancel
 68 | 	live.done = ctx.Done
 69 | 	o := sync.Once{}
 70 | 	live.close = func() {
 71 | 		o.Do(func() {
 72 | 			// cancel needs to be first as live.done is used to know to exit in all the
 73 | 			// various goroutines which should release the waitgroup. It is ok for anywhere
 74 | 			// to call cancel to trigger the other routines, but calls to close is only for
 75 | 			// cleanup and block till done
 76 | 			cancel()
 77 | 			live.wss.Close()
 78 | 			live.wg.Wait()
 79 | 			t.mu.Lock()
 80 | 			t.streams -= 1
 81 | 			t.mu.Unlock()
 82 | 		})
 83 | 	}
 84 | 
 85 | 	return &live
 86 | }
 87 | 
 88 | // Close will terminate the connection and stop any downloads.
 89 | func (l *Live) Close() {
 90 | 	l.close()
 91 | }
 92 | 
 93 | func (l *Live) fetchRoom() error {
 94 | 	roomInfo, err := l.getRoomInfo()
 95 | 	if err != nil {
 96 | 		return err
 97 | 	}
 98 | 	l.Info = roomInfo
 99 | 	//
100 | 	// giftInfo, err := l.getGiftInfo()
101 | 	// if err != nil {
102 | 	//	return err
103 | 	// }
104 | 	// l.GiftInfo = giftInfo
105 | 
106 | 	err = l.getRoomData()
107 | 	if err != nil {
108 | 		return err
109 | 	}
110 | 	return nil
111 | }
112 | 
113 | // GetRoomInfo will only fetch the room info, normally available with live.Info
114 | //
115 | //	but not start tracking a live stream.
116 | func (t *TikTok) GetRoomInfo(username string) (*RoomInfo, error) {
117 | 	id, err := t.getRoomID(username)
118 | 	if err != nil {
119 | 		return nil, errors.Wrap(err, "Failed to fetch room ID by username")
120 | 	}
121 | 
122 | 	l := Live{
123 | 		t:  t,
124 | 		ID: id,
125 | 	}
126 | 
127 | 	roomInfo, err := l.getRoomInfo()
128 | 	if err != nil {
129 | 		return nil, errors.Wrap(err, "Failed to fetch room info")
130 | 	}
131 | 	return roomInfo, nil
132 | }
133 | 
134 | // TrackUser will start to track the livestream of a user, if live.
135 | // To listen to events emitted by the livestream, such as comments and viewer
136 | //
137 | //	count, listen to the Live.Events channel.
138 | //
139 | // It will start a go routine and connect to the tiktok websocket.
140 | func (t *TikTok) TrackUser(username string) (*Live, error) {
141 | 	id, err := t.getRoomID(username)
142 | 	if err != nil {
143 | 		return nil, err
144 | 	}
145 | 
146 | 	return t.TrackRoom(id)
147 | }
148 | 
149 | // TrackRoom will start to track a room by room ID.
150 | // It will start a go routine and connect to the tiktok websocket.
151 | func (t *TikTok) TrackRoom(roomId string) (*Live, error) {
152 | 	live := t.newLive(roomId)
153 | 
154 | 	if err := live.fetchRoom(); err != nil {
155 | 		close(live.Events)
156 | 		return nil, err
157 | 	}
158 | 
159 | 	if err := live.connectRoom(); err != nil {
160 | 		return nil, err
161 | 	}
162 | 
163 | 	return live, nil
164 | }
165 | 
166 | func (live *Live) connectRoom() error {
167 | 	return live.tryConnectionUpgrade()
168 | }
169 | 
170 | func (t *TikTok) getRoomID(user string) (string, error) {
171 | 	userInfo, err := t.GetUserInfo(user)
172 | 	if err != nil {
173 | 		return "", err
174 | 	}
175 | 
176 | 	if userInfo.RoomID == "" {
177 | 		return "", ErrUserOffline
178 | 	}
179 | 	return userInfo.RoomID, nil
180 | }
181 | 
182 | func (l *Live) getRoomInfo() (*RoomInfo, error) {
183 | 	t := l.t
184 | 
185 | 	params := copyMap(defaultGETParams)
186 | 	params["room_id"] = l.ID
187 | 
188 | 	body, _, err := t.sendRequest(&reqOptions{
189 | 		Endpoint: urlRoomInfo,
190 | 		Query:    params,
191 | 	}, nil)
192 | 	if err != nil {
193 | 		return nil, err
194 | 	}
195 | 
196 | 	var rsp roomInfoRsp
197 | 	if err := json.Unmarshal(body, &rsp); err != nil {
198 | 		return nil, err
199 | 	}
200 | 
201 | 	if rsp.RoomInfo.Status == 4 {
202 | 		return rsp.RoomInfo, ErrLiveHasEnded
203 | 	}
204 | 	return rsp.RoomInfo, nil
205 | }
206 | 
207 | func (l *Live) getGiftInfo() (*GiftInfo, error) {
208 | 	t := l.t
209 | 
210 | 	params := copyMap(defaultGETParams)
211 | 	params["room_id"] = l.ID
212 | 
213 | 	body, _, err := t.sendRequest(&reqOptions{
214 | 		Endpoint: urlGiftInfo,
215 | 		Query:    params,
216 | 	}, nil)
217 | 	if err != nil {
218 | 		return nil, err
219 | 	}
220 | 
221 | 	var rsp giftInfoRsp
222 | 	if err := json.Unmarshal(body, &rsp); err != nil {
223 | 		return nil, err
224 | 	}
225 | 	return rsp.GiftInfo, nil
226 | }
227 | 
228 | func (l *Live) getRoomData() error {
229 | 	t := l.t
230 | 
231 | 	params := copyMap(defaultGETParams)
232 | 	params["room_id"] = l.ID
233 | 	params["device_id"] = getRandomDeviceID()
234 | 	if l.cursor != "" {
235 | 		params["cursor"] = l.cursor
236 | 	}
237 | 
238 | 	body, headers, err := t.sendRequest(&reqOptions{
239 | 		Endpoint: urlRoomData,
240 | 		Query:    params,
241 | 	}, nil)
242 | 	if err != nil {
243 | 		return err
244 | 	}
245 | 	ttsCookie := headers.Get("X-Set-TT-Cookie")
246 | 	cookies, err := http.ParseCookie(ttsCookie)
247 | 	if err != nil {
248 | 		return fmt.Errorf("X-SetTT-Cookie not parsable: %w", err)
249 | 	}
250 | 
251 | 	for i := range cookies {
252 | 		cookies[i].Domain = ".tiktok.com"
253 | 	}
254 | 	u, err := url.Parse("https://tiktok.com")
255 | 	if err != nil {
256 | 		return fmt.Errorf("semantica error couldnot parse secure cookie endpoint, please report: %w", err)
257 | 	}
258 | 	t.c.Jar.SetCookies(u, cookies)
259 | 
260 | 	var rsp pb.WebcastResponse
261 | 	if err := proto.Unmarshal(body, &rsp); err != nil {
262 | 		return err
263 | 	}
264 | 
265 | 	l.cursor = rsp.Cursor
266 | 	if rsp.PushServer != "" && rsp.RouteParamsMap != nil {
267 | 		l.wsURL = rsp.PushServer
268 | 		l.wsParams = make(map[string]string)
269 | 		for k, v := range rsp.RouteParamsMap {
270 | 			l.wsParams[k] = v
271 | 		}
272 | 
273 | 	}
274 | 
275 | 	for _, msg := range rsp.Messages {
276 | 		parsed, err := parseMsg(msg, t.warnHandler, t.debugHandler, t.enableExperimentalEvents)
277 | 		if err != nil {
278 | 			return err
279 | 		}
280 | 		if parsed == nil {
281 | 			// This might happen due to some ignorable messages
282 | 			// but can cause problems if we send the events upstream
283 | 			continue
284 | 		}
285 | 		l.Events <- parsed
286 | 	}
287 | 
288 | 	return nil
289 | }
290 | 
291 | // DownloadStream will download the stream to an .mkv file.
292 | //
293 | // A filename can be optionally provided as an argument, if not provided one
294 | //
295 | //	will be generated, with the stream start time in the format of 2022y05m25dT13h03m16s.
296 | //
297 | // The stream start time can be found in Live.Info.CreateTime as epoch seconds.
298 | func (l *Live) DownloadStream(file ...string) error {
299 | 	// Check if ffmpeg is installed
300 | 	if _, err := exec.LookPath("ffmpeg"); err != nil {
301 | 		return ErrFFMPEGNotFound
302 | 	}
303 | 
304 | 	// Get URl
305 | 	url := l.Info.StreamURL.HlsPullURL
306 | 	if url == "" {
307 | 		return ErrURLNotFound
308 | 	}
309 | 
310 | 	// Set file path
311 | 	var path string
312 | 	format := ".mkv"
313 | 	if len(file) > 0 {
314 | 		path = file[0]
315 | 		if !strings.HasSuffix(path, format) {
316 | 			path += format
317 | 		}
318 | 	} else {
319 | 		path = fmt.Sprintf("%s-%s%s", l.Info.Owner.Username, time.Unix(l.Info.CreateTime, 0).Format("2006y01m02dT15h04m05s"), format)
320 | 	}
321 | 	if _, err := os.Stat(path); err == nil {
322 | 		t := strings.TrimSuffix(path, format)
323 | 		path = fmt.Sprintf("%s-%d%s", t, time.Now().Unix(), format)
324 | 	}
325 | 
326 | 	options := []string{}
327 | 	if l.t.proxy != nil && (l.t.proxy.Scheme == "http" || l.t.proxy.Scheme == "https") {
328 | 		options = append([]string{"-http_proxy", l.t.proxy.String()}, options...)
329 | 	}
330 | 	options = append(options, []string{"-i", url}...)
331 | 	// important to come after the -i
332 | 	options = append(options, "-c:v", "libx264", "-c:a", "aac", "-bufsize", "2M", "-fflags", "+discardcorrupt",
333 | 		"-fflags", "+genpts", path)
334 | 	ctx, cancel := context.WithCancel(context.Background())
335 | 	cmd := exec.CommandContext(ctx, "ffmpeg", options...)
336 | 
337 | 	stdin, err := cmd.StdinPipe()
338 | 	if err != nil {
339 | 		return err
340 | 	}
341 | 
342 | 	stdout, err := cmd.StdoutPipe()
343 | 	if err != nil {
344 | 		return err
345 | 	}
346 | 
347 | 	stderr, err := cmd.StderrPipe()
348 | 	if err != nil {
349 | 		return err
350 | 	}
351 | 
352 | 	if err := cmd.Start(); err != nil {
353 | 		return err
354 | 	}
355 | 
356 | 	mu := new(sync.Mutex)
357 | 	finished := false
358 | 
359 | 	go func(c *exec.Cmd) {
360 | 	drainFor:
361 | 		for {
362 | 			select {
363 | 			case <-l.done():
364 | 				break drainFor
365 | 			// Needs to be drained or deadlocks can occur, maybe at some point make a download option
366 | 			// where the library user needs to drain
367 | 			case _, ok := <-l.Events:
368 | 				if !ok {
369 | 					break drainFor
370 | 				}
371 | 			}
372 | 		}
373 | 		mu.Lock()
374 | 		func() {
375 | 			defer mu.Unlock()
376 | 			if !finished {
377 | 				// Send q key press to quit
378 | 				stdin.Write([]byte("q\n"))
379 | 				time.Sleep(5 * time.Second)
380 | 			}
381 | 			cancel()
382 | 		}()
383 | 		// naturally should be closed, but keep draining to prevent deadlocks
384 | 		for {
385 | 			if _, ok := <-l.Events; !ok {
386 | 				break
387 | 			}
388 | 		}
389 | 	}(cmd)
390 | 
391 | 	// Go routine to wait for process to exit and return result
392 | 	l.wg.Add(1)
393 | 	go func(c *exec.Cmd, stdout, stderr io.ReadCloser) {
394 | 		defer l.wg.Done()
395 | 		removeNewlineExp := regexp.MustCompile(`[\r\n]+$`)
396 | 		streamWG := new(sync.WaitGroup)
397 | 		streamWG.Add(2)
398 | 		go func() {
399 | 			defer streamWG.Done()
400 | 			r := bufio.NewReader(stdout)
401 | 			for {
402 | 				str, err := r.ReadString('\n')
403 | 				if err != nil {
404 | 					return
405 | 				}
406 | 				l.t.debugHandler(removeNewlineExp.ReplaceAllString(str, ""))
407 | 			}
408 | 		}()
409 | 
410 | 		go func() {
411 | 			defer streamWG.Done()
412 | 			r := bufio.NewReader(stderr)
413 | 			for {
414 | 				str, err := r.ReadString('\n')
415 | 				if err != nil {
416 | 					return
417 | 				}
418 | 				l.t.debugHandler(removeNewlineExp.ReplaceAllString(str, ""))
419 | 			}
420 | 		}()
421 | 		streamWG.Wait()
422 | 		err := cmd.Wait()
423 | 		mu.Lock()
424 | 		defer mu.Unlock()
425 | 		finished = true
426 | 		if err != nil {
427 | 			l.t.errHandler(fmt.Sprintf("Download for failed: %s", err))
428 | 		}
429 | 		return
430 | 		l.t.infoHandler(fmt.Sprintf("Download for %s finished!", l.Info.Owner.Username))
431 | 	}(cmd, stdout, stderr)
432 | 	l.wg.Wait()
433 | 	l.t.infoHandler(fmt.Sprintf("Started downloading stream by %s to %s\n", l.Info.Owner.Username, path))
434 | 
435 | 	return nil
436 | }
437 | 
438 | func (t *TikTok) signURL(reqUrl string, options *reqOptions) ([]byte, http.Header, error) {
439 | 	query := map[string]string{
440 | 		"client":  t.clientName,
441 | 		"uuc":     strconv.Itoa(t.streams),
442 | 		"url":     reqUrl,
443 | 		"room_id": options.Query["room_id"],
444 | 	}
445 | 	if t.apiKey != "" {
446 | 		query["apiKey"] = t.apiKey
447 | 	}
448 | 	// A badly formed implementation using this library might spam connection requests (ask me
449 | 	// how I know) this limiter is a safety guard to never go over the signer's advertised
450 | 	// capabilities so the client does not exceed limits or get banned from the signer.
451 | 	t.limiter.Take()
452 | 	body, header, err := t.sendRequest(&reqOptions{
453 | 		URI:      t.signerUrl,
454 | 		Endpoint: urlSignReq,
455 | 		Query:    query,
456 | 	}, nil)
457 | 	if err != nil {
458 | 		return nil, nil, errors.Wrap(err, fmt.Sprintf("Failed to sign request: %s", body))
459 | 	}
460 | 
461 | 	return body, header, nil
462 | }
463 | 
464 | // Only able to get this while logged in
465 | // func (l *Live) GetRankList() (*RankList, error) {
466 | // 	t := l.t
467 | //
468 | // 	params := copyMap(defaultGETParams)
469 | // 	params["room_id"] = l.ID
470 | // 	params["channel"] = "tiktok_web"
471 | // 	params["anchor_id"] = "idk"
472 | //
473 | // 	body, err := t.sendRequest(&reqOptions{
474 | // 		Endpoint: urlRankList,
475 | // 		Query:    params,
476 | // 	})
477 | // 	if err != nil {
478 | // 		return nil, err
479 | // 	}
480 | //
481 | // 	var rsp rankListRsp
482 | // 	if err := json.Unmarshal(body, &rsp); err != nil {
483 | // 		return nil, err
484 | // 	}
485 | //
486 | // 	return &rsp.RankList, nil
487 | // }
488 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![GoDoc](https://godoc.org/github.com/steampoweredtaco/gotiktoklive?status.svg)](https://godoc.org/github.com/steampoweredtaco/gotiktoklive) [![Go Report Card](https://goreportcard.com/badge/github.com/steampoweredtaco/gotiktoklive)](https://goreportcard.com/report/github.com/steampoweredtaco/gotiktoklive)
  2 | 
  3 | # WARNING this fork of [Davincible's GotTikTokLive](https://github.com/Davincible/gotiktoklive) is in an alpha state at the moment
  4 | 
  5 | # To add to project
  6 | `go get github.com/steampoweredtaco/gotiktoklive`
  7 | 
  8 | # Do not use any v1.0.7-8 tags
  9 | These tags are bogus and have been retracted and should not be grabbed via `go get` any longer. As of now v0 tags are the only valid tags.
 10 | 
 11 | ## Current Known working state of implementation
 12 | - [x] Using the new signing server and endpoints and can provide API key and secret
 13 | - [x] working live user and room id tracking
 14 | - [x] updated protobuf version 3 messages and synced with python's types
 15 | - [x] Websocket event system
 16 | - [x] GetPriceList
 17 | - [x] DownloadStream (18+ with id_session not verified)
 18 | 
 19 | ## Planned updates
 20 | - [ ] Support many of the new event features over the last two years
 21 |    * [ ] Pinned webchat messages, currently in alpha using ChatMessage event type, will move to a new type.
 22 |    * [ ] Intro messages for live stream categories, these currently will be RoomEvents
 23 |      * [x] WebcastLiveGameIntroMessage 
 24 |      * Others TBD.
 25 | 
 26 | ## Unknown state:
 27 | - GetUserInfo
 28 | - GetRoomInfo
 29 | - NewFeed
 30 | - Using session_id functionality
 31 | 
 32 | # GoTikTokLive
 33 | 
 34 | A Go module to download livestreams and discover, receive and decode livestreams and the livestream events such as comments and gifts in realtime from [TikTok LIVE](https://www.tiktok.com/live) by connecting to TikTok's internal WebCast push service. The package includes a wrapper that connects to the WebCast service using just the username (`uniqueId`). This allows you to connect to your own live chat as well as the live chat of other streamers. No credentials are required. Besides [Chat Comments](#ChatEvent), other events such as [Members Joining](#UserEvent), [Gifts](#GiftEvent), [Viewers](#ViewersEvent), [Follows](#UserEvent), [Shares](#UserEvent), [Questions](#QuestionEvent), [Likes](#LikeEvent) and [Battles](#BattlesEvent) can be tracked.
 35 | 
 36 | Looking for a Python implementation of this library? Check out [TikTok-Live-Connector](https://github.com/isaackogan/TikTok-Live-Connector) by [**@isaackogan**](https://github.com/isaackogan)
 37 | 
 38 | Looking for a Node.js implementation of this library? Check out [TikTok-Livestream-Chat-Connector](https://github.com/zerodytrash/TikTok-Livestream-Chat-Connector) by [**@zerodytrash**](https://github.com/zerodytrash)
 39 | 
 40 | **NOTE:** This is not an official API, and is no way affiliated to or sponsored by TikTok.
 41 | 
 42 | Go rewrite of [zerodytrash/TikTok-Livestream-Chat-Connector](https://github.com/zerodytrash/TikTok-Livestream-Chat-Connector)
 43 | 
 44 | #### Overview
 45 | 
 46 | - [Getting started](#getting-started)
 47 | - [Options](#options)
 48 | - [Methods](#methods)
 49 | - [Events](#events)
 50 | - [Examples](#examples)
 51 | - [Contributing](#contributing)
 52 | 
 53 | ## Getting started
 54 | 1. Install the package using the Go package manager
 55 | ```sh
 56 | go get github.com/steampoweredtaco/gotiktoklive
 57 | ```
 58 | 2. Create your first chat connection
 59 | 
 60 | ```go
 61 | // Create TikTok Instance
 62 | tiktok := gotiktoklive.NewTikTok()
 63 | 
 64 | // Track a TikTok user by username
 65 | live, err := tiktok.TrackUser("promobot.robots")
 66 | if err != nil {
 67 |     panic(err)
 68 | }
 69 | 
 70 | // Start downloading stream Make sure you have the ffmpeg binary installed, and present in
 71 | // your path.
 72 | if err := live.DownloadStream(); err != nil {
 73 |     panic(err)
 74 | }
 75 | 
 76 | // Receive livestream events through the live.Events channel
 77 | for event := range live.Events {
 78 |     switch e := event.(type) {
 79 | 
 80 |     // You can specify what to do for specific events. All events are listed below.
 81 |     case gotiktoklive.UserEvent:
 82 |         fmt.Printf("%T : %s %s\n", e, e.Event, e.User.Username)
 83 | 
 84 |     // List viewer count
 85 |     case gotiktoklive.ViewersEvent:
 86 |         fmt.Printf("%T : %d\n", e, e.Viewers)
 87 | 
 88 |     // Specify the action for all remaining events
 89 |     default:
 90 |         fmt.Printf("%T : %+v\n", e, e)
 91 |     }
 92 | }
 93 | ```
 94 | ## Options
 95 | Options are used when creating a new TikTokLive instance and are used to modify the default behavior of the system in various ways.
 96 | 
 97 | ```go
 98 | // SigningApiKey sets the singer API key.
 99 | func SigningApiKey(apiKey string) TikTokLiveOption {}
100 | 
101 | // SigningUrl defines the signer. The default is https://tiktok.eulerstream.com. Supports
102 | // any signer that supports the signing api as defined by
103 | // https://www.eulerstream.com/docs/openapi
104 | func (url string) TikTokLiveOption {}
105 | 
106 | // DisableSigningLimitsValidation will disable querying the signer for limits and using
107 | // those as the reasonable limits for signing requests per second. Instead, this library
108 | // will be limited to signing only 5 signing requests per minute and may limit
109 | // functionality compared to the request limit the signer provides.
110 | func DisableSigningLimitsValidation(t *TikTok) {}
111 | 
112 | // EnableExperimentalEvents enables experimental events that have not been figured out yet
113 | // and the API for them is not stable. It may also induce additional logging that might be
114 | // undesirable.
115 | func EnableExperimentalEvents(t *TikTok) {}
116 | 
117 | // EnableExtraWebCastDebug an unreasonable amount of debug for library development and
118 | // troubleshooting. This option makes no guarantee of ever having the same output and is
119 | // only for development and triage purposes.
120 | func EnableExtraWebCastDebug(t *TikTok) {}
121 | 
122 | // EnableWSTrace will put traces for all websocket messages into the given file. The file
123 | // will be overwritten so if you want multiple traces make sure handle giving a unique
124 | // filename each startup.
125 | func EnableWSTrace(file string) func(t *TikTok) {}
126 | ```
127 | ### Example Usage
128 | ```go
129 | // Create TikTok instance, do not reconnect when tracking and use an API key for the
130 | // signer
131 | tiktok := gotiktoklive.NewTikTok(SigningApiKey("<secretkey>"), DisableSigningLimitsValidation)
132 | 
133 | ```
134 | ## Methods
135 | 
136 | ```go
137 | // TikTok allows you to track and discover current live streams.
138 | type TikTok struct {
139 | 
140 | 	Debug bool
141 | 
142 | 	// LogRequests when set to true will log all made requests in JSON to debugHandler
143 | 	LogRequests bool
144 | }
145 | 
146 | // NewTikTok creates a tiktok instance that allows you to track live streams
147 | //  and discover current livestreams.
148 | func NewTikTok() *TikTok {}
149 | 
150 | // TrackUser will start to track the livestream of a user, if live.
151 | // To listen to events emitted by the livestream, such as comments and viewer
152 | //  count, listen to the Live.Events channel.
153 | // It will start a go routine and connect to the tiktok websocket.
154 | func (t *TikTok) TrackUser(username string) (*Live, error) {}
155 | 
156 | // TrackRoom will start to track a room by room ID.
157 | // It will start a go routine and connect to the tiktok websocket.
158 | func (t *TikTok) TrackRoom(roomId string) (*Live, error) {}
159 | 
160 | // GetUserInfo will fetch information about the user, such as follwers stats,
161 | //  their user ID, as well as the RoomID, with which you can tell if they are live.
162 | func (t *TikTok) GetUserInfo(user string) (*UserInfo, error) {}
163 | 
164 | // GetRoomInfo will only fetch the room info, normally available with Live.Info
165 | //  but not start tracking a live stream.
166 | func (t *TikTok) GetRoomInfo(username string) (*RoomInfo, error) {}
167 | 
168 | // GetPriceList fetches the price list of tiktok coins. Prices will be given in
169 | //  USD cents and the cents equivalent of the local currency of the IP location.
170 | // To fetch a different currency, use a VPN or proxy to change your IP to a
171 | //  different country.
172 | func (t *TikTok) GetPriceList() (*PriceList, error) {}
173 | 
174 | // NewFeed creates a new Feed instance. Start fetching reccomended livestreams
175 | //  with Feed.Next().
176 | func (t *TikTok) NewFeed() *Feed {}
177 | 
178 | func (t *TikTok) SetDebugHandler(f func(...interface{})) {}
179 | 
180 | func (t *TikTok) SetErrorHandler(f func(error)) {}
181 | 
182 | func (t *TikTok) SetInfoHandler(f func(...interface{})) {}
183 | 
184 | func (t *TikTok) SetWarnHandler(f func(...interface{})) {}
185 | 
186 | // SetProxy will set a proxy for both the http client as well as the websocket.
187 | // You can manually set a proxy with this method, or by using the HTTPS_PROXY
188 | //  environment variable.
189 | // ALL_PROXY can be used to set a proxy only for the websocket.
190 | func (t *TikTok) SetProxy(url string, insecure bool) error {}
191 | ```
192 | 
193 | ## Events
194 | 
195 | - [`RoomEvent`](#RoomEvent)
196 | - [`ChatEvent`](#ChatEvent)
197 | - [`UserEvent`](#UserEvent)
198 | - [`ViewersEvent`](#ViewersEvent)
199 | - [`GiftEvent`](#GiftEvent)
200 | - [`LikeEvent`](#LikeEvent)
201 | - [`QuestionEvent`](#QuestionEvent)
202 | - [`ControlEvent`](#ControlEvent)
203 | - [`MicBattleEvent`](#MicBattleEvent)
204 | - [`BattlesEvent`](#BattlesEvent)
205 | - [`RoomBannerEvent`](#RoomBannerEvent)
206 | - [`IntroEvent`](#IntroEvent)
207 | 
208 | ### RoomEvent
209 | 
210 | Room events are messages broadcast in the room. The most common event, is the
211 | `Type: SystemMessage` at broadcast the beginning a stream gets watched, saying "Welcome to TikTok LIVE! Have fun interacting with others in real-time an
212 | d remember to follow our Community Guidelines."
213 | 
214 | ```go
215 | type RoomEvent struct {
216 | 	Type    string
217 | 	Message string
218 | }
219 | ```
220 | 
221 | ### ChatEvent
222 | 
223 | Chat events are broadcasted when a user posts a chat message, aka comment to a livestream.
224 | 
225 | ```go
226 | type ChatEvent struct {
227 | 	Comment   string
228 | 	User      *User
229 | 	Timestamp int64
230 | }
231 | ```
232 | 
233 | ### UserEvent
234 | 
235 | User events are used when a user either joins the stream, shares the stream, or 
236 | follows the host.
237 | 
238 | ```go
239 | type UserEvent struct {
240 | 	Event userEventType
241 | 	User  *User
242 | }
243 | 
244 | type User struct {
245 | 	ID              int64
246 | 	Username        string
247 | 	Nickname        string
248 | 	ProfilePicture  *ProfilePicture
249 | 	ExtraAttributes *ExtraAttributes
250 | 	Badge           *BadgeAttributes
251 | }
252 | 
253 | // User Event Types
254 | const (
255 | 	USER_JOIN   userEventType = "user joined the stream"
256 | 	USER_SHARE  userEventType = "user shared the stream"
257 | 	USER_FOLLOW userEventType = "user followed the host"
258 | )
259 | ```
260 | 
261 | ### ViewersEvent
262 | 
263 | Viewer events broadcast the current amount of users watching the livestream.
264 | 
265 | ```go
266 | type ViewersEvent struct {
267 | 	Viewers int
268 | }
269 | ```
270 | 
271 | ### GiftEvent
272 | 
273 | Gift events are broadcast when a user buys a gift for the host.
274 | To get more information about the gift, such as the price in coins,
275 | find the gift by ID in the `live.GiftInfo.Gifts`.
276 | 
277 | Gift events with `GiftEvent.Type == 1` are streakable, meaning multiple gifts can 
278 | be sent in sequence, such as roses. For these sequences, multiple events are broadcast.
279 | Upon every subsequent gift in the streak, the `GiftEvent.RepeatCount` will increase by one.
280 | To prevent the duplicate processing of streakable gifts, you should only process 
281 | `if event.Type == 1 && event.RepeatEnd`, as this will be the final message of the streak, 
282 | and includes the total number of gifts sent in the streak.
283 | 
284 | ```go
285 | type GiftEvent struct {
286 | 	ID          int
287 | 	Name        string
288 | 	Describe    string
289 | 	Cost        int
290 | 	RepeatCount int
291 | 	RepeatEnd   bool
292 | 	Type        int
293 | 	ToUserID    int64
294 | 	Timestamp   int64
295 | 	User        *User
296 | }
297 | 
298 | type User struct {
299 | 	ID              int64
300 | 	Username        string
301 | 	Nickname        string
302 | 	ProfilePicture  *ProfilePicture
303 | 	ExtraAttributes *ExtraAttributes
304 | 	Badge           *BadgeAttributes
305 | }
306 | ```
307 | 
308 | ### LikeEvent
309 | 
310 | Like events are broadcast when a user likes the livestream. The event includes
311 | the number of likes the user sent, as well as new total number of likes.
312 | 
313 | ```go
314 | type LikeEvent struct {
315 | 	Likes       int
316 | 	TotalLikes  int
317 | 	User        *User
318 | 	DisplayType string
319 | 	Label       string
320 | }
321 | ```
322 | 
323 | ### QuestionEvent
324 | 
325 | Question events are emitted when a question has been posted by a user. It includes
326 | the question text, and the user that posted the question.
327 | 
328 | ```go
329 | type QuestionEvent struct {
330 | 	Quesion string
331 | 	User    *User
332 | }
333 | ```
334 | 
335 | ### ControlEvent
336 | 
337 | Control events are used to broadcast the status of the livestream.
338 | 
339 | Action values:
340 | 
341 | - 3: live stream ended
342 | 
343 | ```go
344 | type ControlEvent struct {
345 | 	Action int
346 | }
347 | ```
348 | 
349 | ### MicBattleEvent
350 | 
351 | ```go
352 | type MicBattleEvent struct {
353 | 	Users []*User
354 | }
355 | ```
356 | 
357 | ### BattlesEvent
358 | 
359 | ```go
360 | type BattlesEvent struct {
361 | 	Status  int
362 | 	Battles []*Battle
363 | }
364 | 
365 | type Battle struct {
366 | 	Host   int64
367 | 	Groups []*BattleGroup
368 | }
369 | 
370 | type BattleGroup struct {
371 | 	Points int
372 | 	Users  []*User
373 | }
374 | ```
375 | 
376 | ### RoomBannerEvent
377 | 
378 | Room banner event contains the JSON data unmarshaled into an interface that was
379 | passed with the message.
380 | 
381 | ```go
382 | type RoomBannerEvent struct {
383 | 	Data interface{}
384 | }
385 | ```
386 | 
387 | ### IntroEvent
388 | 
389 | Intro events are broadcast upon connecting to a livestream.
390 | 
391 | ```go
392 | type IntroEvent struct {
393 | 	ID    int
394 | 	Title string
395 | 	User  *User
396 | }
397 | ```
398 | 
399 | ## Examples
400 | 
401 | ### Fetching Recommended Live Streams
402 | 
403 | With a feed instance you can fetch a list of recommended livestreams, and directly
404 | start tracking them with a single call.
405 | 
406 | ```go
407 | tiktok := NewTikTok()
408 | feed := tiktok.NewFeed()
409 | 
410 | // Fetch 5 pages of recommended streams, usually 6 are returned at a time
411 | for i := 0; i < 5; i++ {
412 | 	feedItem, err := feed.Next()
413 | 	if err != nil {
414 | 		panic(err)
415 | 	}
416 | 
417 | 	for _, stream := range feedItem.LiveStreams {
418 | 		fmt.Printf("%s : %d viewers\n", stream.Room.Owner.Nickname, stream.Room.UserCount)
419 | 	}
420 | 
421 | 	if !feedItem.Extra.HasMore {
422 | 		break
423 | 	}
424 | }
425 | 
426 | recommendedStreams := feed.LiveStreams
427 | 
428 | // Start tracking the first stream
429 | live, err := recommendedStreams[0].Track()
430 | if err != nil {
431 | 	panic(err)
432 | }
433 | 
434 | // Process events
435 | ...
436 | 
437 | ```
438 | 
439 | ### Error Handling
440 | 
441 | Gotiktoklive uses Go routines to fetch events using either websockets or HTTP polling.
442 | These go routines need an error hander, that defaults to panic. You can overwrite this
443 | behavior:
444 | 
445 | ```go
446 | tiktok.SetErrorHandler(func(err error) {
447 |     ...
448 |   })
449 | 
450 | ```
451 | 
452 | ## Contributing
453 | 
454 | Your improvements are welcome! Feel free to open an <a href="https://github.com/steampoweredtaco/gotiktoklive/issues">issue</a> or <a href="https://github.com/steampoweredtaco/gotiktoklive/pulls">pull request</a>.
455 | 


--------------------------------------------------------------------------------
/proto/webcast.proto:
--------------------------------------------------------------------------------
  1 | syntax = "proto3";
  2 | 
  3 | import "data.proto";
  4 | import "enums.proto";
  5 | 
  6 | option go_package = "./proto;gotiktoklive";
  7 | 
  8 | //@WebcastPushFrame
  9 | // Response from TikTokServer. Container for Messages
 10 | message WebcastPushFrame {
 11 |   uint64 SeqId = 1;
 12 |   uint64 LogId = 2;
 13 |   uint64 Service = 3;
 14 |   uint64 Method = 4;
 15 |   map<string, string> headers = 5;
 16 |   string PayloadEncoding = 6;
 17 |   string PayloadType = 7;
 18 |   bytes Payload = 8;
 19 | 
 20 | }
 21 | 
 22 | 
 23 | 
 24 | //@WebcastResponse
 25 | // Response from TikTokServer. Container for Messages
 26 | message WebcastResponse {
 27 |   repeated Message messages = 1;
 28 |   string cursor = 2;
 29 |   int64 fetchInterval = 3;
 30 |   int64 now = 4;
 31 |   bytes internalExt = 5;
 32 |   int32 fetchType = 6;
 33 |   map<string, string> routeParamsMap = 7;
 34 |   int64 heartBeatDuration = 8;
 35 |   bool needsAck = 9;
 36 |   string pushServer = 10;
 37 |   bool isFirst = 11;
 38 |   string historyCommentCursor = 12;
 39 |   bool historyNoMore = 13;
 40 | 
 41 |   // Server-Message. Binary will deserialize into specific message
 42 |   message Message {
 43 |     string method = 1;
 44 |     bytes payload = 2;
 45 |     int64 msgId = 3;
 46 |     int32 msgType = 4;
 47 |     int64 offset = 5;
 48 |     bool isHistory = 6;
 49 |   }
 50 | }
 51 | 
 52 | //@GiftMessage
 53 | message WebcastGiftMessage {
 54 |   Common common = 1;
 55 |   int64 giftId = 2;
 56 |   int64 fanTicketCount = 3;
 57 |   int32 groupCount = 4;
 58 |   int32 repeatCount = 5;
 59 |   int32 comboCount = 6;
 60 |   User user = 7;
 61 |   User toUser = 8;
 62 |   int32 repeatEnd = 9;
 63 |   int64 groupId = 11;
 64 |   int64 incomeTaskgifts = 12;
 65 |   int64 roomFanTicketCount = 13;
 66 |   GiftStruct gift = 15;
 67 |   string logId = 16;
 68 |   int64 sendType = 17;
 69 |   string monitorExtra = 22;
 70 |   int64 colorId = 24;
 71 |   bool isFirstSent = 25;
 72 |   string orderId = 28;
 73 |   UserIdentity userIdentity = 32;
 74 |   UserGiftReciever userGiftReciever = 23;
 75 | 
 76 |   message UserGiftReciever
 77 |   {
 78 |     int64 userId = 1;
 79 |     string deviceName = 10;
 80 |   }
 81 | 
 82 |   message GiftIMPriority {
 83 |     repeated int64 queueSizesList = 1;
 84 |     int64 selfQueuePriority = 2;
 85 |     int64 priority = 3;
 86 |   }
 87 | 
 88 |   message PublicAreaCommon {
 89 |     Image userLabel = 1;
 90 |     int64 userConsumeInRoom = 2;
 91 |   }
 92 | }
 93 | 
 94 | //@RoomMessage
 95 | message RoomMessage {
 96 |   Common common = 1;
 97 |   string content = 2;
 98 |   bool supprotLandscape = 3;
 99 |   int64 source = 4;
100 |   Image icon = 5;
101 |   string scene = 6;
102 |   bool isWelcome = 7;
103 | }
104 | 
105 | //@WebcastRoomMessage
106 | message WebcastRoomMessage {
107 |   Common common = 1;
108 |   string content = 2;
109 | }
110 | 
111 | //@WebcastBarrageMessage
112 | message WebcastBarrageMessage {
113 |   Common common = 1;
114 |   BarrageEvent event = 2;
115 |   BarrageType msgType = 3; // Enum
116 |   Image icon = 4;
117 |   Text content = 5;
118 |   int32 duration = 6;
119 |   Image background = 7;
120 |   Image rightIcon = 8;
121 |   BarrageTypeUserGradeParam userGradeParam = 100;
122 |   BarrageTypeFansLevelParam fansLevelParam = 101;
123 |   BarrageTypeSubscribeGiftParam subscribeGiftParam = 102;
124 | 
125 |   message BarrageTypeUserGradeParam {
126 |     int32 currentGrade = 1;
127 |     int32 displayConfig = 2;
128 |     string userId = 3;
129 |     User user = 4;
130 |   }
131 |   message BarrageTypeFansLevelParam {
132 |     int32 currentGrade = 1;
133 |     int32 displayConfig = 2;
134 |     User user = 4;
135 |   }
136 |   message BarrageTypeSubscribeGiftParam {
137 |     int64 giftSubCount = 1;
138 |     bool showGiftSubCount = 2;
139 |   }
140 | 
141 |   message BarrageEvent {
142 |     string eventName = 1;
143 |   }
144 | 
145 |   // @BarrageType
146 |   // webcast.im.BarrageMessage
147 |   enum BarrageType {
148 |     UNKNOWN = 0;
149 |     ECOMORDERING = 1;
150 |     ECOMBUYING = 2;
151 |     NORMAL = 3;
152 |     SUBSCRIBE = 4;
153 |     EVENTVIEW = 5;
154 |     EVENTREGISTERED = 6;
155 |     SUBSCRIBEGIFT = 7;
156 |     USERUPGRADE = 8;
157 |     GRADEUSERENTRANCENOTIFICATION = 9;
158 |     FANSLEVELUPGRADE = 10;
159 |     FANSLEVELENTRANCE = 11;
160 |     GAMEPARTNERSHIP = 12;
161 |   }
162 | }
163 | 
164 | //@WebcastCaptionMessage
165 | // Closed Captioning for Video
166 | message WebcastCaptionMessage {
167 |   Common common = 1;
168 |   uint64 timeStamp = 2;
169 |   CaptionData captionData = 4;
170 | 
171 |   message CaptionData {
172 |     string language = 1;
173 |     string text = 2;
174 |   }
175 | }
176 | 
177 | 
178 | 
179 | // Comment sent by User
180 | //@WebcastChatMessage
181 | message WebcastChatMessage {
182 |   Common common = 1;
183 |   User user = 2;
184 |   string content = 3;
185 |   bool visibleToSender = 4;
186 |   Image backgroundImage = 5;
187 |   string fullScreenTextColor = 6;
188 |   Image backgroundImageV2 = 7;
189 |   Image giftImage = 10;
190 |   int32 inputType = 11;
191 |   User atUser = 12;
192 |   repeated EmoteWithIndex emotesList = 13;
193 |   string contentLanguage = 14;
194 |   int32 quickChatScene = 16;
195 |   int32 communityFlaggedStatus = 17;
196 |   UserIdentity UserIdentity = 18;
197 |   map<int32, string> CommentQualityScores = 19;
198 | 
199 |   // @EmoteWithIndex
200 |   // proto.webcast.im.ChatMessage
201 |   message EmoteWithIndex {
202 |     int64 index = 1;
203 |     Emote emote = 2;
204 |   }
205 | }
206 | 
207 | // System-Control Message from Room (e.g. Host ended Stream)
208 | //@WebcastControlMessage
209 | message WebcastControlMessage {
210 |   Common common = 1;
211 |   ControlAction action = 2;
212 |   string tips = 3;
213 |   Extra extra = 4;
214 |   //PerceptionDialogInfo perceptionDialog = 5;
215 |   Text perceptionAudienceText = 6;
216 |   PunishEventInfo punishInfo = 7;
217 |   Text floatText = 8;
218 |   int32 floatStyle = 9;
219 | 
220 |   // @Extra
221 |   // proto.webcast.im.ControlMessage
222 |   message Extra {
223 |     string banInfoUrl = 1;
224 |     int64 reasonNo = 2;
225 |     Text title = 3;
226 |     Text violationReason = 4;
227 |     Text content = 5;
228 |     Text gotItButton = 6;
229 |     Text banDetailButton = 7;
230 |     string source = 8;
231 |   }
232 | }
233 | 
234 | // Emote sent by user
235 | //@WebcastEmoteChatMessage
236 | message WebcastEmoteChatMessage {
237 |   Common common = 1;
238 |   User user = 2;
239 |   repeated Emote emoteList = 3;
240 |   MsgFilter msgFilter = 4;
241 |   UserIdentity userIdentity = 5;
242 | }
243 | 
244 | //@WebcastEnvelopeMessage
245 | message WebcastEnvelopeMessage {
246 |   Common common = 1;
247 |   EnvelopeInfo envelopeInfo = 2;
248 |   EnvelopeDisplay display = 3; // @warning Enum not found, should be Display
249 | 
250 |   // @EnvelopeInfo
251 |   // proto.webcast.im.EnvelopeMessage
252 |   message EnvelopeInfo {
253 |     string envelopeId = 1;
254 |     EnvelopeBusinessType businessType = 2;
255 |     string envelopeIdc = 3;
256 |     string sendUserName = 4;
257 |     int32 diamondCount = 5;
258 |     int32 peopleCount = 6;
259 |     int32 unpackAt = 7;
260 |     string sendUserId = 8;
261 |     Image sendUserAvatar = 9;
262 |     string createAt = 10;
263 |     string roomId = 11;
264 |     EnvelopeFollowShowStatus followShowStatus = 12; // @warning Enum not found, should be FollowShowStatus
265 |     int32 skinId = 13;
266 |   }
267 | }
268 | 
269 | //@WebcastGoalUpdateMessage
270 | message WebcastGoalUpdateMessage {
271 |   Common common = 1;
272 |   Indicator indicator = 2;
273 |   Goal goal = 3;
274 |   int64 contributorId = 4;
275 |   Image contributorAvatar = 5;
276 |   string contributorDisplayId = 6;
277 |   //  SubGoal contributeSubgoal = 7;
278 |   int64 contributeCount = 9;
279 |   int64 contributeScore = 10;
280 |   int64 giftRepeatCount = 11;
281 |   string contributorIdStr = 12;
282 |   bool pin = 13;
283 |   bool unpin = 14;
284 |   // GoalPinInfo pinInfo = 15;
285 | }
286 | 
287 | // Message related to Chat-moderation?
288 | //@WebcastImDeleteMessage
289 | message WebcastImDeleteMessage {
290 |   Common common = 1;
291 |   repeated int64 deleteMsgIdsList = 2;
292 |   repeated int64 deleteUserIdsList = 3;
293 | }
294 | 
295 | //@WebcastInRoomBannerMessage
296 | message WebcastInRoomBannerMessage {
297 |   Common header = 1;
298 |   string json = 2; // Json-Data for BannerMessage
299 | }
300 | 
301 | // User sent one or multiple likes to Stream. Maxes at 15 likes per message
302 | //@WebcastLikeMessage
303 | message WebcastLikeMessage {
304 |   Common common = 1;
305 |   int32 count = 2;
306 |   int32 total = 3;
307 |   User user = 5;
308 | }
309 | 
310 | // Status of Room (ViewerCount + Top Viewers)
311 | //@WebcastRoomUserSeqMessage
312 | message WebcastRoomUserSeqMessage {
313 |   Common common = 1;
314 |   repeated Contributor ranksList = 2;
315 |   int64 total = 3;
316 |   string popStr = 4;
317 |   repeated Contributor seatsList = 5;
318 |   int64 popularity = 6;
319 |   int32 totalUser = 7;
320 |   int64 anonymous = 8;
321 | 
322 |   // @Contributor
323 |   message Contributor {
324 |     int32 score = 1;
325 |     User user = 2;
326 |     int32 rank = 3;
327 |     int64 delta = 4;
328 |   }
329 | }
330 | 
331 | // Sent for a variety of events, including Follow & Share
332 | //@WebcastSocialMessage
333 | message WebcastSocialMessage {
334 |   Common common = 1;
335 |   User user = 2;
336 |   int64 shareType = 3;
337 |   int64 action = 4;
338 |   string shareTarget = 5;
339 |   int32 followCount = 6;
340 |   int64 shareDisplayStyle = 7;
341 |   int32 shareCount = 8;
342 | }
343 | 
344 | //@WebcastSubNotifyMessage
345 | message WebcastSubNotifyMessage {
346 |   Common common = 1;
347 |   User user = 2;
348 |   //  ExhibitionType exhibitionType = 3; // Enum
349 |   int64 subMonth = 4;
350 |   SubscribeType subscribeType = 5; // Enum
351 |   OldSubscribeStatus oldSubscribeStatus = 6; // Enum
352 |   SubscribingStatus subscribingStatus = 8; // Enum
353 |   bool isSend = 9;
354 |   bool isCustom = 10;
355 | 
356 | }
357 | 
358 | //@WebcastRankUpdateMessage
359 | message WebcastRankUpdateMessage {
360 |   Common common = 1;
361 |   repeated RankUpdate updatesList = 2;
362 |   int64 groupType = 3; // @warning Enum not found, should be GroupType
363 |   int64 priority = 5;
364 |   repeated RankTabInfo tabsList = 6;
365 |   bool isAnimationLoopPlay = 7;
366 |   bool animationLoopForOff = 8;
367 | 
368 | 
369 |   message RankTabInfo {
370 |     int64 rankType = 1; // @warning Enum not found, should be RankType
371 |     string title = 2;
372 |     Text titleText = 3;
373 |     int64 listLynxType = 4;
374 |   }
375 | 
376 |   // @RankUpdate
377 |   // proto.webcast.im.RankUpdateMessage
378 |   message RankUpdate {
379 |     int64 rankType = 1; // @warning Enum not found, should be RankType
380 |     int64 ownerRank = 2;
381 |     Text defaultContent = 3;
382 |     bool showEntranceAnimation = 5;
383 |     int64 countdown = 6;
384 |     int64 relatedTabRankType = 8; // @warning Enum not found, should be RelatedTabRankType
385 |     int64 requestFirstShowType = 9; // @warning Enum not found, should be RequestFirstShowType
386 |     int64 supportedVersion = 10;
387 |     bool owneronrank = 11;
388 |   }
389 | }
390 | 
391 | // Sent for a variety of events, including Join & Subscribe
392 | //@WebcastMemberMessage
393 | message WebcastMemberMessage {
394 |   Common common = 1;
395 |   User user = 2;
396 |   int32 memberCount = 3;
397 |   User operator = 4;
398 |   bool isSetToAdmin = 5;
399 |   bool isTopUser = 6;
400 |   int64 rankScore = 7;
401 |   int64 topUserNo = 8;
402 |   int64 enterType = 9;
403 |   MemberMessageAction action = 10;
404 |   string actionDescription = 11;
405 |   int64 userId = 12;
406 |   EffectConfig effectConfig = 13;
407 |   string popStr = 14;
408 |   EffectConfig enterEffectConfig = 15;
409 |   Image backgroundImage = 16;
410 |   Image backgroundImageV2 = 17;
411 |   Text anchorDisplayText = 18;
412 |   string clientEnterSource = 19;
413 |   string clientEnterType = 20;
414 |   string clientLiveReason = 21;
415 |   int64 actionDuration = 22;
416 |   string userShareType = 23;
417 | 
418 |   // @EffectConfig
419 |   // proto.webcast.im.MemberMessage
420 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
421 |   message EffectConfig {
422 |     int64 type = 1;
423 |     Image icon = 2;
424 |     int64 avatarPos = 3;
425 |     Text text = 4;
426 |     Image textIcon = 5;
427 |     int32 stayTime = 6;
428 |     int64 animAssetId = 7;
429 |     Image badge = 8;
430 |     repeated int64 flexSettingArrayList = 9;
431 |   }
432 | 
433 | }
434 | 
435 | 
436 | 
437 | 
438 | // --- HandMade --
439 | //@WebcastPollMessage
440 | message WebcastPollMessage {
441 |   Common common = 1;
442 |   MessageType messageType = 2;
443 |   int64 pollId = 3;
444 |   PollStartContent startContent = 4;
445 |   PollEndContent endContent = 5;
446 |   PollUpdateVotesContent updateContent = 6;
447 |   int32 pollKind = 7; // Possibly an Enum?
448 | }
449 | 
450 | //@WebcastQuestionNewMessage
451 | message WebcastQuestionNewMessage {
452 |   Common common = 1;
453 |   QuestionDetails details = 2;
454 | 
455 |   message QuestionDetails {
456 |     uint64 id = 1;
457 |     string text = 2;
458 |     uint64 timeStamp = 4;
459 |     User user = 5;
460 |     uint32 data1 = 20;
461 |   }
462 | }
463 | 
464 | //@WebcastRankTextMessage
465 | message WebcastRankTextMessage {
466 |   Common common = 1;
467 |   int32 scene = 2;
468 |   int64 ownerIdxBeforeUpdate = 3;
469 |   int64 ownerIdxAfterUpdate = 4;
470 |   Text selfGetBadgeMsg = 5;
471 |   Text otherGetBadgeMsg = 6;
472 |   int64 curUserId = 7;
473 | }
474 | 
475 | //@WebcastHourlyRankMessage
476 | message WebcastHourlyRankMessage {
477 |   Common common = 1;
478 |   RankContainer data = 2;
479 |   uint32 data2 = 3;
480 | 
481 |   message RankContainer {
482 |     uint32 data1 = 1;
483 |     RankingData rankingdata = 2;
484 |     uint32 data2 = 3;
485 |     Ranking rankings = 4;
486 |     RankingData2 rankingdata2 = 5;
487 |     uint32 data3 = 6;
488 |     uint32 data4 = 7;
489 | 
490 |     message RankingData {
491 |       uint32 data1 = 1;
492 |       Ranking rankdata = 2;
493 |       string data2 = 3;
494 |     }
495 | 
496 |     message RankingData2 {
497 |       uint32 data1 = 1;
498 |       uint32 data2 = 2;
499 |       Ranking rankdata = 3;
500 |       string data3 = 4;
501 |       uint32 data4 = 5;
502 |       uint32 data5 = 6;
503 |     }
504 |   }
505 | }
506 | 
507 | 
508 | //<Battles>
509 | 
510 | //@WebcastLinkMicArmies
511 | message WebcastLinkMicArmies {
512 |   Common common = 1;
513 |   uint64 id = 2;
514 |   repeated LinkMicArmiesItems battleItems = 3;
515 |   uint64 id2 = 4;
516 |   uint64 timeStamp1 = 5;
517 |   uint64 timeStamp2 = 6;
518 |   LinkMicBattleStatus battleStatus = 7;
519 |   uint64 data1 = 8;
520 |   uint64 data2 = 9;
521 |   uint32 data3 = 10;
522 |   Image Image = 11;
523 |   uint32 data4 = 12;
524 |   uint32 data5 = 13;
525 | }
526 | //@WebcastLinkMicBattlePunishFinish
527 | message WebcastLinkMicBattlePunishFinish {
528 |   Common Header = 1;
529 |   uint64 Id1 = 2;
530 |   uint64 Timestamp = 3;
531 |   uint32 Data4 = 4;
532 |   uint64 Id2 = 5;
533 |   LinkMicBattlePunishFinishData Data6 = 6;
534 | 
535 |   message LinkMicBattlePunishFinishData {
536 |     uint64 Id2 = 1; // Same as Id2 in outer object (loser?)
537 |     uint64 Timestamp = 2;
538 |     uint32 Data3 = 3;
539 |     uint64 Id1 = 4; // Same as Id1 in outer object (winner?)
540 |     uint32 Data5 = 5;
541 |     uint32 Data6 = 6;
542 |     uint32 Data8 = 8;
543 |   }
544 | }
545 | 
546 | //@WebcastLinkmicBattleTaskMessage
547 | message WebcastLinkmicBattleTaskMessage {
548 |   Common Header = 1;
549 |   uint32 Data2 = 2;
550 |   LinkmicBattleTaskData Data3 = 3;
551 |   LinkmicBattleTaskData2 Data5 = 5;
552 | 
553 |   message LinkmicBattleTaskData {
554 |     BattleTaskData Data1 = 1;
555 |   }
556 |   message BattleTaskData {
557 |     uint32 Data1 = 1;
558 |   }
559 | 
560 |   message LinkmicBattleTaskData2 {
561 |     uint32 Data1 = 1;
562 |     uint32 Data2 = 2;
563 |   }
564 | }
565 | 
566 | //@WebcastLinkMicBattle
567 | message WebcastLinkMicBattle {
568 |   Common common = 1;
569 |   uint64 id = 2;
570 |   LinkMicBattleConfig battleConfig = 3;
571 |   LinkMicBattleStatus battleStatus = 4;
572 |   repeated LinkMicBattleDetails details = 5;
573 |   repeated LinkMicBattleTopViewers viewerTeam = 9;
574 |   repeated LinkMicBattleHost hostTeam = 10;
575 |   repeated LinkMicBattleTeamData teamData = 13;
576 |   uint64 unknownData16 = 16;
577 |   repeated Host2v2Data hostData2v2 = 17;
578 | 
579 |   message Host2v2Data {
580 |     uint32 teamNumber = 1;
581 |     repeated HostData hostdata = 2;
582 |     uint32 unknownData3 = 3;
583 |     uint32 totalPoints = 4;
584 | 
585 |     message HostData {
586 |       uint64 hostId = 1;
587 |       uint32 points = 2;
588 |       string hostIdStr = 3;
589 |     }
590 |   }
591 | 
592 |   message LinkMicBattleConfig {
593 |     uint64 id1 = 1;
594 |     uint64 timestamp = 2;
595 |     uint32 data1 = 3;
596 |     uint64 id2 = 4;
597 |     uint32 data2 = 5;
598 |     uint32 data3 = 6;
599 |     uint32 data4 = 8;
600 |   }
601 | 
602 |   message LinkMicBattleTeamData {
603 |     uint64 teamId = 1;
604 |     LinkMicBattleData data = 2;
605 |   }
606 | 
607 |   message LinkMicBattleData {
608 |     uint64 id = 1;
609 |     uint32 data1 = 2;
610 |     uint32 winStreak = 3;
611 |     uint32 data3 = 5;
612 |     string url = 6;
613 |   }
614 | 
615 |   message LinkMicBattleDetails {
616 |     uint64 id = 1;
617 |     LinkMicBattleDetailsSummary summary = 2;
618 | 
619 |     message LinkMicBattleDetailsSummary {
620 |       uint64 id = 1;
621 |       uint32 unknownData2 = 2;
622 |       uint32 points = 3;
623 |     }
624 |   }
625 | 
626 |   message LinkMicBattleTopViewers {
627 |     uint64 id = 1;
628 |     repeated TopViewerGroup viewerGroup = 2;
629 | 
630 |     message TopViewerGroup {
631 |       repeated TopViewer viewer = 1;
632 |       uint32 points = 2;
633 |       string hostIdOrTeamNum = 3; // 1v1 Battle = HostId | 2v2 Battle = Team # - 1 & 2
634 | 
635 |       message TopViewer {
636 |         uint64 id = 1;
637 |         uint32 points = 2;
638 |         string profileId = 3;
639 |         repeated Image images = 4;
640 |         string stringId = 6;
641 |       }
642 |     }
643 |   }
644 | 
645 |   message LinkMicBattleHost {
646 |     uint64 id = 1;
647 |     repeated HostGroup hostGroup = 2;
648 | 
649 |     message HostGroup {
650 |       repeated Host host = 1;
651 |       uint32 points = 2;
652 |       string hostId = 3;
653 | 
654 |       message Host {
655 |         uint64 id = 1;
656 |         string profileId = 2;
657 |         repeated Image images = 3;
658 |         string name = 4;
659 |       }
660 |     }
661 |   }
662 | }
663 | 
664 | //@WebcastLinkMicFanTicketMethod
665 | message WebcastLinkMicFanTicketMethod {
666 |   Common common = 1;
667 |   FanTicketRoomNoticeContent FanTicketRoomNotice = 2;
668 | }
669 | //@WebcastLinkMicMethod
670 | message WebcastLinkMicMethod {
671 |   Common common = 1;
672 |   MessageType messageType = 2;
673 |   string accessKey = 3;
674 |   int64 anchorLinkmicId = 4;
675 |   int64 userId = 5;
676 |   int64 fanTicket = 6;
677 |   int64 totalLinkMicFanTicket = 7;
678 |   int64 channelId = 8;
679 |   int64 layout = 9;
680 |   int64 vendor = 10;
681 |   int64 dimension = 11;
682 |   string theme = 12;
683 |   int64 inviteUid = 13;
684 | }
685 | 
686 | //<Battles>
687 | 
688 | //@WebcastLiveIntroMessage
689 | message WebcastLiveIntroMessage {
690 |   Common common = 1;
691 |   int64 roomId = 2;
692 |   AuditStatus auditStatus = 3;
693 |   string content = 4;
694 |   User host = 5;
695 |   int32 introMode = 6;
696 |   repeated BadgeStruct badges = 7;
697 |   string language = 8;
698 | }
699 | 
700 | //@WebcastUnauthorizedMemberMessage
701 | message WebcastUnauthorizedMemberMessage {
702 |   Common common = 1;
703 |   int32 action = 2;
704 |   Text nickNamePrefix = 3;
705 |   string nickName = 4;
706 |   Text enterText = 5;
707 | }
708 | 
709 | //@WebcastMsgDetectMessage
710 | message WebcastMsgDetectMessage {
711 |   Common common = 1;
712 |   int32 detectType = 2; // Possibly an Enum?
713 |   TriggerCondition triggerCondition = 3;
714 |   TimeInfo timeInfo = 4;
715 |   int32 triggerBy = 5; // Possible an Enum?
716 |   string fromRegion = 6;
717 | 
718 |   message TimeInfo {
719 |     int64 clientStartMs = 1;
720 |     int64 apiRecvTimeMs = 2;
721 |     int64 apiSendToGoimMs = 3;
722 |   }
723 | 
724 |   message TriggerCondition {
725 |     bool uplinkDetectHttp = 1;
726 |     bool uplinkDetectWebSocket = 2;
727 |     bool detectP2PMsg = 3;
728 |     bool detectRoomMsg = 4;
729 |     bool httpOptimize = 5;
730 |   }
731 | }
732 | 
733 | //@WebcastOecLiveShoppingMessage
734 | message WebcastOecLiveShoppingMessage {
735 |   Common common = 1;
736 |   uint32 data1 = 2;
737 |   LiveShoppingData shopData = 4;
738 |   TimeStampContainer shopTimings = 5; // Uses index 1, 2 & 3
739 |   LiveShoppingDetails details = 9;
740 | 
741 |   message LiveShoppingData {
742 |     string title = 1;
743 |     string priceString = 2; // $55.99
744 |     string imageUrl = 3;
745 |     string shopUrl = 4;
746 |     uint64 data1 = 6;
747 |     string shopName = 7; // "Shopify"
748 |     uint64 data2 = 8;
749 |     string shopUrl2 = 9;
750 |     uint64 data3 = 10;
751 |     uint64 data4 = 11;
752 |   }
753 | 
754 |   message LiveShoppingDetails {
755 |     string id1 = 1;
756 |     string data1 = 3;
757 |     uint32 data2 = 4;
758 |     uint64 timestamp = 5;
759 |     ValueLabel data = 6;
760 |   }
761 | }
762 | 
763 | //@WebcastRoomPinMessage
764 | // Host Pins comment to stream
765 | message WebcastRoomPinMessage {
766 |   Common common = 1;
767 |   bytes pinnedMessage = 2; // Usually this is a ChatMessage, but it can also be another message.
768 |   string originalMsgType = 30; // Use this Type/Method to Deserialize the PinnedMessage
769 |   uint64 timestamp = 31;
770 | }
771 | 
772 | //@WebcastLiveGameIntroMessage
773 | //Game intro showing live selected game metadata
774 | message WebcastLiveGameIntroMessage {
775 |   Common common = 1;
776 |   Text gameText = 2;
777 | }
778 | 
779 | //@SystemMessage
780 | message WebcastSystemMessage {
781 |   Common common = 1;
782 |   string message = 2;
783 | }
784 | 
785 | //@WebcastLinkMessage
786 | message WebcastLinkMessage {
787 |   Common common = 1;
788 |   LinkMessageType MessageType = 2;
789 |   int64 LinkerId = 3;
790 |   Scene Scene = 4;
791 |   LinkerInviteContent InviteContent = 5;
792 |   LinkerReplyContent ReplyContent = 6;
793 |   LinkerCreateContent CreateContent = 7;
794 |   LinkerCloseContent CloseContent = 8;
795 |   LinkerEnterContent EnterContent = 9;
796 |   LinkerLeaveContent LeaveContent = 10;
797 |   LinkerCancelContent CancelContent = 11;
798 |   LinkerKickOutContent KickOutContent = 12;
799 |   LinkerLinkedListChangeContent LinkedListChangeContent = 13;
800 |   LinkerUpdateUserContent UpdateUserContent = 14;
801 |   LinkerWaitingListChangeContent WaitingListChangeContent = 15;
802 |   LinkerMuteContent MuteContent = 16;
803 |   LinkerRandomMatchContent RandomMatchContent = 17;
804 |   LinkerUpdateUserSettingContent UpdateUserSettingContent = 18;
805 |   LinkerMicIdxUpdateContent MicIdxUpdateContent = 19;
806 |   LinkerListChangeContent ListChangeContent = 20;
807 |   CohostListChangeContent CohostListChangeContent = 21;
808 |   LinkerMediaChangeContent MediaChangeContent = 22;
809 |   LinkerAcceptNoticeContent AcceptNoticeContent = 23;
810 |   LinkerSysKickOutContent SysKickOutContent = 101;
811 |   LinkmicUserToastContent UserToastContent = 102;
812 |   string extra = 200;
813 |   int64 expireTimestamp = 201;
814 |   string transferExtra = 202;
815 | }
816 | 
817 | 
818 | // @WebcastLinkLayerMessage
819 | message WebcastLinkLayerMessage {
820 |   Common common = 1;
821 |   MessageType messageType = 2; // Enum
822 |   int64 channelId = 3;
823 |   Scene scene = 4; // Enum
824 |   CreateChannelContent createChannelContent = 100;
825 |   ListChangeContent listChangeContent = 102;
826 |   InviteContent inviteContent = 103;
827 |   ApplyContent applyContent = 104;
828 |   PermitApplyContent permitApplyContent = 105;
829 |   ReplyInviteContent replyInviteContent = 106;
830 |   KickOutContent kickOutContent = 107;
831 |   CancelApplyContent cancelApplyContent = 108;
832 |   CancelInviteContent cancelInviteContent = 109;
833 |   LeaveContent leaveContent = 110;
834 |   FinishChannelContent finishContent = 111;
835 |   JoinDirectContent joinDirectContent = 112;
836 |   JoinGroupContent joinGroupContent = 113;
837 |   PermitJoinGroupContent permitGroupContent = 114;
838 |   CancelJoinGroupContent cancelGroupContent = 115;
839 |   LeaveJoinGroupContent leaveGroupContent = 116;
840 |   P2PGroupChangeContent p2pGroupChangeContent = 117;
841 |   BusinessContent businessContent = 200;
842 | }
843 | 
844 | // @RoomVerifyMessage
845 | message RoomVerifyMessage {
846 |   Common common = 1;
847 |   int32 action = 2;
848 |   string content = 3;
849 |   int64 noticeType = 4;
850 |   bool closeRoom = 5;
851 | }
852 | 
853 | 
854 | 


--------------------------------------------------------------------------------
/proto/data.proto:
--------------------------------------------------------------------------------
   1 | syntax = "proto3";
   2 | import "enums.proto";
   3 | option go_package = "./proto;gotiktoklive";
   4 | // @Common
   5 | message Common {
   6 |   string method = 1;
   7 |   int64 msgId = 2;
   8 |   int64 roomId = 3;
   9 |   int64 createTime = 4;
  10 |   int32 monitor = 5;
  11 |   bool isShowMsg = 6;
  12 |   string describe = 7;
  13 |   Text displayText = 8;
  14 |   int64 foldType = 9;
  15 |   int64 anchorFoldType = 10;
  16 |   int64 priorityScore = 11;
  17 |   string logId = 12;
  18 |   string msgProcessFilterK = 13;
  19 |   string msgProcessFilterV = 14;
  20 |   string fromIdc = 15;
  21 |   string toIdc = 16;
  22 |   repeated string filterMsgTagsList = 17;
  23 |   LiveMessageSEI sei = 18;
  24 |   LiveMessageID dependRootId = 19;
  25 |   LiveMessageID dependId = 20;
  26 |   int64 anchorPriorityScore = 21;
  27 |   int64 roomMessageHeatLevel = 22;
  28 |   int64 foldTypeForWeb = 23;
  29 |   int64 anchorFoldTypeForWeb = 24;
  30 |   int64 clientSendTime = 25;
  31 |   IMDispatchStrategy dispatchStrategy = 26; // Enum
  32 | 
  33 |   message LiveMessageSEI {
  34 |     LiveMessageID uniqueId = 1;
  35 |     int64 timestamp = 2;
  36 |   }
  37 | 
  38 |   message LiveMessageID {
  39 |     string primaryId = 1;
  40 |     string messageScene = 2;
  41 |   }
  42 | 
  43 |   enum IMDispatchStrategy {
  44 |     IM_DISPATCH_STRATEGY_DEFAULT = 0;
  45 |     IM_DISPATCH_STRATEGY_BYPASS_DISPATCH_QUEUE = 1;
  46 |   }
  47 | }
  48 | 
  49 | // @Text
  50 | message Text {
  51 |   string key = 1;
  52 |   string defaultPattern = 2;
  53 |   TextFormat defaultFormat = 3;
  54 |   repeated TextPiece piecesList = 4;
  55 | 
  56 |   message TextPiece {
  57 |     int32 type = 1;
  58 |     TextFormat format = 2;
  59 |     string stringValue = 11;
  60 |     oneof textPieceType
  61 |     {
  62 |       TextPieceUser userValue = 21;
  63 |       TextPieceGift giftValue = 22;
  64 |     }
  65 |     TextPiecePatternRef patternRefValue = 24;
  66 |   }
  67 | 
  68 |   message TextFormat {
  69 |     string color = 1;
  70 |     bool bold = 2;
  71 |     bool italic = 3;
  72 |     int32 weight = 4;
  73 |     int32 italicAngle = 5;
  74 |     int32 fontSize = 6;
  75 |     bool useHeighLightColor = 7;
  76 |     bool useRemoteClor = 8;
  77 |   }
  78 | 
  79 |   message TextPieceGift {
  80 |     int32 giftId = 1;
  81 |     // PatternRef nameRef = 2;
  82 |     // ShowType showType = 3; // Enum
  83 |     int64 colorId = 4;
  84 |   }
  85 | 
  86 |   message TextPiecePatternRef {
  87 |     string key = 1;
  88 |     string defaultPattern = 2;
  89 |   }
  90 | 
  91 |   message TextPieceUser {
  92 |     User user = 1;
  93 |     bool withColon = 2;
  94 |   }
  95 | 
  96 | }
  97 | 
  98 | // @Image
  99 | message Image {
 100 |   repeated string urlList = 1;
 101 |   string extras = 2;
 102 |   bool isAnimated = 9;
 103 | }
 104 | 
 105 | // @Badge
 106 | message BadgeStruct {
 107 |   BadgeDisplayType displayType = 1; // Enum
 108 |   oneof badgeType
 109 |   {
 110 |     ImageBadge image = 20;
 111 |     TextBadge text = 21;
 112 |     StringBadge str = 22;
 113 |     CombineBadge combine = 23;
 114 |   }
 115 | 
 116 |   message CombineBadge {
 117 |     Image icon = 2;
 118 |     TextBadge text = 3;
 119 |     string str = 4;
 120 |     // repeated PaddingInfo padding = 5;
 121 |     // FontStyle fontStyle = 6;
 122 |     ProfileCardPanel profileCardPanel = 7;
 123 |     CombineBadgeBackground background = 11;
 124 |     CombineBadgeBackground backgroundDarkMode = 12;
 125 |     bool iconAutoMirrored = 13;
 126 |     bool backgroundAutoMirrored = 14;
 127 |     int32 publicScreenShowStyle = 15;
 128 |     int32 personalCardShowStyle = 16;
 129 |     int32 ranklistOnlineAudienceShowStyle = 17;
 130 |     int32 multiGuestShowStyle = 18;
 131 |     //  repeated PaddingInfo paddingNewFont = 20;
 132 |   }
 133 | 
 134 |   message ProfileContent {
 135 |     bool useContent = 1;
 136 |     repeated IconConfig iconList = 2;
 137 |     NumberConfig numberConfig = 3;
 138 |   }
 139 | 
 140 |   message ProjectionConfig {
 141 |     bool useProjection = 1;
 142 |     Image icon = 2;
 143 |   }
 144 | 
 145 |   message NumberConfig {
 146 |     int64 number = 1;
 147 |     //FontStyle fontStyle = 2;
 148 |     CombineBadgeBackground background = 3;
 149 |   }
 150 | 
 151 | 
 152 |   message ProfileCardPanel {
 153 |     bool useNewProfileCardStyle = 1;
 154 |     //  BadgeTextPosition badgeTextPosition = 2; // Enum
 155 |     ProjectionConfig projectionConfig = 3;
 156 |     ProfileContent profileContent = 4;
 157 |   }
 158 | 
 159 |   message CombineBadgeBackground {
 160 |     Image image = 1;
 161 |     string backgroundColorCode = 2;
 162 |     string borderColorCode = 3;
 163 |   }
 164 | 
 165 |   message ImageBadge {
 166 |     Image image = 2;
 167 |   }
 168 | 
 169 |   message TextBadge {
 170 |     string defaultPattern = 3;
 171 |   }
 172 | 
 173 |   message IconConfig {
 174 |     Image icon = 1;
 175 |     CombineBadgeBackground background = 2;
 176 |   }
 177 | 
 178 | 
 179 |   message StringBadge {
 180 |     string str = 2;
 181 |   }
 182 | 
 183 |   enum DataCase {
 184 |     DATA_NOT_SET = 0;
 185 |     IMAGE = 20;
 186 |     TEXT = 21;
 187 |     STR = 22;
 188 |     COMBINE = 23;
 189 |   }
 190 | 
 191 |   enum BadgeDisplayType {
 192 |     BADGEDISPLAYTYPE_UNKNOWN = 0;
 193 |     BADGEDISPLAYTYPE_IMAGE = 1;
 194 |     BADGEDISPLAYTYPE_TEXT = 2;
 195 |     BADGEDISPLAYTYPE_STRING = 3;
 196 |     BADGEDISPLAYTYPE_COMBINE = 4;
 197 |   }
 198 | 
 199 | 
 200 | 
 201 | 
 202 |   enum Position {
 203 |     POSITIONUNKNOWN = 0;
 204 |     POSITIONLEFT = 1;
 205 |     POSITIONRIGHT = 2;
 206 |   }
 207 | 
 208 | 
 209 | }
 210 | 
 211 | // @Gift
 212 | message GiftStruct {
 213 |   Image image = 1;
 214 |   string describe = 2;
 215 |   int64 duration = 4;
 216 |   int64 id = 5;
 217 |   bool forLinkmic = 7;
 218 |   bool combo = 10;
 219 |   int32 type = 11;
 220 |   int32 diamondCount = 12;
 221 |   bool isDisplayedOnPanel = 13;
 222 |   int64 primaryEffectId = 14;
 223 |   Image giftLabelIcon = 15;
 224 |   string name = 16;
 225 |   Image icon = 21;
 226 |   string goldEffect = 24;
 227 |   Image previewImage = 47;
 228 |   GiftPanelBanner giftPanelBanner = 48;
 229 |   bool isBroadcastGift = 49;
 230 |   bool isEffectBefview = 50;
 231 |   bool isRandomGift = 51;
 232 |   bool isBoxGift = 52;
 233 |   bool canPutInGiftBox = 53;
 234 |   // GiftBoxInfo giftBoxInfo = 54;
 235 | 
 236 | 
 237 |   // @GiftPanelBanner
 238 |   // proto.webcast.data.GiftStruct
 239 |   message GiftPanelBanner {
 240 |     Text displayText = 1;
 241 |     Image leftIcon = 2;
 242 |     string schemaUrl = 3;
 243 |     repeated string bgColorValuesList = 5;
 244 |     string bannerLynxUrl = 6;
 245 |   }
 246 | 
 247 | 
 248 |   // @GiftRandomEffectInfo
 249 |   // proto.webcast.data.GiftStruct
 250 |   message GiftRandomEffectInfo {
 251 |     RandomGiftPanelBanner randomGiftPanelBanner = 1;
 252 |     repeated int64 effectIdsList = 2;
 253 |     string hostKey = 3;
 254 |     string audienceKey = 4;
 255 |     RandomGiftBubble randomGiftBubble = 5;
 256 |   }
 257 | 
 258 | 
 259 |   // @RandomGiftBubble
 260 |   // proto.webcast.data.GiftStruct
 261 |   message RandomGiftBubble {
 262 |     string displayText = 1;
 263 |     Image iconDynamicEffect = 2;
 264 |   }
 265 | 
 266 | 
 267 |   // @RandomGiftPanelBanner
 268 |   // proto.webcast.data.GiftStruct
 269 |   message RandomGiftPanelBanner {
 270 |     Image bgImage = 1;
 271 |     Image shadingImage = 2;
 272 |     int64 targetNum = 3;
 273 |     int64 collectNum = 4;
 274 |     string displayText = 5;
 275 |     Image leftIcon = 6;
 276 |     string schemaUrl = 7;
 277 |     repeated string bgColorValuesList = 8;
 278 |     int64 round = 9;
 279 |   }
 280 | 
 281 | }
 282 | 
 283 | // @User
 284 | message User {
 285 |   int64 id = 1;
 286 |   string nickname = 3;
 287 |   string bioDescription = 5;
 288 |   Image avatarThumb = 9;
 289 |   Image avatarMedium = 10;
 290 |   Image avatarLarge = 11;
 291 |   bool verified = 12;
 292 |   int32 status = 15;
 293 |   int64 createTime = 16;
 294 |   int64 modifyTime = 17;
 295 |   int32 secret = 18;
 296 |   string shareQrcodeUri = 19;
 297 |   repeated Image badgeImageList = 21;
 298 |   FollowInfo followInfo = 22;
 299 |   PayGrade payGrade = 23;
 300 |   FansClub fansClub = 24;
 301 |   Border border = 25;
 302 |   string specialId = 26;
 303 |   Image avatarBorder = 27;
 304 |   Image medal = 28;
 305 |   repeated Image realTimeIconsList = 29;
 306 |   repeated Image newRealTimeIconsList = 30;
 307 |   int64 topVipNo = 31;
 308 |   UserAttr userAttr = 32;
 309 |   OwnRoom ownRoom = 33;
 310 |   int64 payScore = 34;
 311 |   int64 ticketCount = 35;
 312 |   LinkmicStatus linkMicStats = 37;
 313 |   string displayId = 38;
 314 |   bool withCommercePermission = 39;
 315 |   bool withFusionShopEntry = 40;
 316 |   AnchorLevel webcastAnchorLevel = 42;
 317 |   string verifiedContent = 43;
 318 |   AuthorStats authorStats = 44;
 319 |   repeated User topFansList = 45;
 320 |   string secUid = 46;
 321 |   int32 userRole = 47;
 322 |   ActivityInfo activityReward = 49;
 323 |   Image personalCard = 52;
 324 |   AuthenticationInfo authenticationInfo = 53;
 325 |   repeated Image mediaBadgeImageList = 57;
 326 |   repeated int64 commerceWebcastConfigIdsList = 60;
 327 |   repeated Border borderList = 61;
 328 |   ComboBadgeInfo comboBadgeInfo = 62;
 329 |   SubscribeInfo subscribeInfo = 63;
 330 |   repeated BadgeStruct badgeList = 64;
 331 |   repeated int64 mintTypeLabelList = 65;
 332 |   FansClubInfo fansClubInfo = 66;
 333 |   bool allowFindByContacts = 1002;
 334 |   bool allowOthersDownloadVideo = 1003;
 335 |   bool allowOthersDownloadWhenSharingVideo = 1004;
 336 |   bool allowShareShowProfile = 1005;
 337 |   bool allowShowInGossip = 1006;
 338 |   bool allowShowMyAction = 1007;
 339 |   bool allowStrangeComment = 1008;
 340 |   bool allowUnfollowerComment = 1009;
 341 |   bool allowUseLinkmic = 1010;
 342 |   AnchorLevel anchorLevel = 1011;
 343 |   Image avatarJpg = 1012;
 344 |   string bgImgUrl = 1013;
 345 |   int32 blockStatus = 1016;
 346 |   int32 commentRestrict = 1017;
 347 |   string constellation = 1018;
 348 |   int32 disableIchat = 1019;
 349 |   int64 enableIchatImg = 1020;
 350 |   int32 exp = 1021;
 351 |   int64 fanTicketCount = 1022;
 352 |   bool foldStrangerChat = 1023;
 353 |   int64 followStatus = 1024;
 354 |   int32 ichatRestrictType = 1027;
 355 |   string idStr = 1028;
 356 |   bool isFollower = 1029;
 357 |   bool isFollowing = 1030;
 358 |   bool needProfileGuide = 1031;
 359 |   int64 payScores = 1032;
 360 |   bool pushCommentStatus = 1033;
 361 |   bool pushDigg = 1034;
 362 |   bool pushFollow = 1035;
 363 |   bool pushFriendAction = 1036;
 364 |   bool pushIchat = 1037;
 365 |   bool pushStatus = 1038;
 366 |   bool pushVideoPost = 1039;
 367 |   bool pushVideoRecommend = 1040;
 368 |   UserStats stats = 1041;
 369 |   string verifiedReason = 1043;
 370 |   bool withCarManagementPermission = 1044;
 371 |   repeated LiveEventInfo upcomingEventList = 1045;
 372 |   string scmLabel = 1046;
 373 |   EcommerceEntrance ecommerceEntrance = 1047;
 374 |   bool isBlock = 1048;
 375 | 
 376 |   message LiveEventInfo {
 377 |     int64 eventId = 1;
 378 |     int64 startTime = 2;
 379 |     int64 duration = 3;
 380 |     string title = 4;
 381 |     string description = 5;
 382 |     bool hasSubscribed = 6;
 383 |     bool isPaidEvent = 7;
 384 |     int64 ticketAmount = 8;
 385 |     int64 payMethod = 9; // @warning Enum not found, should be PayMethod
 386 | 
 387 | 
 388 |     // @EventPayMethod
 389 |     // webcast.data.LiveEventInfo
 390 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 391 |     enum EventPayMethod {
 392 |       EVENTPAYMETHODINVALID = 0;
 393 |       EVENTPAYMETHODCOINS = 1;
 394 |       EVENTPAYMETHODCASH = 2;
 395 |     }
 396 | 
 397 | 
 398 |     // @WalletPackage
 399 |     // proto.webcast.data.LiveEventInfo
 400 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 401 |     message WalletPackage {
 402 |       string iapId = 1;
 403 |       string usdPriceShow = 2;
 404 |     }
 405 | 
 406 |   }
 407 | 
 408 | 
 409 |   // @ActivityInfo
 410 |   // proto.webcast.data.User
 411 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 412 |   message ActivityInfo {
 413 |     Image badge = 1;
 414 |     Image storytag = 2;
 415 |   }
 416 | 
 417 | 
 418 | 
 419 |   // @AnchorLevel
 420 |   // proto.webcast.data.User
 421 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 422 |   message AnchorLevel {
 423 |     int64 level = 1;
 424 |     int64 experience = 2;
 425 |     int64 lowestExperienceThisLevel = 3;
 426 |     int64 highestExperienceThisLevel = 4;
 427 |     int64 taskStartExperience = 5;
 428 |     int64 taskStartTime = 6;
 429 |     int64 taskDecreaseExperience = 7;
 430 |     int64 taskTargetExperience = 8;
 431 |     int64 taskEndTime = 9;
 432 |     Image profileDialogBg = 10;
 433 |     Image profileDialogBgBack = 11;
 434 |     Image stageLevel = 12;
 435 |     Image smallIcon = 13;
 436 |   }
 437 | 
 438 | 
 439 |   // @AuthenticationInfo
 440 |   // proto.webcast.data.User
 441 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 442 |   message AuthenticationInfo {
 443 |     string customVerify = 1;
 444 |     string enterpriseVerifyReason = 2;
 445 |     Image authenticationBadge = 3;
 446 |   }
 447 | 
 448 | 
 449 |   // @AuthorStats
 450 |   // proto.webcast.data.User
 451 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 452 |   message AuthorStats {
 453 |     int64 videoTotalCount = 1;
 454 |     int64 videoTotalPlayCount = 2;
 455 |     int64 videoTotalShareCount = 3;
 456 |     int64 videoTotalSeriesCount = 4;
 457 |     int64 varietyShowPlayCount = 5;
 458 |     int64 videoTotalFavoriteCount = 6;
 459 |   }
 460 | 
 461 | 
 462 |   // @Border
 463 |   // proto.webcast.data.User
 464 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 465 |   message Border {
 466 |     Image icon = 1;
 467 |     int64 level = 2;
 468 |     string source = 3;
 469 |     Image profileDecorationRibbon = 4;
 470 |     string avatarBackgroundColor = 7;
 471 |     string avatarBackgroundBorderColor = 8;
 472 |   }
 473 | 
 474 | 
 475 |   // @ComboBadgeInfo
 476 |   // proto.webcast.data.User
 477 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 478 |   message ComboBadgeInfo {
 479 |     Image icon = 1;
 480 |     int64 comboCount = 2;
 481 |   }
 482 | 
 483 | 
 484 |   // @EcommerceEntrance
 485 |   // proto.webcast.data.User
 486 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 487 |   message EcommerceEntrance {
 488 |     EntranceType entranceType = 1; // Enum
 489 |     CreatorType creatorType = 2; // Enum
 490 |     string schema = 3;
 491 |     ShopEntranceInfo shopEntranceInfo = 4;
 492 |     ShowcaseEntranceInfo showcaseEntranceInfo = 5;
 493 | 
 494 | 
 495 |     // @CreatorType
 496 |     // webcast.data.User.EcommerceEntrance
 497 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 498 |     enum CreatorType {
 499 |       UNDEFINED = 0;
 500 |       OFFICIAL = 1;
 501 |       MARKET = 2;
 502 |       NORMAL = 3;
 503 |     }
 504 | 
 505 | 
 506 |     // @EntranceType
 507 |     // webcast.data.User.EcommerceEntrance
 508 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 509 |     enum EntranceType {
 510 |       PROFILE = 0;
 511 |       SHOWCASE = 1;
 512 |       SHOP = 2;
 513 |     }
 514 | 
 515 | 
 516 |     // @ShopEntranceInfo
 517 |     // proto.webcast.data.User.EcommerceEntrance
 518 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 519 |     message ShopEntranceInfo {
 520 |       string shopId = 1;
 521 |       string shopName = 2;
 522 |       string shopRating = 3;
 523 |       StoreLabel storeLabel = 4;
 524 |       string formatSoldCount = 5;
 525 |       int64 soldCount = 6;
 526 |       int32 expRatePercentile = 7;
 527 |       string expRateTopDisplay = 8;
 528 |       int32 rateDisplayStyle = 9;
 529 |       bool showRateNotApplicable = 10;
 530 | 
 531 | 
 532 |       // @StoreLabel
 533 |       // proto.webcast.data.User.EcommerceEntrance.ShopEntranceInfo
 534 |       // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 535 |       message StoreLabel {
 536 |         StoreOfficialLabel officialLabel = 1;
 537 |         bool isBytemall = 2;
 538 | 
 539 | 
 540 |         // @StoreBrandLabelType
 541 |         // webcast.data.User.EcommerceEntrance.ShopEntranceInfo.StoreLabel
 542 |         // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 543 |         enum StoreBrandLabelType {
 544 |           NONE = 0;
 545 |           OFFICIAL = 1;
 546 |           AUTHORIZED = 2;
 547 |           STORE_BRAND_LABEL_TYPE_BLUE_V = 3;
 548 |           STORE_BRAND_LABEL_TYPE_TOP_CHOICE = 4;
 549 |         }
 550 | 
 551 | 
 552 |         // @StoreOfficialLabel
 553 |         // proto.webcast.data.User.EcommerceEntrance.ShopEntranceInfo.StoreLabel
 554 |         // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 555 |         message StoreOfficialLabel {
 556 |           ShopLabelImage labelImageLight = 1;
 557 |           ShopLabelImage labelImageDark = 2;
 558 |           int64 labelType = 3; // @warning Enum not found, should be LabelType
 559 |           string labelTypeStr = 4;
 560 | 
 561 | 
 562 |           // @ShopLabelImage
 563 |           // proto.webcast.data.User.EcommerceEntrance.ShopEntranceInfo.StoreLabel.StoreOfficialLabel
 564 |           // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 565 |           message ShopLabelImage {
 566 |             int32 height = 1;
 567 |             int32 width = 2;
 568 |             string minetype = 3;
 569 |             string thumbUri = 4;
 570 |             repeated string thumbUriList = 5;
 571 |             string uri = 6;
 572 |             repeated string urlList = 7;
 573 |             string color = 8;
 574 |           }
 575 | 
 576 |         }
 577 | 
 578 |       }
 579 | 
 580 |     }
 581 | 
 582 | 
 583 |     // @ShowcaseEntranceInfo
 584 |     // proto.webcast.data.User.EcommerceEntrance
 585 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 586 |     message ShowcaseEntranceInfo {
 587 |       string formatSoldCount = 1;
 588 |       int64 soldCount = 2;
 589 |     }
 590 | 
 591 |   }
 592 | 
 593 | 
 594 |   // @FansClub
 595 |   // proto.webcast.data.User
 596 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 597 |   message FansClub {
 598 |     FansClubData data = 1;
 599 | 
 600 | 
 601 |     // @FansClubData
 602 |     // proto.webcast.data.User.FansClub
 603 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 604 |     message FansClubData {
 605 |       string clubName = 1;
 606 |       int32 level = 2;
 607 |       UserFansClubStatus userFansClubStatus = 3; // Enum
 608 |       repeated int64 availableGiftIdsList = 5;
 609 |       int64 anchorId = 6;
 610 | 
 611 | 
 612 |       // @BadgeIcon
 613 |       // webcast.data.User.FansClub.FansClubData
 614 |       // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 615 |       enum BadgeIcon {
 616 |         UNKNOWN = 0;
 617 |         ICON = 1;
 618 |         SMALLICON = 2;
 619 |       }
 620 | 
 621 | 
 622 |       // @UserFansClubStatus
 623 |       // webcast.data.User.FansClub.FansClubData
 624 |       // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 625 |       enum UserFansClubStatus {
 626 |         NOTJOINED = 0;
 627 |         ACTIVE = 1;
 628 |         INACTIVE = 2;
 629 |       }
 630 | 
 631 |     }
 632 | 
 633 | 
 634 |     // @PreferntialType
 635 |     // webcast.data.User.FansClub
 636 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 637 |     enum PreferntialType {
 638 |       PRESONALPROFILE = 0;
 639 |       OTHERROOM = 1;
 640 |     }
 641 | 
 642 |   }
 643 | 
 644 | 
 645 |   // @FansClubInfo
 646 |   // proto.webcast.data.User
 647 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 648 |   message FansClubInfo {
 649 |     bool isSleeping = 1;
 650 |     int64 fansLevel = 2;
 651 |     int64 fansScore = 3;
 652 |     Image badge = 4;
 653 |     int64 fansCount = 5;
 654 |   }
 655 | 
 656 | 
 657 |   // @FollowInfo
 658 |   // proto.webcast.data.User
 659 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 660 |   message FollowInfo {
 661 |     int64 followingCount = 1;
 662 |     int64 followerCount = 2;
 663 |     int64 followStatus = 3;
 664 |     int64 pushStatus = 4;
 665 |   }
 666 | 
 667 | 
 668 |   // @OwnRoom
 669 |   // proto.webcast.data.User
 670 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 671 |   message OwnRoom {
 672 |     repeated int64 roomIdsList = 1;
 673 |     repeated string roomIdsStrList = 2;
 674 |   }
 675 | 
 676 | 
 677 |   // @PayGrade
 678 |   // proto.webcast.data.User
 679 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 680 |   message PayGrade {
 681 |     Image diamondIcon = 2;
 682 |     string name = 3;
 683 |     Image icon = 4;
 684 |     string nextName = 5;
 685 |     int64 level = 6;
 686 |     Image nextIcon = 7;
 687 |     string gradeDescribe = 13;
 688 |     repeated GradeIcon gradeIconList = 14;
 689 |     int64 screenChatType = 15;
 690 |     Image imIcon = 16;
 691 |     Image imIconWithLevel = 17;
 692 |     Image liveIcon = 18;
 693 |     Image newImIconWithLevel = 19;
 694 |     Image newLiveIcon = 20;
 695 |     int64 upgradeNeedConsume = 21;
 696 |     string nextPrivileges = 22;
 697 |     Image background = 23;
 698 |     Image backgroundBack = 24;
 699 |     int64 score = 25;
 700 |     string gradeBanner = 1001;
 701 |     Image profileDialogBg = 1002;
 702 |     Image profileDialogBgBack = 1003;
 703 | 
 704 | 
 705 |     // @GradeIcon
 706 |     // proto.webcast.data.User.PayGrade
 707 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 708 |     message GradeIcon {
 709 |       Image icon = 1;
 710 |       int64 iconDiamond = 2;
 711 |       int64 level = 3;
 712 |       string levelStr = 4;
 713 |     }
 714 | 
 715 |   }
 716 | 
 717 | 
 718 |   // @SubscribeBadge
 719 |   // proto.webcast.data.User
 720 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 721 |   message SubscribeBadge {
 722 |     Image originImg = 3;
 723 |     Image previewImg = 4;
 724 |   }
 725 | 
 726 | 
 727 |   // @SubscribeInfo
 728 |   // proto.webcast.data.User
 729 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 730 |   message SubscribeInfo {
 731 |     bool qualification = 1;
 732 |     bool isSubscribe = 2;
 733 |     SubscribeBadge badge = 3;
 734 |     bool enableSubscription = 4;
 735 |     int64 subscriberCount = 5;
 736 |     bool isInGracePeriod = 6;
 737 |     bool isSubscribedToAnchor = 7;
 738 |     bool userGiftSubAuth = 9;
 739 |     bool anchorGiftSubAuth = 10;
 740 |   }
 741 | 
 742 | 
 743 |   // @UserAttr
 744 |   // proto.webcast.data.User
 745 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 746 |   message UserAttr {
 747 |     bool isMuted = 1;
 748 |     bool isAdmin = 2;
 749 |     bool isSuperAdmin = 3;
 750 |     int64 muteDuration = 4;
 751 |   }
 752 | 
 753 | 
 754 |   // @UserStats
 755 |   // proto.webcast.data.User
 756 |   // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 757 |   message UserStats {
 758 |     int64 id = 1;
 759 |     string idStr = 2;
 760 |     int64 followingCount = 3;
 761 |     int64 followerCount = 4;
 762 |     int64 recordCount = 5;
 763 |     int64 totalDuration = 6;
 764 |     int64 dailyFanTicketCount = 7;
 765 |     int64 dailyIncome = 8;
 766 |     int64 itemCount = 9;
 767 |     int64 favoriteItemCount = 10;
 768 |     int64 diamondConsumedCount = 12;
 769 |     int64 tuwenItemCount = 13;
 770 |   }
 771 | 
 772 | }
 773 | 
 774 | // @Emote
 775 | message Emote {
 776 |   string emoteId = 1;
 777 |   Image image = 2;
 778 |   AuditStatus auditStatus = 3; // Enum
 779 |   string uuid = 4;
 780 |   EmoteType emoteType = 5; // Enum
 781 |   ContentSource contentSource = 6; // Enum
 782 |   EmotePrivateType emotePrivateType = 7; // Enum
 783 | }
 784 | 
 785 | // @PunishEventInfo
 786 | message PunishEventInfo {
 787 |   string punishType = 1;
 788 |   string punishReason = 2;
 789 |   string punishId = 3;
 790 |   int64 violationUid = 4;
 791 |   int32 punishTypeId = 5; // Enum
 792 |   int64 duration = 6;
 793 | }
 794 | 
 795 | // @MsgFilter
 796 | message MsgFilter {
 797 |   bool isGifter = 1;
 798 |   bool isSubscribedToAnchor = 2;
 799 | }
 800 | 
 801 | // @UserIdentity
 802 | // proto.webcast.data
 803 | message UserIdentity {
 804 |   bool isGiftGiverOfAnchor = 1;
 805 |   bool isSubscriberOfAnchor = 2;
 806 |   bool isMutualFollowingWithAnchor = 3;
 807 |   bool isFollowerOfAnchor = 4;
 808 |   bool isModeratorOfAnchor = 5;
 809 |   bool isAnchor = 6;
 810 | }
 811 | 
 812 | // @Goal
 813 | // proto.webcast.data
 814 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 815 | message Goal {
 816 |   int64 id = 1;
 817 |   // TextType type = 2; // Enum
 818 |   // GoalStatus status = 3; // Enum
 819 |   // repeated SubGoal subGoalsList = 4;
 820 |   string description = 5;
 821 |   int32 auditStatus = 6;
 822 |   // CycleType cycleType = 7; // Enum
 823 |   int64 startTime = 8;
 824 |   int64 expireTime = 9;
 825 |   int64 realFinishTime = 10;
 826 |   repeated GoalContributor contributorsList = 11;
 827 |   int32 contributorsLength = 12;
 828 |   string idStr = 13;
 829 |   string auditDescription = 14;
 830 |   GoalStats stats = 15;
 831 | 
 832 |   message GoalStats {
 833 |     int64 totalCoins = 1;
 834 |     int64 totalContributor = 2;
 835 |   }
 836 | 
 837 |   message GoalContributor {
 838 |     int64 userId = 1;
 839 |     Image avatar = 2;
 840 |     string displayId = 3;
 841 |     int64 score = 4;
 842 |     string userIdStr = 5;
 843 |     bool inRoom = 6;
 844 |     bool isFriend = 7;
 845 |     repeated BadgeStruct badgeList = 8;
 846 |     bool followByOwner = 9;
 847 |     bool isFistContribute = 10;
 848 |   }
 849 | 
 850 | }
 851 | 
 852 | // @Indicator
 853 | // proto.webcast.data
 854 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
 855 | message Indicator {
 856 |   string key = 1;
 857 |   int64 op = 2; // @warning Enum not found, should be Op
 858 | }
 859 | 
 860 | 
 861 | // --- HANDMANDE
 862 | 
 863 | message Ranking {
 864 |   string type = 1;
 865 |   string label = 2;
 866 |   TikTokColor color = 3;
 867 |   repeated ValueLabel details = 4;
 868 | }
 869 | 
 870 | message TikTokColor {
 871 |   string color = 1;
 872 |   uint64 id = 4;
 873 |   uint32 data1 = 6;
 874 | }
 875 | 
 876 | message ValueLabel {
 877 |   uint32 data = 1;
 878 |   string label = 2;
 879 |   string label2 = 3;
 880 |   string label3 = 11;
 881 | }
 882 | 
 883 | message MessageDetails {
 884 |   uint32 data1 = 1;
 885 |   TikTokColor color = 2;
 886 |   string category = 11;
 887 |   UserContainer user = 21;
 888 | }
 889 | 
 890 | message UserContainer {
 891 |   User user = 1;
 892 |   uint32 data1 = 2;
 893 | }
 894 | 
 895 | // Container for uint-Data
 896 | message DataContainer {
 897 |   uint64 data1 = 1;
 898 |   uint32 data2 = 2;
 899 |   uint32 data3 = 3;
 900 |   uint32 data4 = 4;
 901 |   uint32 data5 = 5;
 902 |   uint32 data6 = 6;
 903 |   uint32 data7 = 7;
 904 |   uint32 data8 = 8;
 905 |   uint32 data9 = 9;
 906 | }
 907 | 
 908 | message TimeStampContainer {
 909 |   uint64 timestamp1 = 1;
 910 |   uint64 timestamp2 = 2;
 911 |   uint64 timestamp3 = 3;
 912 | }
 913 | message MemberMessageData {
 914 |   string type = 1;
 915 |   string label = 2;
 916 |   TikTokColor color = 3;
 917 |   repeated MessageDetails details = 4; // UserContainer-Data is empty
 918 | }
 919 | message LinkMicArmiesItems {
 920 |   uint64 hostUserId = 1;
 921 |   repeated LinkMicArmiesGroup battleGroups = 2;
 922 | 
 923 |   message LinkMicArmiesGroup {
 924 |     repeated User users = 1;
 925 |     uint32 points = 2;
 926 |   }
 927 | }
 928 | 
 929 | message PollStartContent {
 930 |   int64 StartTime = 1;
 931 |   int64 EndTime = 2;
 932 |   repeated PollOptionInfo OptionList = 3;
 933 |   string Title = 4;
 934 |   User Operator = 5;
 935 | }
 936 | 
 937 | message PollEndContent {
 938 |   int32 EndType = 1; // Possibly an Enum?
 939 |   repeated PollOptionInfo OptionList = 2;
 940 |   User Operator = 3;
 941 | }
 942 | 
 943 | message PollOptionInfo {
 944 |   int32 Votes = 1;
 945 |   string DisplayContent = 2;
 946 |   int32 OptionIdx = 3;
 947 |   repeated VoteUser VoteUserList = 4;
 948 | }
 949 | 
 950 | message VoteUser {
 951 |   int64 UserId = 1;
 952 |   string NickName = 2;
 953 |   Image AvatarThumb = 3;
 954 | }
 955 | 
 956 | message PollUpdateVotesContent {
 957 |   repeated PollOptionInfo OptionList = 2;
 958 | }
 959 | message UserFanTicket {
 960 |   int64 UserId = 1;
 961 |   int64 FanTicket = 2;
 962 |   int64 MatchTotalScore = 3;
 963 |   int32 MatchRank = 4;
 964 | }
 965 | 
 966 | message FanTicketRoomNoticeContent {
 967 |   repeated UserFanTicket UserFanTicketList = 1;
 968 |   int64 TotalLinkMicFanTicket = 2;
 969 |   int64 MatchId = 3;
 970 |   int64 EventTime = 4;
 971 |   string FanTicketIconUrl = 5;
 972 | }
 973 | 
 974 | message LinkerAcceptNoticeContent {
 975 |   int64 fromUserId = 1;
 976 |   int64 fromRoomId = 2;
 977 |   int64 toUserId = 3;
 978 | }
 979 | 
 980 | message LinkerCancelContent {
 981 |   int64 fromUserId = 1;
 982 |   int64 toUserId = 2;
 983 |   int64 cancelType = 3;
 984 |   int64 actionId = 4;
 985 | }
 986 | 
 987 | message ListUser {
 988 |   User user = 1;
 989 |   int64 linkmicId = 2;
 990 |   string linkmicIdStr = 3;
 991 |   int64 linkStatus = 4; // Enum
 992 |   LinkType linkType = 5; // Enum
 993 |   int32 userPosition = 6;
 994 |   int32 silenceStatus = 7; // Enum
 995 |   int64 modifyTime = 8;
 996 |   int64 linkerId = 9;
 997 |   int32 roleType = 10; // Enum
 998 | 
 999 |   enum LinkType {
1000 |     LINK_UNKNOWN = 0;
1001 |     AUDIO = 1;
1002 |     VIDEO = 2;
1003 |   }
1004 | }
1005 | 
1006 | 
1007 | //it is just empty
1008 | message LinkerCloseContent {
1009 | 
1010 | }
1011 | 
1012 | message LinkerCreateContent {
1013 |   int64 ownerId = 1;
1014 |   int64 ownerRoomId = 2;
1015 |   int64 linkType = 3;
1016 | }
1017 | 
1018 | 
1019 | 
1020 | message LinkerEnterContent {
1021 |   repeated ListUser linkedUsersList = 1;
1022 |   int32 anchorMultiLiveEnum = 2; // Enum
1023 |   LinkmicUserSettingInfo anchorSettingInfo = 3;;
1024 | }
1025 | 
1026 | message LinkerInviteContent {
1027 |   int64 fromUserId = 1;
1028 |   int64 fromRoomId = 2;
1029 |   string toRtcExtInfo = 3;
1030 |   bool rtcJoinChannel = 4;
1031 |   int64 vendor = 5;
1032 |   string secFromUserId = 6;
1033 |   string toLinkmicIdStr = 7;
1034 |   User fromUser = 8;
1035 |   int64 requiredMicIdx = 9;
1036 | }
1037 | 
1038 | message LinkerKickOutContent {
1039 |   int64 fromUserId = 1;
1040 |   KickoutReason kickoutReason = 2; // Enum
1041 | }
1042 | 
1043 | message LinkerLeaveContent {
1044 |   int64 userId = 1;
1045 |   string linkmicIdStr = 2;
1046 |   int64 sendLeaveUid = 3;
1047 |   int64 leaveReason = 4;
1048 | }
1049 | 
1050 | //Empty
1051 | message LinkerLinkedListChangeContent {
1052 | 
1053 | }
1054 | //Empty
1055 | message CohostListChangeContent {
1056 | }
1057 | 
1058 | 
1059 | message LinkerListChangeContent {
1060 |   repeated ListUser linkedUsers = 1;
1061 |   repeated ListUser appliedUsers = 2;
1062 |   repeated ListUser connectingUsers = 3;
1063 | }
1064 | 
1065 | message LinkerMediaChangeContent {
1066 |   int64 op = 1; // Enum
1067 |   int64 toUserId = 2;
1068 |   int64 anchorId = 3;
1069 |   int64 roomId = 4;
1070 |   int64 changeScene = 5; // Enum
1071 | }
1072 | 
1073 | //Empty
1074 | message LinkerMicIdxUpdateContent {
1075 | 
1076 | }
1077 | 
1078 | 
1079 | message LinkerMuteContent {
1080 |   int64 userId = 1;
1081 |   int64 status = 2; // Enum
1082 | }
1083 | 
1084 | message LinkerRandomMatchContent {
1085 |   User user = 1;
1086 |   int64 roomId = 2;
1087 |   int64 inviteType = 3;
1088 |   string matchId = 4;
1089 |   int64 innerChannelId = 5;
1090 | }
1091 | 
1092 | message LinkerReplyContent {
1093 |   int64 fromUserId = 1;
1094 |   int64 fromRoomId = 2;
1095 |   LinkmicInfo fromUserLinkmicInfo = 3;
1096 |   int64 toUserId = 4;
1097 |   LinkmicInfo toUserLinkmicInfo = 5;
1098 |   int64 linkType = 6;
1099 |   int64 replyStatus = 7;
1100 |   LinkerSetting linkerSetting = 8;
1101 |   User fromUser = 9;
1102 |   User toUser = 10;
1103 | 
1104 |   message LinkmicInfo {
1105 |     string accessKey = 1;
1106 |     int64 linkMicId = 2;
1107 |     bool joinable = 3;
1108 |     int32 confluenceType = 4;
1109 |     string rtcExtInfo = 5;
1110 |     string rtcAppId = 6;
1111 |     string rtcAppSign = 7;
1112 |     string linkmicIdStr = 8;
1113 |     int64 vendor = 9;
1114 |   }
1115 | }
1116 | 
1117 | message LinkerSetting {
1118 |   int64 MaxMemberLimit = 1;
1119 |   int64 LinkType = 2;
1120 |   int64 Scene = 3;
1121 |   int64 OwnerUserId = 4;
1122 |   int64 OwnerRoomId = 5;
1123 |   int64 Vendor = 6;
1124 | }
1125 | 
1126 | message LinkerSysKickOutContent {
1127 |   int64 userId = 1;
1128 |   string linkmicIdStr = 2;
1129 | }
1130 | 
1131 | message LinkmicUserToastContent {
1132 |   int64 userId = 1;
1133 |   int64 roomId = 2;
1134 |   Text displayText = 3;
1135 | }
1136 | 
1137 | message LinkerUpdateUserContent {
1138 |   int64 fromUserId = 1;
1139 |   int64 toUserId = 2;
1140 | }
1141 | 
1142 | //Empty
1143 | message LinkerUpdateUserSettingContent {
1144 | 
1145 | }
1146 | 
1147 | //Empty
1148 | message LinkerWaitingListChangeContent {
1149 | 
1150 | }
1151 | 
1152 | 
1153 | message LinkmicUserSettingInfo {
1154 |   int64 userId = 1;
1155 |   int64 layout = 2; // @warning Enum not found, should be Layout
1156 |   int64 fixMicNum = 3; // @warning Enum not found, should be FixMicNum
1157 |   int64 allowRequestFromUser = 4; // @warning Enum not found, should be AllowRequestFromUser
1158 |   int64 allowRequestFromFollowerOnly = 5; // @warning Enum not found, should be AllowRequestFromFollowerOnly
1159 |   LinkmicApplierSortSetting applierSortSetting = 7; // Enum
1160 | }
1161 | 
1162 | 
1163 | message Player {
1164 |   int64 roomId = 1;
1165 |   int64 userId = 2;
1166 | }
1167 | 
1168 | message AllListUser {
1169 |   repeated LinkLayerListUser linkedList = 2;
1170 |   repeated LinkLayerListUser appliedList = 3;
1171 |   repeated LinkLayerListUser invitedList = 4;
1172 |   repeated LinkLayerListUser readyList = 5;
1173 | }
1174 | 
1175 | message LinkLayerListUser {
1176 |   User user = 1;
1177 |   int64 linkmicId = 2;
1178 |   Position pos = 3;
1179 |   int64 linkedTimeNano = 4;
1180 |   string appVersion = 5;
1181 |   int64 magicNumber1 = 7;
1182 | }
1183 | 
1184 | message Position {
1185 |   int32 type = 1;
1186 |   LinkPosition link = 2;
1187 | }
1188 | 
1189 | message LinkPosition {
1190 |   int32 position = 1;
1191 |   int32 opt = 2;
1192 | }
1193 | 
1194 | message GroupPlayer {
1195 |   int64 channelId = 1;
1196 |   User user = 2;
1197 | }
1198 | 
1199 | message DSLConfig {
1200 |   int32 sceneVersion = 1;
1201 |   string layoutId = 2;
1202 | }
1203 | 
1204 | message GroupChannelAllUser {
1205 |   int64 groupChannelId = 1;
1206 |   repeated GroupChannelUser userList = 2;
1207 | }
1208 | 
1209 | message GroupChannelUser {
1210 |   int64 channelId = 1;
1211 |   GroupStatus status = 2; // Enum
1212 |   TextType type = 3; // Enum
1213 |   AllListUser allUser = 4;
1214 |   int64 joinTime = 5;
1215 |   int64 linkedTime = 6;
1216 |   GroupPlayer ownerUser = 7;
1217 | }
1218 | 
1219 | message RTCExtraInfo {
1220 |   RTCEngineConfig liveRtcEngineConfig = 1;
1221 |   repeated RTCLiveVideoParam liveRtcVideoParamList = 2;
1222 |   RTCBitrateMap rtcBitrateMap = 3;
1223 |   int32 rtcFps = 4;
1224 |   string rtcBusinessId = 8;
1225 |   int32 interactClientType = 10;
1226 | 
1227 |   message RTCEngineConfig {
1228 |     string rtcAppId = 1;
1229 |     string rtcUserId = 2;
1230 |     string rtcToken = 3;
1231 |     int64 rtcChannelId = 4;
1232 |   }
1233 | 
1234 |   message RTCLiveVideoParam {
1235 |     int32 strategyId = 1;
1236 |     RTCVideoParam params = 2;
1237 |   }
1238 | 
1239 |   message RTCVideoParam {
1240 |     int32 width = 1;
1241 |     int32 height = 2;
1242 |     int32 fps = 3;
1243 |     int32 bitrateKbps = 4;
1244 |   }
1245 | 
1246 |   message RTCBitrateMap {
1247 |     int32 xx1 = 1;
1248 |     int32 xx2 = 2;
1249 |     int32 xx3 = 3;
1250 |     int32 xx4 = 4;
1251 |   }
1252 | }
1253 | 
1254 | message CreateChannelContent {
1255 |   Player  owner = 1;
1256 |   string ownerLinkMicId = 2;
1257 | }
1258 | 
1259 | message ListChangeContent {
1260 |   TextType type = 1; // Enum
1261 |   AllListUser list = 2;
1262 | }
1263 | 
1264 | message MultiLiveContent {
1265 |   InviteBizContent inviteBizContent = 2;
1266 |   ReplyBizContent replyBizContent = 3;
1267 |   PermitBizContent permitBizContent = 4;
1268 |   KickOutBizContent kickOutBizContent = 6;
1269 | 
1270 | 
1271 |   message InviteBizContent {
1272 |     LinkmicUserSettingInfo anchorSettingInfo = 1;
1273 |     int64 inviteSource = 2; // @warning Enum not found, should be InviteSource
1274 |     User operatorUserInfo = 3;
1275 |     int64 operatorLinkAdminType = 4; // @warning Enum not found, should be OperatorLinkAdminType
1276 |     User inviteeUserInfo = 5;
1277 |   }
1278 | 
1279 | 
1280 |   message ReplyBizContent {
1281 |     int32 linkType = 1;
1282 |     int32 isTurnOffInvitation = 2;
1283 |     User replyUserInfo = 3;
1284 |   }
1285 | 
1286 |   message PermitBizContent {
1287 |     LinkmicUserSettingInfo anchorSettingInfo = 1;
1288 |     int64 expireTimestamp = 2;
1289 |     User operatorUserInfo = 3;
1290 |     int64 operatorLinkAdminType = 4; // @warning Enum not found, should be OperatorLinkAdminType
1291 |   }
1292 | 
1293 |   message KickOutBizContent {
1294 |     User operatorUserInfo = 1;
1295 |     int64 operatorLinkAdminType = 2; // @warning Enum not found, should be OperatorLinkAdminType
1296 |     User kickPlayerUserInfo = 3;
1297 |   }
1298 | 
1299 | }
1300 | 
1301 | 
1302 | message InviteContent {
1303 |   Player  invitor = 1;
1304 |   RTCExtraInfo inviteeRtcExtInfo = 2;
1305 |   string invitorLinkMicId = 3;
1306 |   string inviteeLinkMicId = 4;
1307 |   bool isOwner = 5;
1308 |   Position pos = 6;
1309 |   DSLConfig dsl = 7;
1310 |   User invitee = 8;
1311 |   User operator = 9;
1312 | }
1313 | 
1314 | 
1315 | // @ApplyContent
1316 | // proto.webcast.im
1317 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1318 | message ApplyContent {
1319 |   Player  applier = 1;
1320 |   string applierLinkMicId = 2;
1321 | }
1322 | 
1323 | 
1324 | // @PermitApplyContent
1325 | // proto.webcast.im
1326 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1327 | message PermitApplyContent {
1328 |   Player  permiter = 1;
1329 |   string permiterLinkMicId = 2;
1330 |   Position applierPos = 3;
1331 |   ReplyStatus replyStatus = 4; // Enum
1332 |   DSLConfig dsl = 5;
1333 |   User applier = 6;
1334 |   User operator = 7;
1335 |   string applierLinkMicId = 8;
1336 | }
1337 | 
1338 | 
1339 | // @ReplyInviteContent
1340 | // proto.webcast.im
1341 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1342 | message ReplyInviteContent {
1343 |   Player  invitee = 1;
1344 |   ReplyStatus replyStatus = 2; // Enum
1345 |   string inviteeLinkMicId = 3;
1346 |   Position inviteePos = 4;
1347 |   Player  inviteOperatorUser = 5;
1348 | }
1349 | 
1350 | 
1351 | // @KickOutContent
1352 | // proto.webcast.im
1353 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1354 | message KickOutContent {
1355 |   Player  offliner = 1;
1356 |   KickoutReason kickoutReason = 2; // Enum
1357 | }
1358 | 
1359 | 
1360 | // @CancelApplyContent
1361 | // proto.webcast.im
1362 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1363 | message CancelApplyContent {
1364 |   Player  applier = 1;
1365 |   string applierLinkMicId = 2;
1366 | }
1367 | 
1368 | 
1369 | // @CancelInviteContent
1370 | // proto.webcast.im
1371 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1372 | message CancelInviteContent {
1373 |   Player  invitor = 1;
1374 |   string invitorLinkMicId = 2;
1375 |   string inviteeLinkMicId = 3;
1376 |   int64 inviteSeqId = 4;
1377 |   Player  invitee = 5;
1378 | }
1379 | 
1380 | 
1381 | // @LeaveContent
1382 | // proto.webcast.im
1383 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1384 | message LeaveContent {
1385 |   Player  leaver = 1;
1386 |   int64 leaveReason = 2;
1387 | }
1388 | 
1389 | 
1390 | // @FinishChannelContent
1391 | // proto.webcast.im
1392 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1393 | message FinishChannelContent {
1394 |   Player  owner = 1;
1395 |   int64 finishReason = 2;
1396 | }
1397 | 
1398 | 
1399 | // @JoinDirectContent
1400 | // proto.webcast.im
1401 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1402 | message JoinDirectContent {
1403 |   LinkLayerListUser joiner = 1;
1404 |   AllListUser allUsers = 2;
1405 | }
1406 | 
1407 | 
1408 | // @LeaveJoinGroupContent
1409 | // proto.webcast.im
1410 | // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1411 | message LeaveJoinGroupContent {
1412 |   GroupPlayer operator = 1;
1413 |   int64 groupChannelId = 2;
1414 |   string leaveSource = 3;
1415 | }
1416 | 
1417 | 
1418 | // @PermitJoinGroupContent
1419 | // proto.webcast.im
1420 | message PermitJoinGroupContent {
1421 |   GroupPlayer approver = 1;
1422 |   AgreeStatus agreeStatus = 2; // Enum
1423 |   TextType type = 3; // Enum
1424 |   repeated RTCExtraInfo groupExtInfoList = 4;
1425 |   GroupChannelAllUser groupUser = 5;
1426 | }
1427 | 
1428 | 
1429 | // @CancelJoinGroupContent
1430 | // proto.webcast.im
1431 | message CancelJoinGroupContent {
1432 |   repeated GroupPlayer leaverList = 1;
1433 |   GroupPlayer operator = 2;
1434 |   TextType type = 3; // Enum
1435 | }
1436 | 
1437 | 
1438 | 
1439 | message P2PGroupChangeContent {
1440 |   repeated RTCExtraInfo groupExtInfoList = 1;
1441 |   GroupChannelAllUser groupUser = 2;
1442 | }
1443 | 
1444 | 
1445 | message BusinessContent {
1446 |   int64 overLength = 1;
1447 |   MultiLiveContent multiLiveContent = 100;
1448 |   CohostContent cohostContent = 200;
1449 | 
1450 |   message CohostContent {
1451 |     JoinGroupBizContent joinGroupBizContent = 1;
1452 | 
1453 |   }
1454 | 
1455 |   message JoinGroupBizContent {
1456 |     int32 fromRoomAgeRestricted = 1;
1457 |     Tag fromTag = 2;
1458 |     PerceptionDialogInfo dialog = 3;
1459 |     PunishEventInfo punishInfo = 4;
1460 |     JoinGroupMessageExtra joinGroupMsgExtra = 101;
1461 |   }
1462 | 
1463 |   message Tag {
1464 |     int32 tagType = 1;
1465 |     string tagValue = 2;
1466 |     string tagText = 3;
1467 |   }
1468 | 
1469 |   message PerceptionDialogInfo {
1470 |     int64 iconType = 1; // @warning Enum not found, should be IconType
1471 |     Text title = 2;
1472 |     Text subTitle = 3;
1473 |     Text adviceActionText = 4;
1474 |     Text defaultActionText = 5;
1475 |     string violationDetailUrl = 6;
1476 |     int32 scene = 7;
1477 |     int64 targetUserId = 8;
1478 |     int64 targetRoomId = 9;
1479 |     int64 countDownTime = 10;
1480 |     bool showFeedback = 11;
1481 |     repeated PerceptionFeedbackOption feedbackOptionsList = 12;
1482 |     int64 policyTip = 13;
1483 |   }
1484 | 
1485 |   message PerceptionFeedbackOption {
1486 |     int64 id = 1;
1487 |     string contentKey = 2;
1488 |   }
1489 | 
1490 |   message JoinGroupMessageExtra {
1491 |     int64 sourceType = 1;
1492 |     RivalExtra extra = 2;
1493 |     repeated RivalExtra otherUsersList = 3;
1494 | 
1495 | 
1496 |     // @RivalExtra
1497 |     // proto.webcast.im.JoinGroupMessageExtra
1498 |     // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
1499 |     message RivalExtra {
1500 |       int64 userCount = 4;
1501 |       Image avatarThumb = 5;
1502 |       string displayId = 6;
1503 |       AuthenticationInfo authenticationInfo = 7;
1504 |       string nickname = 8;
1505 |       int64 followStatus = 9;
1506 |       Hashtag hashtag = 10;
1507 |       TopHostInfo topHostInfo = 11;
1508 |       int64 userId = 12;
1509 |       bool isBestTeammate = 13;
1510 | 
1511 |       message AuthenticationInfo {
1512 |         string customVerify = 1;
1513 |         string enterpriseVerifyReason = 2;
1514 |         Image authenticationBadge = 3;
1515 |       }
1516 |     }
1517 |   }
1518 |   message Hashtag {
1519 |     int64 id = 1;
1520 |     string title = 2;
1521 |     Image image = 3;
1522 |     HashtagNamespace namespace = 4; // Enum
1523 |   }
1524 | 
1525 |   message TopHostInfo {
1526 |     string rankType = 1;
1527 |     int64 topIndex = 2;
1528 |   }
1529 | }
1530 | 
1531 | message JoinGroupContent {
1532 |   GroupChannelAllUser groupUser = 1;
1533 |   GroupPlayer joinUser = 2;
1534 |   TextType type = 3; // Enum
1535 | }


--------------------------------------------------------------------------------
/types.go:
--------------------------------------------------------------------------------
   1 | package gotiktoklive
   2 | 
   3 | import "time"
   4 | 
   5 | type Event interface {
   6 | 	CreatedTimestamp() int64
   7 | 	IsHistory() bool
   8 | }
   9 | 
  10 | type RoomEvent struct {
  11 | 	Timestamp int64
  12 | 	MessageID int64
  13 | 	Type      string
  14 | 	Message   string
  15 | 	isHistory bool
  16 | }
  17 | 
  18 | func (r RoomEvent) CreatedTimestamp() int64 {
  19 | 	return r.Timestamp
  20 | }
  21 | 
  22 | func (r RoomEvent) IsHistory() bool {
  23 | 	return r.isHistory
  24 | }
  25 | 
  26 | type ChatEvent struct {
  27 | 	MessageID    int64
  28 | 	Timestamp    int64
  29 | 	Comment      string
  30 | 	User         *User
  31 | 	UserIdentity *UserIdentity
  32 | 	isHistory    bool
  33 | }
  34 | 
  35 | func (c ChatEvent) IsHistory() bool {
  36 | 	return c.isHistory
  37 | }
  38 | 
  39 | func (c ChatEvent) CreatedTimestamp() int64 {
  40 | 	return c.Timestamp
  41 | }
  42 | 
  43 | type userEventType string
  44 | 
  45 | const (
  46 | 	USER_JOIN   userEventType = "user joined the stream"
  47 | 	USER_SHARE  userEventType = "user shared the stream"
  48 | 	USER_FOLLOW userEventType = "user followed the host"
  49 | )
  50 | 
  51 | type UserEvent struct {
  52 | 	Timestamp int64
  53 | 	MessageID int64
  54 | 	Event     userEventType
  55 | 	User      *User
  56 | 	isHistory bool
  57 | }
  58 | 
  59 | func (u UserEvent) CreatedTimestamp() int64 {
  60 | 	return u.Timestamp
  61 | }
  62 | 
  63 | func (u UserEvent) IsHistory() bool {
  64 | 	return u.isHistory
  65 | }
  66 | 
  67 | type ViewersEvent struct {
  68 | 	Timestamp int64
  69 | 	MessageID int64
  70 | 	Viewers   int
  71 | 	isHistory bool
  72 | }
  73 | 
  74 | func (v ViewersEvent) TimeComparableID() int64 {
  75 | 	return v.MessageID
  76 | }
  77 | 
  78 | func (v ViewersEvent) IsHistory() bool {
  79 | 	return v.isHistory
  80 | }
  81 | 
  82 | func (v ViewersEvent) CreatedTimestamp() int64 {
  83 | 	return v.Timestamp
  84 | }
  85 | 
  86 | type GiftEvent struct {
  87 | 	MessageID    int64
  88 | 	Timestamp    int64
  89 | 	ID           int64
  90 | 	Name         string
  91 | 	Describe     string
  92 | 	Diamonds     int
  93 | 	RepeatCount  int
  94 | 	RepeatEnd    bool
  95 | 	Type         int
  96 | 	ToUserID     int64
  97 | 	User         *User
  98 | 	UserIdentity *UserIdentity
  99 | 	isHistory    bool
 100 | 	GroupID      int64
 101 | 	IsComboGift  bool
 102 | }
 103 | 
 104 | func (g GiftEvent) CreatedTimestamp() int64 {
 105 | 	return g.Timestamp
 106 | }
 107 | 
 108 | func (g GiftEvent) IsHistory() bool {
 109 | 	return g.isHistory
 110 | }
 111 | 
 112 | type LikeEvent struct {
 113 | 	MessageID   int64
 114 | 	Timestamp   int64
 115 | 	Likes       int
 116 | 	TotalLikes  int
 117 | 	User        *User
 118 | 	DisplayType string
 119 | 	Label       string
 120 | 	isHistory   bool
 121 | }
 122 | 
 123 | func (l LikeEvent) IsHistory() bool {
 124 | 	return l.isHistory
 125 | }
 126 | 
 127 | func (l LikeEvent) CreatedTimestamp() int64 {
 128 | 	return l.Timestamp
 129 | }
 130 | 
 131 | type QuestionEvent struct {
 132 | 	MessageID int64
 133 | 	Timestamp int64
 134 | 	Quesion   string
 135 | 	User      *User
 136 | 	isHistory bool
 137 | }
 138 | 
 139 | func (q QuestionEvent) CreatedTimestamp() int64 {
 140 | 	return q.Timestamp
 141 | }
 142 | 
 143 | func (q QuestionEvent) IsHistory() bool {
 144 | 	return q.isHistory
 145 | }
 146 | 
 147 | type ControlEvent struct {
 148 | 	MessageID   int64
 149 | 	Timestamp   int64
 150 | 	Action      int
 151 | 	Description string
 152 | 	isHistory   bool
 153 | }
 154 | 
 155 | func (c ControlEvent) IsHistory() bool {
 156 | 	return c.isHistory
 157 | }
 158 | 
 159 | func (c ControlEvent) TimeComparableID() int64 {
 160 | 	return c.MessageID
 161 | }
 162 | 
 163 | func (c ControlEvent) CreatedTimestamp() int64 {
 164 | 	return c.Timestamp
 165 | }
 166 | 
 167 | type MicBattleEvent struct {
 168 | 	MessageID int64
 169 | 	Timestamp int64
 170 | 	Users     []*User
 171 | 	isHistory bool
 172 | }
 173 | 
 174 | func (m MicBattleEvent) IsHistory() bool {
 175 | 	return m.isHistory
 176 | }
 177 | 
 178 | func (m MicBattleEvent) CreatedTimestamp() int64 {
 179 | 	return m.Timestamp
 180 | }
 181 | 
 182 | type BattlesEvent struct {
 183 | 	MessageID int64
 184 | 	Timestamp int64
 185 | 	Status    int
 186 | 	Battles   []*Battle
 187 | 	isHistory bool
 188 | }
 189 | 
 190 | func (b BattlesEvent) IsHistory() bool {
 191 | 	return b.isHistory
 192 | }
 193 | 
 194 | func (b BattlesEvent) CreatedTimestamp() int64 {
 195 | 	return b.Timestamp
 196 | }
 197 | 
 198 | type RoomBannerEvent struct {
 199 | 	MessageID int64
 200 | 	Timestamp int64
 201 | 	Data      interface{}
 202 | 	isHistory bool
 203 | }
 204 | 
 205 | func (r RoomBannerEvent) IsHistory() bool {
 206 | 	return r.isHistory
 207 | }
 208 | 
 209 | func (r RoomBannerEvent) CreatedTimestamp() int64 {
 210 | 	return r.Timestamp
 211 | }
 212 | 
 213 | type IntroEvent struct {
 214 | 	MessageID int64
 215 | 	Timestamp int64
 216 | 	ID        int
 217 | 	Title     string
 218 | 	User      *User
 219 | 	isHistory bool
 220 | }
 221 | 
 222 | func (i IntroEvent) IsHistory() bool {
 223 | 	return i.isHistory
 224 | }
 225 | 
 226 | func (i IntroEvent) TimeComparableID() int64 {
 227 | 	return i.MessageID
 228 | }
 229 | 
 230 | func (i IntroEvent) CreatedTimestamp() int64 {
 231 | 	return i.Timestamp
 232 | }
 233 | 
 234 | type Battle struct {
 235 | 	Host   int64
 236 | 	Groups []*BattleGroup
 237 | }
 238 | 
 239 | type BattleGroup struct {
 240 | 	Points int
 241 | 	Users  []*User
 242 | }
 243 | 
 244 | type User struct {
 245 | 	ID              int64
 246 | 	Username        string
 247 | 	Nickname        string
 248 | 	ProfilePicture  *ProfilePicture
 249 | 	ExtraAttributes *ExtraAttributes
 250 | 	Badge           *BadgeAttributes
 251 | }
 252 | 
 253 | type UserIdentity struct {
 254 | 	IsGiftGiver       bool
 255 | 	IsSubscriber      bool
 256 | 	IsMutualFollowing bool
 257 | 	IsFollower        bool
 258 | 	IsModerator       bool
 259 | 	IsAnchor          bool
 260 | }
 261 | 
 262 | type ProfilePicture struct {
 263 | 	Urls []string
 264 | }
 265 | 
 266 | type ExtraAttributes struct {
 267 | 	FollowRole int
 268 | }
 269 | 
 270 | type BadgeAttributes struct {
 271 | 	Badges []*UserBadge
 272 | }
 273 | 
 274 | type UserBadge struct {
 275 | 	Type string
 276 | 	Name string
 277 | }
 278 | 
 279 | type roomInfoRsp struct {
 280 | 	RoomInfo *RoomInfo `json:"data"`
 281 | 	Extra    struct {
 282 | 		Now int64 `json:"now"`
 283 | 	} `json:"extra"`
 284 | 	StatusCode float64 `json:"status_code"`
 285 | }
 286 | 
 287 | type RoomInfo struct {
 288 | 	AnchorABMap              interface{}   `json:"AnchorABMap"`
 289 | 	AdminUserIds             []interface{} `json:"admin_user_ids"`
 290 | 	AnchorScheduledTimeText  string        `json:"anchor_scheduled_time_text"`
 291 | 	AnchorShareText          string        `json:"anchor_share_text"`
 292 | 	AnchorTabType            float64       `json:"anchor_tab_type"`
 293 | 	AnsweringQuestionContent string        `json:"answering_question_content"`
 294 | 	AppID                    float64       `json:"app_id"`
 295 | 	AutoCover                float64       `json:"auto_cover"`
 296 | 	BookEndTime              float64       `json:"book_end_time"`
 297 | 	BookTime                 float64       `json:"book_time"`
 298 | 	BusinessLive             float64       `json:"business_live"`
 299 | 	ChallengeInfo            string        `json:"challenge_info"`
 300 | 	ClientVersion            float64       `json:"client_version"`
 301 | 	CommentNameMode          float64       `json:"comment_name_mode"`
 302 | 	CommerceInfo             struct {
 303 | 		CommercePermission       float64 `json:"commerce_permission"`
 304 | 		OecLiveEnterRoomInitData string  `json:"oec_live_enter_room_init_data"`
 305 | 	} `json:"commerce_info"`
 306 | 	CommonLabelList string `json:"common_label_list"`
 307 | 	ContentTag      string `json:"content_tag"`
 308 | 	Cover           struct {
 309 | 		AvgColor   string   `json:"avg_color"`
 310 | 		Height     float64  `json:"height"`
 311 | 		ImageType  float64  `json:"image_type"`
 312 | 		IsAnimated bool     `json:"is_animated"`
 313 | 		OpenWebURL string   `json:"open_web_url"`
 314 | 		URI        string   `json:"uri"`
 315 | 		URLList    []string `json:"url_list"`
 316 | 		Width      float64  `json:"width"`
 317 | 	} `json:"cover"`
 318 | 	CreateTime           int64         `json:"create_time"`
 319 | 	DecoList             []interface{} `json:"deco_list"`
 320 | 	DisablePreloadStream bool          `json:"disable_preload_stream"`
 321 | 	FansclubMsgStyle     float64       `json:"fansclub_msg_style"`
 322 | 	FeedRoomLabel        struct {
 323 | 		AvgColor   string   `json:"avg_color"`
 324 | 		Height     float64  `json:"height"`
 325 | 		ImageType  float64  `json:"image_type"`
 326 | 		IsAnimated bool     `json:"is_animated"`
 327 | 		OpenWebURL string   `json:"open_web_url"`
 328 | 		URI        string   `json:"uri"`
 329 | 		URLList    []string `json:"url_list"`
 330 | 		Width      float64  `json:"width"`
 331 | 	} `json:"feed_room_label"`
 332 | 	FeedRoomLabels      []interface{} `json:"feed_room_labels"`
 333 | 	FilterMsgRules      []interface{} `json:"filter_msg_rules"`
 334 | 	FinishReason        float64       `json:"finish_reason"`
 335 | 	FinishTime          float64       `json:"finish_time"`
 336 | 	FinishURL           string        `json:"finish_url"`
 337 | 	FinishURLV2         string        `json:"finish_url_v2"`
 338 | 	FollowMsgStyle      float64       `json:"follow_msg_style"`
 339 | 	ForumExtraData      string        `json:"forum_extra_data"`
 340 | 	GameTag             []interface{} `json:"game_tag"`
 341 | 	GiftMsgStyle        float64       `json:"gift_msg_style"`
 342 | 	GiftPollVoteEnabled bool          `json:"gift_poll_vote_enabled"`
 343 | 	GroupSource         float64       `json:"group_source"`
 344 | 	HasCommerceGoods    bool          `json:"has_commerce_goods"`
 345 | 	Hashtag             struct {
 346 | 		ID    float64 `json:"id"`
 347 | 		Image struct {
 348 | 			AvgColor   string   `json:"avg_color"`
 349 | 			Height     float64  `json:"height"`
 350 | 			ImageType  float64  `json:"image_type"`
 351 | 			IsAnimated bool     `json:"is_animated"`
 352 | 			OpenWebURL string   `json:"open_web_url"`
 353 | 			URI        string   `json:"uri"`
 354 | 			URLList    []string `json:"url_list"`
 355 | 			Width      float64  `json:"width"`
 356 | 		} `json:"image"`
 357 | 		Namespace float64 `json:"namespace"`
 358 | 		Title     string  `json:"title"`
 359 | 	} `json:"hashtag"`
 360 | 	HaveWishlist               bool    `json:"have_wishlist"`
 361 | 	HotSentenceInfo            string  `json:"hot_sentence_info"`
 362 | 	ID                         int64   `json:"id"`
 363 | 	IDStr                      string  `json:"id_str"`
 364 | 	InteractionQuestionVersion float64 `json:"interaction_question_version"`
 365 | 	Introduction               string  `json:"introduction"`
 366 | 	IsGatedRoom                bool    `json:"is_gated_room"`
 367 | 	IsReplay                   bool    `json:"is_replay"`
 368 | 	IsShowUserCardSwitch       bool    `json:"is_show_user_card_switch"`
 369 | 	LastPingTime               float64 `json:"last_ping_time"`
 370 | 	Layout                     float64 `json:"layout"`
 371 | 	LikeCount                  float64 `json:"like_count"`
 372 | 	LinkMic                    struct {
 373 | 		AudienceIDList []interface{} `json:"audience_id_list"`
 374 | 		BattleScores   []interface{} `json:"battle_scores"`
 375 | 		BattleSettings struct {
 376 | 			BattleID    float64 `json:"battle_id"`
 377 | 			ChannelID   float64 `json:"channel_id"`
 378 | 			Duration    float64 `json:"duration"`
 379 | 			Finished    float64 `json:"finished"`
 380 | 			MatchType   float64 `json:"match_type"`
 381 | 			StartTime   float64 `json:"start_time"`
 382 | 			StartTimeMs float64 `json:"start_time_ms"`
 383 | 			Theme       string  `json:"theme"`
 384 | 		} `json:"battle_settings"`
 385 | 		ChannelID      float64       `json:"channel_id"`
 386 | 		FollowedCount  float64       `json:"followed_count"`
 387 | 		LinkedUserList []interface{} `json:"linked_user_list"`
 388 | 		MultiLiveEnum  float64       `json:"multi_live_enum"`
 389 | 		RivalAnchorID  float64       `json:"rival_anchor_id"`
 390 | 		ShowUserList   []interface{} `json:"show_user_list"`
 391 | 	} `json:"link_mic"`
 392 | 	LinkerMap struct {
 393 | 	} `json:"linker_map"`
 394 | 	LinkmicLayout      float64       `json:"linkmic_layout"`
 395 | 	LiveDistribution   []interface{} `json:"live_distribution"`
 396 | 	LiveID             float64       `json:"live_id"`
 397 | 	LiveReason         string        `json:"live_reason"`
 398 | 	LiveRoomMode       float64       `json:"live_room_mode"`
 399 | 	LiveTypeAudio      bool          `json:"live_type_audio"`
 400 | 	LiveTypeLinkmic    bool          `json:"live_type_linkmic"`
 401 | 	LiveTypeNormal     bool          `json:"live_type_normal"`
 402 | 	LiveTypeSandbox    bool          `json:"live_type_sandbox"`
 403 | 	LiveTypeScreenshot bool          `json:"live_type_screenshot"`
 404 | 	LiveTypeSocialLive bool          `json:"live_type_social_live"`
 405 | 	LiveTypeThirdParty bool          `json:"live_type_third_party"`
 406 | 	LivingRoomAttrs    struct {
 407 | 		AdminFlag   float64 `json:"admin_flag"`
 408 | 		Rank        float64 `json:"rank"`
 409 | 		RoomID      int64   `json:"room_id"`
 410 | 		RoomIDStr   string  `json:"room_id_str"`
 411 | 		SilenceFlag float64 `json:"silence_flag"`
 412 | 	} `json:"living_room_attrs"`
 413 | 	LotteryFinishTime    float64   `json:"lottery_finish_time"`
 414 | 	MosaicStatus         float64   `json:"mosaic_status"`
 415 | 	OsType               float64   `json:"os_type"`
 416 | 	Owner                *UserData `json:"owner"`
 417 | 	OwnerDeviceID        float64   `json:"owner_device_id"`
 418 | 	OwnerDeviceIDStr     string    `json:"owner_device_id_str"`
 419 | 	OwnerUserID          float64   `json:"owner_user_id"`
 420 | 	OwnerUserIDStr       string    `json:"owner_user_id_str"`
 421 | 	PreEnterTime         float64   `json:"pre_enter_time"`
 422 | 	PreviewFlowTag       float64   `json:"preview_flow_tag"`
 423 | 	RanklistAudienceType float64   `json:"ranklist_audience_type"`
 424 | 	RelationTag          string    `json:"relation_tag"`
 425 | 	Replay               bool      `json:"replay"`
 426 | 	RoomAuditStatus      float64   `json:"room_audit_status"`
 427 | 	RoomAuth             struct {
 428 | 		Banner              float64 `json:"Banner"`
 429 | 		BroadcastMessage    float64 `json:"BroadcastMessage"`
 430 | 		Chat                bool    `json:"Chat"`
 431 | 		ChatL2              bool    `json:"ChatL2"`
 432 | 		ChatSubOnly         bool    `json:"ChatSubOnly"`
 433 | 		Danmaku             bool    `json:"Danmaku"`
 434 | 		Digg                bool    `json:"Digg"`
 435 | 		DonationSticker     float64 `json:"DonationSticker"`
 436 | 		Gift                bool    `json:"Gift"`
 437 | 		GiftAnchorMt        float64 `json:"GiftAnchorMt"`
 438 | 		GiftPoll            float64 `json:"GiftPoll"`
 439 | 		GoldenEnvelope      float64 `json:"GoldenEnvelope"`
 440 | 		InteractionQuestion bool    `json:"InteractionQuestion"`
 441 | 		Landscape           float64 `json:"Landscape"`
 442 | 		LandscapeChat       float64 `json:"LandscapeChat"`
 443 | 		LuckMoney           bool    `json:"LuckMoney"`
 444 | 		Poll                float64 `json:"Poll"`
 445 | 		Promote             bool    `json:"Promote"`
 446 | 		Props               bool    `json:"Props"`
 447 | 		PublicScreen        float64 `json:"PublicScreen"`
 448 | 		QuickChat           float64 `json:"QuickChat"`
 449 | 		Rank                float64 `json:"Rank"`
 450 | 		RoomContributor     bool    `json:"RoomContributor"`
 451 | 		Share               bool    `json:"Share"`
 452 | 		ShareEffect         float64 `json:"ShareEffect"`
 453 | 		UserCard            bool    `json:"UserCard"`
 454 | 		UserCount           float64 `json:"UserCount"`
 455 | 		Viewers             bool    `json:"Viewers"`
 456 | 		TransactionHistory  float64 `json:"transaction_history"`
 457 | 	} `json:"room_auth"`
 458 | 	RoomCreateAbParam string        `json:"room_create_ab_param"`
 459 | 	RoomLayout        float64       `json:"room_layout"`
 460 | 	RoomStickerList   []interface{} `json:"room_sticker_list"`
 461 | 	RoomTabs          []interface{} `json:"room_tabs"`
 462 | 	RoomTag           float64       `json:"room_tag"`
 463 | 	ScrollConfig      string        `json:"scroll_config"`
 464 | 	SearchID          float64       `json:"search_id"`
 465 | 	ShareMsgStyle     float64       `json:"share_msg_style"`
 466 | 	ShareURL          string        `json:"share_url"`
 467 | 	ShortTitle        string        `json:"short_title"`
 468 | 	ShortTouchItems   []interface{} `json:"short_touch_items"`
 469 | 	SocialInteraction struct {
 470 | 		MultiLive struct {
 471 | 			UserSettings struct {
 472 | 				MultiLiveApplyPermission float64 `json:"multi_live_apply_permission"`
 473 | 			} `json:"user_settings"`
 474 | 		} `json:"multi_live"`
 475 | 	} `json:"social_interaction"`
 476 | 	StartTime float64 `json:"start_time"`
 477 | 	Stats     struct {
 478 | 		DiggCount            float64 `json:"digg_count"`
 479 | 		EnterCount           float64 `json:"enter_count"`
 480 | 		FanTicket            float64 `json:"fan_ticket"`
 481 | 		FollowCount          float64 `json:"follow_count"`
 482 | 		GiftUvCount          float64 `json:"gift_uv_count"`
 483 | 		ID                   int64   `json:"id"`
 484 | 		IDStr                string  `json:"id_str"`
 485 | 		LikeCount            float64 `json:"like_count"`
 486 | 		ReplayFanTicket      float64 `json:"replay_fan_ticket"`
 487 | 		ReplayViewers        float64 `json:"replay_viewers"`
 488 | 		ShareCount           float64 `json:"share_count"`
 489 | 		TotalUser            float64 `json:"total_user"`
 490 | 		TotalUserDesp        string  `json:"total_user_desp"`
 491 | 		UserCountComposition struct {
 492 | 			MyFollow    float64 `json:"my_follow"`
 493 | 			Other       float64 `json:"other"`
 494 | 			VideoDetail float64 `json:"video_detail"`
 495 | 		} `json:"user_count_composition"`
 496 | 		Watermelon float64 `json:"watermelon"`
 497 | 	} `json:"stats"`
 498 | 	Status      float64       `json:"status"`
 499 | 	StickerList []interface{} `json:"sticker_list"`
 500 | 	StreamID    int64         `json:"stream_id"`
 501 | 	StreamIDStr string        `json:"stream_id_str"`
 502 | 	StreamURL   struct {
 503 | 		CandidateResolution []string      `json:"candidate_resolution"`
 504 | 		CompletePushUrls    []interface{} `json:"complete_push_urls"`
 505 | 		DefaultResolution   string        `json:"default_resolution"`
 506 | 		Extra               struct {
 507 | 			AnchorInteractProfile   float64 `json:"anchor_interact_profile"`
 508 | 			AudienceInteractProfile float64 `json:"audience_interact_profile"`
 509 | 			BframeEnable            bool    `json:"bframe_enable"`
 510 | 			BitrateAdaptStrategy    float64 `json:"bitrate_adapt_strategy"`
 511 | 			Bytevc1Enable           bool    `json:"bytevc1_enable"`
 512 | 			DefaultBitrate          float64 `json:"default_bitrate"`
 513 | 			Fps                     float64 `json:"fps"`
 514 | 			GopSec                  float64 `json:"gop_sec"`
 515 | 			HardwareEncode          bool    `json:"hardware_encode"`
 516 | 			Height                  float64 `json:"height"`
 517 | 			MaxBitrate              float64 `json:"max_bitrate"`
 518 | 			MinBitrate              float64 `json:"min_bitrate"`
 519 | 			Roi                     bool    `json:"roi"`
 520 | 			SwRoi                   bool    `json:"sw_roi"`
 521 | 			VideoProfile            float64 `json:"video_profile"`
 522 | 			Width                   float64 `json:"width"`
 523 | 		} `json:"extra"`
 524 | 		FlvPullURL struct {
 525 | 			FullHd1 string `json:"FULL_HD1"`
 526 | 			Hd1     string `json:"HD1"`
 527 | 			Sd1     string `json:"SD1"`
 528 | 			Sd2     string `json:"SD2"`
 529 | 		} `json:"flv_pull_url"`
 530 | 		FlvPullURLParams struct {
 531 | 			FullHd1 string `json:"FULL_HD1"`
 532 | 			Hd1     string `json:"HD1"`
 533 | 			Sd1     string `json:"SD1"`
 534 | 			Sd2     string `json:"SD2"`
 535 | 		} `json:"flv_pull_url_params"`
 536 | 		HlsPullURL    string `json:"hls_pull_url"`
 537 | 		HlsPullURLMap struct {
 538 | 		} `json:"hls_pull_url_map"`
 539 | 		HlsPullURLParams string `json:"hls_pull_url_params"`
 540 | 		ID               int64  `json:"id"`
 541 | 		IDStr            string `json:"id_str"`
 542 | 		LiveCoreSdkData  struct {
 543 | 			PullData struct {
 544 | 				Options struct {
 545 | 					DefaultQuality struct {
 546 | 						Level      float64 `json:"level"`
 547 | 						Name       string  `json:"name"`
 548 | 						Resolution string  `json:"resolution"`
 549 | 						SdkKey     string  `json:"sdk_key"`
 550 | 						VCodec     string  `json:"v_codec"`
 551 | 					} `json:"default_quality"`
 552 | 					Qualities []struct {
 553 | 						Level      float64 `json:"level"`
 554 | 						Name       string  `json:"name"`
 555 | 						Resolution string  `json:"resolution"`
 556 | 						SdkKey     string  `json:"sdk_key"`
 557 | 						VCodec     string  `json:"v_codec"`
 558 | 					} `json:"qualities"`
 559 | 				} `json:"options"`
 560 | 				StreamData string `json:"stream_data"`
 561 | 			} `json:"pull_data"`
 562 | 		} `json:"live_core_sdk_data"`
 563 | 		Provider       float64       `json:"provider"`
 564 | 		PushUrls       []interface{} `json:"push_urls"`
 565 | 		ResolutionName struct {
 566 | 			Auto    string `json:"AUTO"`
 567 | 			FullHd1 string `json:"FULL_HD1"`
 568 | 			Hd1     string `json:"HD1"`
 569 | 			Origion string `json:"ORIGION"`
 570 | 			Sd1     string `json:"SD1"`
 571 | 			Sd2     string `json:"SD2"`
 572 | 		} `json:"resolution_name"`
 573 | 		RtmpPullURL       string  `json:"rtmp_pull_url"`
 574 | 		RtmpPullURLParams string  `json:"rtmp_pull_url_params"`
 575 | 		RtmpPushURL       string  `json:"rtmp_push_url"`
 576 | 		RtmpPushURLParams string  `json:"rtmp_push_url_params"`
 577 | 		StreamControlType float64 `json:"stream_control_type"`
 578 | 	} `json:"stream_url"`
 579 | 	StreamURLFilteredInfo struct {
 580 | 		IsGatedRoom bool `json:"is_gated_room"`
 581 | 		IsPaidEvent bool `json:"is_paid_event"`
 582 | 	} `json:"stream_url_filtered_info"`
 583 | 	Title             string    `json:"title"`
 584 | 	TopFans           []*TopFan `json:"top_fans"`
 585 | 	UseFilter         bool      `json:"use_filter"`
 586 | 	UserCount         int       `json:"user_count"` // Viewers
 587 | 	UserShareText     string    `json:"user_share_text"`
 588 | 	VideoFeedTag      string    `json:"video_feed_tag"`
 589 | 	WebcastCommentTcs float64   `json:"webcast_comment_tcs"`
 590 | 	WebcastSdkVersion float64   `json:"webcast_sdk_version"`
 591 | 	WithDrawSomething bool      `json:"with_draw_something"`
 592 | 	WithKtv           bool      `json:"with_ktv"`
 593 | 	WithLinkmic       bool      `json:"with_linkmic"`
 594 | }
 595 | 
 596 | type giftInfoRsp struct {
 597 | 	GiftInfo *GiftInfo `json:"data"`
 598 | 	Extra    struct {
 599 | 		LogID string `json:"log_id"`
 600 | 		Now   int64  `json:"now"`
 601 | 	} `json:"extra"`
 602 | 	StatusCode int `json:"status_code"`
 603 | }
 604 | 
 605 | type GiftInfo struct {
 606 | 	DoodleTemplates []interface{} `json:"doodle_templates"`
 607 | 	Gifts           []struct {
 608 | 		ActionType            int           `json:"action_type"`
 609 | 		AppID                 int           `json:"app_id"`
 610 | 		BusinessText          string        `json:"business_text"`
 611 | 		ColorInfos            []interface{} `json:"color_infos"`
 612 | 		Combo                 bool          `json:"combo"`
 613 | 		Describe              string        `json:"describe"`
 614 | 		DiamondCount          int           `json:"diamond_count"`
 615 | 		Duration              int           `json:"duration"`
 616 | 		EventName             string        `json:"event_name"`
 617 | 		ForCustom             bool          `json:"for_custom"`
 618 | 		ForLinkmic            bool          `json:"for_linkmic"`
 619 | 		GiftRankRecommendInfo string        `json:"gift_rank_recommend_info"`
 620 | 		GiftScene             int           `json:"gift_scene"`
 621 | 		GoldEffect            string        `json:"gold_effect"`
 622 | 		GraySchemeURL         string        `json:"gray_scheme_url"`
 623 | 		GuideURL              string        `json:"guide_url"`
 624 | 		Icon                  struct {
 625 | 			AvgColor   string   `json:"avg_color"`
 626 | 			Height     int      `json:"height"`
 627 | 			ImageType  int      `json:"image_type"`
 628 | 			IsAnimated bool     `json:"is_animated"`
 629 | 			OpenWebURL string   `json:"open_web_url"`
 630 | 			URI        string   `json:"uri"`
 631 | 			URLList    []string `json:"url_list"`
 632 | 			Width      int      `json:"width"`
 633 | 		} `json:"icon"`
 634 | 		ID    int `json:"id"`
 635 | 		Image struct {
 636 | 			AvgColor   string   `json:"avg_color"`
 637 | 			Height     int      `json:"height"`
 638 | 			ImageType  int      `json:"image_type"`
 639 | 			IsAnimated bool     `json:"is_animated"`
 640 | 			OpenWebURL string   `json:"open_web_url"`
 641 | 			URI        string   `json:"uri"`
 642 | 			URLList    []string `json:"url_list"`
 643 | 			Width      int      `json:"width"`
 644 | 		} `json:"image"`
 645 | 		IsBroadcastGift    bool `json:"is_broadcast_gift"`
 646 | 		IsDisplayedOnPanel bool `json:"is_displayed_on_panel"`
 647 | 		IsEffectBefview    bool `json:"is_effect_befview"`
 648 | 		IsGray             bool `json:"is_gray"`
 649 | 		IsRandomGift       bool `json:"is_random_gift"`
 650 | 		ItemType           int  `json:"item_type"`
 651 | 		LockInfo           struct {
 652 | 			Lock     bool `json:"lock"`
 653 | 			LockType int  `json:"lock_type"`
 654 | 		} `json:"lock_info"`
 655 | 		Manual          string `json:"manual"`
 656 | 		Name            string `json:"name"`
 657 | 		Notify          bool   `json:"notify"`
 658 | 		PrimaryEffectID int    `json:"primary_effect_id"`
 659 | 		Region          string `json:"region"`
 660 | 		SchemeURL       string `json:"scheme_url"`
 661 | 		SpecialEffects  struct {
 662 | 		} `json:"special_effects"`
 663 | 		TriggerWords  []interface{} `json:"trigger_words"`
 664 | 		Type          int           `json:"type"`
 665 | 		GiftLabelIcon struct {
 666 | 			AvgColor   string   `json:"avg_color"`
 667 | 			Height     int      `json:"height"`
 668 | 			ImageType  int      `json:"image_type"`
 669 | 			IsAnimated bool     `json:"is_animated"`
 670 | 			OpenWebURL string   `json:"open_web_url"`
 671 | 			URI        string   `json:"uri"`
 672 | 			URLList    []string `json:"url_list"`
 673 | 			Width      int      `json:"width"`
 674 | 		} `json:"gift_label_icon,omitempty"`
 675 | 		PreviewImage struct {
 676 | 			AvgColor   string   `json:"avg_color"`
 677 | 			Height     int      `json:"height"`
 678 | 			ImageType  int      `json:"image_type"`
 679 | 			IsAnimated bool     `json:"is_animated"`
 680 | 			OpenWebURL string   `json:"open_web_url"`
 681 | 			URI        string   `json:"uri"`
 682 | 			URLList    []string `json:"url_list"`
 683 | 			Width      int      `json:"width"`
 684 | 		} `json:"preview_image,omitempty"`
 685 | 		TrackerParams struct {
 686 | 			GiftProperty string `json:"gift_property"`
 687 | 		} `json:"tracker_params,omitempty"`
 688 | 		GiftPanelBanner struct {
 689 | 			BgColorValues []interface{} `json:"bg_color_values"`
 690 | 			DisplayText   struct {
 691 | 				DefaultFormat struct {
 692 | 					Bold               bool   `json:"bold"`
 693 | 					Color              string `json:"color"`
 694 | 					FontSize           int    `json:"font_size"`
 695 | 					Italic             bool   `json:"italic"`
 696 | 					ItalicAngle        int    `json:"italic_angle"`
 697 | 					UseHeighLightColor bool   `json:"use_heigh_light_color"`
 698 | 					UseRemoteClor      bool   `json:"use_remote_clor"`
 699 | 					Weight             int    `json:"weight"`
 700 | 				} `json:"default_format"`
 701 | 				DefaultPattern string        `json:"default_pattern"`
 702 | 				Key            string        `json:"key"`
 703 | 				Pieces         []interface{} `json:"pieces"`
 704 | 			} `json:"display_text"`
 705 | 			LeftIcon struct {
 706 | 				AvgColor   string   `json:"avg_color"`
 707 | 				Height     int      `json:"height"`
 708 | 				ImageType  int      `json:"image_type"`
 709 | 				IsAnimated bool     `json:"is_animated"`
 710 | 				OpenWebURL string   `json:"open_web_url"`
 711 | 				URI        string   `json:"uri"`
 712 | 				URLList    []string `json:"url_list"`
 713 | 				Width      int      `json:"width"`
 714 | 			} `json:"left_icon"`
 715 | 			SchemaURL string `json:"schema_url"`
 716 | 		} `json:"gift_panel_banner,omitempty"`
 717 | 	} `json:"gifts"`
 718 | 	GiftsInfo struct {
 719 | 		ColorGiftIconAnimation struct {
 720 | 			AvgColor   string   `json:"avg_color"`
 721 | 			Height     int      `json:"height"`
 722 | 			ImageType  int      `json:"image_type"`
 723 | 			IsAnimated bool     `json:"is_animated"`
 724 | 			OpenWebURL string   `json:"open_web_url"`
 725 | 			URI        string   `json:"uri"`
 726 | 			URLList    []string `json:"url_list"`
 727 | 			Width      int      `json:"width"`
 728 | 		} `json:"color_gift_icon_animation"`
 729 | 		DefaultLocColorGiftID            int  `json:"default_loc_color_gift_id"`
 730 | 		EnableFirstRechargeDynamicEffect bool `json:"enable_first_recharge_dynamic_effect"`
 731 | 		FirstRechargeGiftInfo            struct {
 732 | 			ExpireAt             int `json:"expire_at"`
 733 | 			GiftID               int `json:"gift_id"`
 734 | 			OriginalDiamondCount int `json:"original_diamond_count"`
 735 | 		} `json:"first_recharge_gift_info"`
 736 | 		GiftComboInfos []interface{} `json:"gift_combo_infos"`
 737 | 		GiftGroupInfos []struct {
 738 | 			GroupCount int    `json:"group_count"`
 739 | 			GroupText  string `json:"group_text"`
 740 | 		} `json:"gift_group_infos"`
 741 | 		GiftIconInfo struct {
 742 | 			EffectURI string `json:"effect_uri"`
 743 | 			Icon      struct {
 744 | 				AvgColor   string        `json:"avg_color"`
 745 | 				Height     int           `json:"height"`
 746 | 				ImageType  int           `json:"image_type"`
 747 | 				IsAnimated bool          `json:"is_animated"`
 748 | 				OpenWebURL string        `json:"open_web_url"`
 749 | 				URI        string        `json:"uri"`
 750 | 				URLList    []interface{} `json:"url_list"`
 751 | 				Width      int           `json:"width"`
 752 | 			} `json:"icon"`
 753 | 			IconID       int    `json:"icon_id"`
 754 | 			IconURI      string `json:"icon_uri"`
 755 | 			Name         string `json:"name"`
 756 | 			ValidEndAt   int    `json:"valid_end_at"`
 757 | 			ValidStartAt int    `json:"valid_start_at"`
 758 | 			WithEffect   bool   `json:"with_effect"`
 759 | 		} `json:"gift_icon_info"`
 760 | 		GiftPollInfo struct {
 761 | 			GiftPollOptions []struct {
 762 | 				GiftID         int `json:"gift_id"`
 763 | 				PollResultIcon struct {
 764 | 					AvgColor   string   `json:"avg_color"`
 765 | 					Height     int      `json:"height"`
 766 | 					ImageType  int      `json:"image_type"`
 767 | 					IsAnimated bool     `json:"is_animated"`
 768 | 					OpenWebURL string   `json:"open_web_url"`
 769 | 					URI        string   `json:"uri"`
 770 | 					URLList    []string `json:"url_list"`
 771 | 					Width      int      `json:"width"`
 772 | 				} `json:"poll_result_icon"`
 773 | 			} `json:"gift_poll_options"`
 774 | 		} `json:"gift_poll_info"`
 775 | 		GiftWords                 string `json:"gift_words"`
 776 | 		HideRechargeEntry         bool   `json:"hide_recharge_entry"`
 777 | 		NewGiftID                 int    `json:"new_gift_id"`
 778 | 		RecentlySentColorGiftID   int    `json:"recently_sent_color_gift_id"`
 779 | 		RecommendedRandomGiftID   int    `json:"recommended_random_gift_id"`
 780 | 		ShowFirstRechargeEntrance bool   `json:"show_first_recharge_entrance"`
 781 | 		SpeedyGiftID              int    `json:"speedy_gift_id"`
 782 | 	} `json:"gifts_info"`
 783 | 	Pages []interface{} `json:"pages"`
 784 | }
 785 | 
 786 | type TopFan struct {
 787 | 	FanTicket float64   `json:"fan_ticket"`
 788 | 	User      *UserData `json:"user"`
 789 | }
 790 | 
 791 | type FeedItem struct {
 792 | 	LiveStreams []*LiveStream `json:"data"`
 793 | 	Extra       struct {
 794 | 		Banner struct {
 795 | 			Banners     []interface{} `json:"banners"`
 796 | 			BannersType int           `json:"banners_type"`
 797 | 			SwitchType  int           `json:"switch_type"`
 798 | 			Title       string        `json:"title"`
 799 | 			Total       int           `json:"total"`
 800 | 		} `json:"banner"`
 801 | 		Cost        int    `json:"cost"`
 802 | 		HasMore     bool   `json:"has_more"`
 803 | 		HashtagText string `json:"hashtag_text"`
 804 | 		IsBackup    int    `json:"is_backup"`
 805 | 		LogPb       struct {
 806 | 			ImprID    string `json:"impr_id"`
 807 | 			SessionID int    `json:"session_id"`
 808 | 		} `json:"log_pb"`
 809 | 		MaxTime     int64  `json:"max_time"`
 810 | 		MinTime     int    `json:"min_time"`
 811 | 		Now         int64  `json:"now"`
 812 | 		Style       int    `json:"style"`
 813 | 		Total       int    `json:"total"`
 814 | 		UnreadExtra string `json:"unread_extra"`
 815 | 	} `json:"extra"`
 816 | 	StatusCode int `json:"status_code"`
 817 | }
 818 | 
 819 | type LiveStream struct {
 820 | 	t *TikTok
 821 | 
 822 | 	Room      *RoomInfo `json:"data"`
 823 | 	DebugInfo string    `json:"debug_info"`
 824 | 	FlareInfo struct {
 825 | 		IsFlare bool   `json:"is_flare"`
 826 | 		TaskID  string `json:"task_id"`
 827 | 	} `json:"flare_info"`
 828 | 	IsPseudoLiving  bool   `json:"is_pseudo_living"`
 829 | 	IsRecommendCard bool   `json:"is_recommend_card"`
 830 | 	LiveReason      string `json:"live_reason"`
 831 | 	Rid             string `json:"rid"`
 832 | 	Type            int    `json:"type"`
 833 | }
 834 | 
 835 | type UserData struct {
 836 | 	AllowFindByContacts                 bool `json:"allow_find_by_contacts"`
 837 | 	AllowOthersDownloadVideo            bool `json:"allow_others_download_video"`
 838 | 	AllowOthersDownloadWhenSharingVideo bool `json:"allow_others_download_when_sharing_video"`
 839 | 	AllowShareShowProfile               bool `json:"allow_share_show_profile"`
 840 | 	AllowShowInGossip                   bool `json:"allow_show_in_gossip"`
 841 | 	AllowShowMyAction                   bool `json:"allow_show_my_action"`
 842 | 	AllowStrangeComment                 bool `json:"allow_strange_comment"`
 843 | 	AllowUnfollowerComment              bool `json:"allow_unfollower_comment"`
 844 | 	AllowUseLinkmic                     bool `json:"allow_use_linkmic"`
 845 | 	AvatarLarge                         struct {
 846 | 		AvgColor   string   `json:"avg_color"`
 847 | 		Height     int      `json:"height"`
 848 | 		ImageType  int      `json:"image_type"`
 849 | 		IsAnimated bool     `json:"is_animated"`
 850 | 		OpenWebURL string   `json:"open_web_url"`
 851 | 		URI        string   `json:"uri"`
 852 | 		URLList    []string `json:"url_list"`
 853 | 		Width      int      `json:"width"`
 854 | 	} `json:"avatar_large"`
 855 | 	AvatarMedium struct {
 856 | 		AvgColor   string   `json:"avg_color"`
 857 | 		Height     int      `json:"height"`
 858 | 		ImageType  int      `json:"image_type"`
 859 | 		IsAnimated bool     `json:"is_animated"`
 860 | 		OpenWebURL string   `json:"open_web_url"`
 861 | 		URI        string   `json:"uri"`
 862 | 		URLList    []string `json:"url_list"`
 863 | 		Width      int      `json:"width"`
 864 | 	} `json:"avatar_medium"`
 865 | 	AvatarThumb struct {
 866 | 		AvgColor   string   `json:"avg_color"`
 867 | 		Height     int      `json:"height"`
 868 | 		ImageType  int      `json:"image_type"`
 869 | 		IsAnimated bool     `json:"is_animated"`
 870 | 		OpenWebURL string   `json:"open_web_url"`
 871 | 		URI        string   `json:"uri"`
 872 | 		URLList    []string `json:"url_list"`
 873 | 		Width      int      `json:"width"`
 874 | 	} `json:"avatar_thumb"`
 875 | 	BadgeImageList           []interface{} `json:"badge_image_list"`
 876 | 	BadgeList                []interface{} `json:"badge_list"`
 877 | 	BgImgURL                 string        `json:"bg_img_url"`
 878 | 	BioDescription           string        `json:"bio_description"`
 879 | 	BlockStatus              int           `json:"block_status"`
 880 | 	BorderList               []interface{} `json:"border_list"`
 881 | 	CommentRestrict          int           `json:"comment_restrict"`
 882 | 	CommerceWebcastConfigIds []interface{} `json:"commerce_webcast_config_ids"`
 883 | 	Constellation            string        `json:"constellation"`
 884 | 	CreateTime               int           `json:"create_time"`
 885 | 	DisableIchat             int           `json:"disable_ichat"`
 886 | 	Username                 string        `json:"display_id"`
 887 | 	EnableIchatImg           int           `json:"enable_ichat_img"`
 888 | 	Exp                      int           `json:"exp"`
 889 | 	FanTicketCount           int           `json:"fan_ticket_count"`
 890 | 	FoldStrangerChat         bool          `json:"fold_stranger_chat"`
 891 | 	FollowInfo               struct {
 892 | 		FollowStatus   int `json:"follow_status"`
 893 | 		FollowerCount  int `json:"follower_count"`
 894 | 		FollowingCount int `json:"following_count"`
 895 | 		PushStatus     int `json:"push_status"`
 896 | 	} `json:"follow_info"`
 897 | 	FollowStatus        int           `json:"follow_status"`
 898 | 	IchatRestrictType   int           `json:"ichat_restrict_type"`
 899 | 	ID                  int64         `json:"id"`
 900 | 	IDStr               string        `json:"id_str"`
 901 | 	IsFollower          bool          `json:"is_follower"`
 902 | 	IsFollowing         bool          `json:"is_following"`
 903 | 	LinkMicStats        int           `json:"link_mic_stats"`
 904 | 	MediaBadgeImageList []interface{} `json:"media_badge_image_list"`
 905 | 	ModifyTime          int           `json:"modify_time"`
 906 | 	NeedProfileGuide    bool          `json:"need_profile_guide"`
 907 | 	NewRealTimeIcons    []interface{} `json:"new_real_time_icons"`
 908 | 	Nickname            string        `json:"nickname"`
 909 | 	OwnRoom             struct {
 910 | 		RoomIds    []int64  `json:"room_ids"`
 911 | 		RoomIdsStr []string `json:"room_ids_str"`
 912 | 	} `json:"own_room"`
 913 | 	PayGrade struct {
 914 | 		GradeBanner        string        `json:"grade_banner"`
 915 | 		GradeDescribe      string        `json:"grade_describe"`
 916 | 		GradeIconList      []interface{} `json:"grade_icon_list"`
 917 | 		Level              int           `json:"level"`
 918 | 		Name               string        `json:"name"`
 919 | 		NextName           string        `json:"next_name"`
 920 | 		NextPrivileges     string        `json:"next_privileges"`
 921 | 		Score              int           `json:"score"`
 922 | 		ScreenChatType     int           `json:"screen_chat_type"`
 923 | 		UpgradeNeedConsume int           `json:"upgrade_need_consume"`
 924 | 	} `json:"pay_grade"`
 925 | 	PayScore           int           `json:"pay_score"`
 926 | 	PayScores          int           `json:"pay_scores"`
 927 | 	PushCommentStatus  bool          `json:"push_comment_status"`
 928 | 	PushDigg           bool          `json:"push_digg"`
 929 | 	PushFollow         bool          `json:"push_follow"`
 930 | 	PushFriendAction   bool          `json:"push_friend_action"`
 931 | 	PushIchat          bool          `json:"push_ichat"`
 932 | 	PushStatus         bool          `json:"push_status"`
 933 | 	PushVideoPost      bool          `json:"push_video_post"`
 934 | 	PushVideoRecommend bool          `json:"push_video_recommend"`
 935 | 	RealTimeIcons      []interface{} `json:"real_time_icons"`
 936 | 	SecUID             string        `json:"sec_uid"`
 937 | 	Secret             int           `json:"secret"`
 938 | 	ShareQrcodeURI     string        `json:"share_qrcode_uri"`
 939 | 	SpecialID          string        `json:"special_id"`
 940 | 	Status             int           `json:"status"`
 941 | 	TicketCount        int           `json:"ticket_count"`
 942 | 	TopFans            []interface{} `json:"top_fans"`
 943 | 	TopVipNo           int           `json:"top_vip_no"`
 944 | 	UserAttr           struct {
 945 | 		IsAdmin      bool `json:"is_admin"`
 946 | 		IsMuted      bool `json:"is_muted"`
 947 | 		IsSuperAdmin bool `json:"is_super_admin"`
 948 | 		MuteDuration int  `json:"mute_duration"`
 949 | 	} `json:"user_attr"`
 950 | 	UserRole                    int    `json:"user_role"`
 951 | 	Verified                    bool   `json:"verified"`
 952 | 	VerifiedContent             string `json:"verified_content"`
 953 | 	VerifiedReason              string `json:"verified_reason"`
 954 | 	WithCarManagementPermission bool   `json:"with_car_management_permission"`
 955 | 	WithCommercePermission      bool   `json:"with_commerce_permission"`
 956 | 	WithFusionShopEntry         bool   `json:"with_fusion_shop_entry"`
 957 | }
 958 | 
 959 | type rankListRsp struct {
 960 | 	RankList RankList `json:"data"`
 961 | 	Extra    struct {
 962 | 		Now int64 `json:"now"`
 963 | 	} `json:"extra"`
 964 | 	StatusCode int `json:"status_code"`
 965 | }
 966 | 
 967 | type RankList struct {
 968 | 	AnchorShowContribution bool        `json:"anchor_show_contribution"`
 969 | 	Anonymous              int         `json:"anonymous"`
 970 | 	Currency               string      `json:"currency"`
 971 | 	Ranks                  []*RankUser `json:"ranks"`
 972 | 	RuleURL                string      `json:"rule_url"`
 973 | 	Total                  int         `json:"total"`
 974 | }
 975 | 
 976 | type RankUser struct {
 977 | 	GapDescription       string    `json:"gap_description"`
 978 | 	Rank                 int       `json:"rank"`  // Absolute Rank
 979 | 	Score                int       `json:"score"` // Coins Count
 980 | 	User                 *UserData `json:"user"`
 981 | 	UserRestrictionLevel int       `json:"user_restriction_level"`
 982 | }
 983 | 
 984 | type PriceList struct {
 985 | 	PriceList []*PriceItem `json:"data"`
 986 | 	Extra     struct {
 987 | 		ApplePayHintURL                    string        `json:"apple_pay_hint_url"`
 988 | 		BadgeIcon                          string        `json:"badge_icon"`
 989 | 		Channel                            string        `json:"channel"`
 990 | 		ChannelID                          int           `json:"channel_id"`
 991 | 		CurrencyList                       []string      `json:"currency_list"`
 992 | 		CustomizedIds                      []int         `json:"customized_ids"`
 993 | 		DefaultCurrency                    string        `json:"default_currency"`
 994 | 		DefaultPacketID                    int           `json:"default_packet_id"`
 995 | 		ExtraDiamondList                   []interface{} `json:"extra_diamond_list"`
 996 | 		FirstChargePacketID                int           `json:"first_charge_packet_id"`
 997 | 		IsDefault                          bool          `json:"is_default"`
 998 | 		IsRecommend                        bool          `json:"is_recommend"`
 999 | 		LargePayURL                        string        `json:"large_pay_url"`
1000 | 		MaxCustomizedDiamondCnt            int           `json:"max_customized_diamond_cnt"`
1001 | 		MerchantID                         string        `json:"merchant_id"`
1002 | 		MinCustomizedDiamondCnt            int           `json:"min_customized_diamond_cnt"`
1003 | 		NeedAuth                           int           `json:"need_auth"`
1004 | 		Now                                int64         `json:"now"`
1005 | 		PloyTraceID                        int           `json:"ploy_trace_id"`
1006 | 		RecentlyPurchasedPacketID          int           `json:"recently_purchased_packet_id"`
1007 | 		RecommendedPacketID                int           `json:"recommended_packet_id"`
1008 | 		ShouldDisplayCustomizedWebRecharge bool          `json:"should_display_customized_web_recharge"`
1009 | 		ShowHint                           int           `json:"show_hint"`
1010 | 		SignInfos                          []interface{} `json:"sign_infos"`
1011 | 		TotalSigned                        int           `json:"total_signed"`
1012 | 	} `json:"extra"`
1013 | 	StatusCode int `json:"status_code"`
1014 | }
1015 | 
1016 | type PriceItem struct {
1017 | 	CouponID      string `json:"coupon_id"`
1018 | 	CurrencyPrice []struct {
1019 | 		Currency      string `json:"currency"`
1020 | 		KeepDot       int    `json:"keep_dot"`
1021 | 		OriginalPrice int    `json:"original_price"`
1022 | 		Price         int    `json:"price"` // Local Currency Price Cents
1023 | 		PriceDot      int    `json:"price_dot"`
1024 | 		PriceShowForm string `json:"price_show_form"`
1025 | 	} `json:"currency_price"`
1026 | 	Describe      string `json:"describe"`
1027 | 	DiamondCount  int    `json:"diamond_count"` // Coin Count
1028 | 	DiscountPrice int    `json:"discount_price"`
1029 | 	ExchangePrice int    `json:"exchange_price"` // Local Currency Price Cents
1030 | 	GivingCount   int    `json:"giving_count"`
1031 | 	IapID         string `json:"iap_id"`
1032 | 	ID            int    `json:"id"`
1033 | 	Price         int    `json:"price"` // USD Cents
1034 | }
1035 | 
1036 | type UserInfo struct {
1037 | 	ID           string `json:"id"`
1038 | 	ShortID      string `json:"shortId"`
1039 | 	UniqueID     string `json:"uniqueId"`
1040 | 	Nickname     string `json:"nickname"`
1041 | 	AvatarLarger string `json:"avatarLarger"`
1042 | 	AvatarMedium string `json:"avatarMedium"`
1043 | 	AvatarThumb  string `json:"avatarThumb"`
1044 | 	Biography    string `json:"signature"`
1045 | 	CreateTime   int    `json:"createTime"`
1046 | 	Verified     bool   `json:"verified"`
1047 | 	SecUID       string `json:"secUid"`
1048 | 	Ftc          bool   `json:"ftc"`
1049 | 	Relation     int    `json:"relation"`
1050 | 	OpenFavorite bool   `json:"openFavorite"`
1051 | 	BioLink      struct {
1052 | 		Link string `json:"link"`
1053 | 		Risk int    `json:"risk"`
1054 | 	} `json:"bioLink"`
1055 | 	CommentSetting int    `json:"commentSetting"`
1056 | 	DuetSetting    int    `json:"duetSetting"`
1057 | 	StitchSetting  int    `json:"stitchSetting"`
1058 | 	PrivateAccount bool   `json:"privateAccount"`
1059 | 	Secret         bool   `json:"secret"`
1060 | 	IsADVirtual    bool   `json:"isADVirtual"`
1061 | 	RoomID         string `json:"roomId"`
1062 | 
1063 | 	Stats UserStats
1064 | }
1065 | 
1066 | type UserStats struct {
1067 | 	FollowerCount  int  `json:"followerCount"`
1068 | 	FollowingCount int  `json:"followingCount"`
1069 | 	Heart          int  `json:"heart"`
1070 | 	HeartCount     int  `json:"heartCount"`
1071 | 	VideoCount     int  `json:"videoCount"`
1072 | 	DiggCount      int  `json:"diggCount"`
1073 | 	NeedFix        bool `json:"needFix"`
1074 | }
1075 | 
1076 | type SignedURL struct {
1077 | 	SignedURL      string `json:"signedUrl"`
1078 | 	MsToken        string `json:"msToken"`
1079 | 	Signature      string `json:"_signature"`
1080 | 	XBogus         string `json:"X-Bogus"`
1081 | 	UserAgent      string `json:"User-Agent"`
1082 | 	BrowserVersion string `json:"browserVersion"`
1083 | 	BrowserName    string `json:"browserName"`
1084 | 	Error          string `json:"error"`
1085 | }
1086 | 
1087 | // DisconnectEvent sent went disconnected from live. When this event occurs no other events will be emitted and the live
1088 | // instance should be closed with `Closed`. A new track user/room should be invoked to reconnect if desired. This event
1089 | // should always be emitted.
1090 | type DisconnectEvent struct {
1091 | 	created time.Time
1092 | }
1093 | 
1094 | func (d DisconnectEvent) IsHistory() bool {
1095 | 	return false
1096 | }
1097 | 
1098 | func (d DisconnectEvent) CreatedTimestamp() int64 {
1099 | 	return d.created.Unix()
1100 | }
1101 | 
1102 | type LimitInfo struct {
1103 | 	Max       int       `json:"max"`
1104 | 	Remaining int       `json:"remaining"`
1105 | 	ResetAt   time.Time `json:"reset_at"`
1106 | }
1107 | 
1108 | // SigningLimits are the rates and result from the configured signer.
1109 | type SigningLimits struct {
1110 | 	Code    int
1111 | 	Message string
1112 | 	Day     LimitInfo
1113 | 	Hour    LimitInfo
1114 | 	Minute  LimitInfo
1115 | }
1116 | 
1117 | type liveRoomContainer struct {
1118 | 	LiveRoomUserInfo *LiveRoomUserInfo `json:"liveRoomUserInfo,omitempty"`
1119 | }
1120 | 
1121 | type LiveRoomUserInfo struct {
1122 | 	LiveRoomUser *LiveRoomUser `json:"user,omitempty"`
1123 | 	Stats        Stats         `json:"stats"`
1124 | 	LiveRoom     *LiveRoom     `json:"liveRoom,omitempty"`
1125 | }
1126 | 
1127 | type LiveRoomUser struct {
1128 | 	AvatarLarger string `json:"avatarLarger"`
1129 | 	AvatarMedium string `json:"avatarMedium"`
1130 | 	AvatarThumb  string `json:"avatarThumb"`
1131 | 	ID           string `json:"id"`
1132 | 	Nickname     string `json:"nickname"`
1133 | 	SecUID       string `json:"secUid"`
1134 | 	Secret       bool   `json:"secret"`
1135 | 	UniqueID     string `json:"uniqueId"`
1136 | 	Verified     bool   `json:"verified"`
1137 | 	RoomID       string `json:"roomId"`
1138 | 	Signature    string `json:"signature"`
1139 | 	Status       int    `json:"status"`
1140 | 	FollowStatus int    `json:"followStatus"`
1141 | }
1142 | 
1143 | type Stats struct {
1144 | 	FollowingCount int `json:"followingCount"`
1145 | 	FollowerCount  int `json:"followerCount"`
1146 | }
1147 | 
1148 | type LiveRoom struct {
1149 | 	CoverURL          string        `json:"coverUrl"`
1150 | 	SquareCoverImg    string        `json:"squareCoverImg"`
1151 | 	Title             string        `json:"title"`
1152 | 	StartTime         int64         `json:"startTime"`
1153 | 	Status            int           `json:"status"`
1154 | 	PaidEvent         PaidEvent     `json:"paidEvent"`
1155 | 	LiveSubOnly       int           `json:"liveSubOnly"`
1156 | 	LiveRoomMode      int           `json:"liveRoomMode"`
1157 | 	HashTagID         int           `json:"hashTagId"`
1158 | 	GameTagID         int           `json:"gameTagId"`
1159 | 	LiveRoomStats     LiveRoomStats `json:"liveRoomStats"`
1160 | 	StreamData        StreamData    `json:"streamData"`
1161 | 	StreamID          string        `json:"streamId"`
1162 | 	MultiStreamScene  int           `json:"multiStreamScene"`
1163 | 	MultiStreamSource int           `json:"multiStreamSource"`
1164 | 	HevcStreamData    StreamData    `json:"hevcStreamData"`
1165 | }
1166 | 
1167 | type PaidEvent struct {
1168 | 	EventID  int `json:"event_id"`
1169 | 	PaidType int `json:"paid_type"`
1170 | }
1171 | 
1172 | type LiveRoomStats struct {
1173 | 	UserCount int `json:"userCount"`
1174 | }
1175 | 
1176 | type StreamData struct {
1177 | 	PullData PullData `json:"pull_data"`
1178 | }
1179 | 
1180 | type PullData struct {
1181 | 	Options    Options `json:"options"`
1182 | 	StreamData string  `json:"stream_data"`
1183 | }
1184 | 
1185 | type Options struct {
1186 | 	DefaultQuality    Quality   `json:"default_quality"`
1187 | 	Qualities         []Quality `json:"qualities"`
1188 | 	ShowQualityButton bool      `json:"show_quality_button"`
1189 | }
1190 | 
1191 | type Quality struct {
1192 | 	IconType   int    `json:"icon_type"`
1193 | 	Level      int    `json:"level"`
1194 | 	Name       string `json:"name"`
1195 | 	Resolution string `json:"resolution"`
1196 | 	SdkKey     string `json:"sdk_key"`
1197 | 	VCodec     string `json:"v_codec"`
1198 | }
1199 | 


--------------------------------------------------------------------------------