wsapi.go 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739
  1. // Discordgo - Discord bindings for Go
  2. // Available at https://github.com/bwmarrin/discordgo
  3. // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>. All rights reserved.
  4. // Use of this source code is governed by a BSD-style
  5. // license that can be found in the LICENSE file.
  6. // This file contains low level functions for interacting with the Discord
  7. // data websocket interface.
  8. package discordgo
  9. import (
  10. "bytes"
  11. "compress/zlib"
  12. "encoding/json"
  13. "errors"
  14. "fmt"
  15. "io"
  16. "net/http"
  17. "runtime"
  18. "time"
  19. "github.com/gorilla/websocket"
  20. )
  21. type handshakeProperties struct {
  22. OS string `json:"$os"`
  23. Browser string `json:"$browser"`
  24. Device string `json:"$device"`
  25. Referer string `json:"$referer"`
  26. ReferringDomain string `json:"$referring_domain"`
  27. }
  28. type handshakeData struct {
  29. Version int `json:"v"`
  30. Token string `json:"token"`
  31. Properties handshakeProperties `json:"properties"`
  32. Compress bool `json:"compress"`
  33. }
  34. type handshakeOp struct {
  35. Op int `json:"op"`
  36. Data handshakeData `json:"d"`
  37. }
  38. // Open opens a websocket connection to Discord.
  39. func (s *Session) Open() (err error) {
  40. s.Lock()
  41. defer func() {
  42. if err != nil {
  43. s.Unlock()
  44. }
  45. }()
  46. if s.wsConn != nil {
  47. err = errors.New("Web socket already opened.")
  48. return
  49. }
  50. // Get the gateway to use for the Websocket connection
  51. g, err := s.Gateway()
  52. if err != nil {
  53. return
  54. }
  55. header := http.Header{}
  56. header.Add("accept-encoding", "zlib")
  57. // TODO: See if there's a use for the http response.
  58. // conn, response, err := websocket.DefaultDialer.Dial(session.Gateway, nil)
  59. s.wsConn, _, err = websocket.DefaultDialer.Dial(g, header)
  60. if err != nil {
  61. return
  62. }
  63. err = s.wsConn.WriteJSON(handshakeOp{2, handshakeData{3, s.Token, handshakeProperties{runtime.GOOS, "Discordgo v" + VERSION, "", "", ""}, s.Compress}})
  64. if err != nil {
  65. return
  66. }
  67. // Create listening outside of listen, as it needs to happen inside the mutex
  68. // lock.
  69. s.listening = make(chan interface{})
  70. go s.listen(s.wsConn, s.listening)
  71. s.Unlock()
  72. if s.OnConnect != nil {
  73. s.OnConnect(s)
  74. }
  75. return
  76. }
  77. // Close closes a websocket and stops all listening/heartbeat goroutines.
  78. // TODO: Add support for Voice WS/UDP connections
  79. func (s *Session) Close() (err error) {
  80. s.Lock()
  81. s.DataReady = false
  82. if s.listening != nil {
  83. close(s.listening)
  84. s.listening = nil
  85. }
  86. if s.wsConn != nil {
  87. err = s.wsConn.Close()
  88. s.wsConn = nil
  89. }
  90. s.Unlock()
  91. if s.OnDisconnect != nil {
  92. s.OnDisconnect(s)
  93. }
  94. return
  95. }
  96. // listen polls the websocket connection for events, it will stop when
  97. // the listening channel is closed, or an error occurs.
  98. func (s *Session) listen(wsConn *websocket.Conn, listening <-chan interface{}) {
  99. for {
  100. messageType, message, err := wsConn.ReadMessage()
  101. if err != nil {
  102. // Detect if we have been closed manually. If a Close() has already
  103. // happened, the websocket we are listening on will be different to the
  104. // current session.
  105. s.RLock()
  106. sameConnection := s.wsConn == wsConn
  107. s.RUnlock()
  108. if sameConnection {
  109. // There has been an error reading, Close() the websocket so that
  110. // OnDisconnect is fired.
  111. err := s.Close()
  112. if err != nil {
  113. fmt.Println("error closing session connection: ", err)
  114. }
  115. // Attempt to reconnect, with expenonential backoff up to 10 minutes.
  116. if s.ShouldReconnectOnError {
  117. wait := time.Duration(1)
  118. for {
  119. if s.Open() == nil {
  120. return
  121. }
  122. <-time.After(wait * time.Second)
  123. wait *= 2
  124. if wait > 600 {
  125. wait = 600
  126. }
  127. }
  128. }
  129. }
  130. return
  131. }
  132. select {
  133. case <-listening:
  134. return
  135. default:
  136. go s.event(messageType, message)
  137. }
  138. }
  139. }
  140. type heartbeatOp struct {
  141. Op int `json:"op"`
  142. Data int `json:"d"`
  143. }
  144. func (s *Session) sendHeartbeat(wsConn *websocket.Conn) error {
  145. return wsConn.WriteJSON(heartbeatOp{1, int(time.Now().Unix())})
  146. }
  147. // heartbeat sends regular heartbeats to Discord so it knows the client
  148. // is still connected. If you do not send these heartbeats Discord will
  149. // disconnect the websocket connection after a few seconds.
  150. func (s *Session) heartbeat(wsConn *websocket.Conn, listening <-chan interface{}, i time.Duration) {
  151. if listening == nil || wsConn == nil {
  152. return
  153. }
  154. s.Lock()
  155. s.DataReady = true
  156. s.Unlock()
  157. // Send first heartbeat immediately because lag could put the
  158. // first heartbeat outside the required heartbeat interval window.
  159. err := s.sendHeartbeat(wsConn)
  160. if err != nil {
  161. fmt.Println("Error sending initial heartbeat:", err)
  162. return
  163. }
  164. ticker := time.NewTicker(i * time.Millisecond)
  165. for {
  166. select {
  167. case <-ticker.C:
  168. err := s.sendHeartbeat(wsConn)
  169. if err != nil {
  170. fmt.Println("Error sending heartbeat:", err)
  171. return
  172. }
  173. case <-listening:
  174. return
  175. }
  176. }
  177. }
  178. type updateStatusGame struct {
  179. Name string `json:"name"`
  180. }
  181. type updateStatusData struct {
  182. IdleSince *int `json:"idle_since"`
  183. Game *updateStatusGame `json:"game"`
  184. }
  185. type updateStatusOp struct {
  186. Op int `json:"op"`
  187. Data updateStatusData `json:"d"`
  188. }
  189. // UpdateStatus is used to update the authenticated user's status.
  190. // If idle>0 then set status to idle. If game>0 then set game.
  191. // if otherwise, set status to active, and no game.
  192. func (s *Session) UpdateStatus(idle int, game string) (err error) {
  193. s.RLock()
  194. defer s.RUnlock()
  195. if s.wsConn == nil {
  196. return errors.New("No websocket connection exists.")
  197. }
  198. var usd updateStatusData
  199. if idle > 0 {
  200. usd.IdleSince = &idle
  201. }
  202. if game != "" {
  203. usd.Game = &updateStatusGame{game}
  204. }
  205. err = s.wsConn.WriteJSON(updateStatusOp{3, usd})
  206. return
  207. }
  208. // Front line handler for all Websocket Events. Determines the
  209. // event type and passes the message along to the next handler.
  210. // event is the front line handler for all events. This needs to be
  211. // broken up into smaller functions to be more idiomatic Go.
  212. // Events will be handled by any implemented handler in Session.
  213. // All unhandled events will then be handled by OnEvent.
  214. func (s *Session) event(messageType int, message []byte) {
  215. if s.Handlers == nil {
  216. s.initialize()
  217. }
  218. var err error
  219. var reader io.Reader
  220. reader = bytes.NewBuffer(message)
  221. if messageType == 2 {
  222. z, err1 := zlib.NewReader(reader)
  223. if err1 != nil {
  224. fmt.Println(err1)
  225. return
  226. }
  227. defer func() {
  228. err := z.Close()
  229. if err != nil {
  230. fmt.Println("error closing zlib:", err)
  231. }
  232. }()
  233. reader = z
  234. }
  235. var e *Event
  236. decoder := json.NewDecoder(reader)
  237. if err = decoder.Decode(&e); err != nil {
  238. fmt.Println(err)
  239. return
  240. }
  241. if s.Debug {
  242. printEvent(e)
  243. }
  244. var i interface{}
  245. switch e.Type {
  246. case "READY":
  247. i = &Ready{}
  248. case "MESSAGE_CREATE":
  249. i = &MessageCreate{}
  250. case "MESSAGE_UPDATE":
  251. i = &MessageUpdate{}
  252. case "MESSAGE_DELETE":
  253. i = &MessageDelete{}
  254. case "PRESENCE_UPDATE":
  255. i = &PresenceUpdate{}
  256. case "TYPING_START":
  257. i = &TypingStart{}
  258. }
  259. // case "VOICE_SERVER_UPDATE":
  260. // if s.Voice == nil && s.OnVoiceServerUpdate == nil {
  261. // break
  262. // }
  263. // var st *VoiceServerUpdate
  264. // if err = unmarshalEvent(e, &st); err == nil {
  265. // if s.Voice != nil {
  266. // s.onVoiceServerUpdate(st)
  267. // }
  268. // if s.OnVoiceServerUpdate != nil {
  269. // s.OnVoiceServerUpdate(s, st)
  270. // }
  271. // }
  272. // if s.OnVoiceServerUpdate != nil {
  273. // return
  274. // }
  275. // case "VOICE_STATE_UPDATE":
  276. // if s.Voice == nil && s.OnVoiceStateUpdate == nil {
  277. // break
  278. // }
  279. // var st *VoiceState
  280. // if err = unmarshalEvent(e, &st); err == nil {
  281. // if s.Voice != nil {
  282. // s.onVoiceStateUpdate(st)
  283. // }
  284. // if s.OnVoiceStateUpdate != nil {
  285. // s.OnVoiceStateUpdate(s, st)
  286. // }
  287. // }
  288. // if s.OnVoiceStateUpdate != nil {
  289. // return
  290. // }
  291. // case "USER_UPDATE":
  292. // if s.OnUserUpdate != nil {
  293. // var st *User
  294. // if err = unmarshalEvent(e, &st); err == nil {
  295. // s.OnUserUpdate(s, st)
  296. // }
  297. // return
  298. // }
  299. // /* Never seen this come in but saw it in another Library.
  300. // case "MESSAGE_ACK":
  301. // if s.OnMessageAck != nil {
  302. // }
  303. // */
  304. // case "MESSAGE_ACK":
  305. // if s.OnMessageAck != nil {
  306. // var st *MessageAck
  307. // if err = unmarshalEvent(e, &st); err == nil {
  308. // s.OnMessageAck(s, st)
  309. // }
  310. // return
  311. // }
  312. // case "CHANNEL_CREATE":
  313. // if !s.StateEnabled && s.OnChannelCreate == nil {
  314. // break
  315. // }
  316. // var st *Channel
  317. // if err = unmarshalEvent(e, &st); err == nil {
  318. // if s.StateEnabled {
  319. // err := s.State.ChannelAdd(st)
  320. // if err != nil {
  321. // fmt.Println("error :", err)
  322. // }
  323. // }
  324. // if s.OnChannelCreate != nil {
  325. // s.OnChannelCreate(s, st)
  326. // }
  327. // }
  328. // if s.OnChannelCreate != nil {
  329. // return
  330. // }
  331. // case "CHANNEL_UPDATE":
  332. // if !s.StateEnabled && s.OnChannelUpdate == nil {
  333. // break
  334. // }
  335. // var st *Channel
  336. // if err = unmarshalEvent(e, &st); err == nil {
  337. // if s.StateEnabled {
  338. // err := s.State.ChannelAdd(st)
  339. // if err != nil {
  340. // fmt.Println("error :", err)
  341. // }
  342. // }
  343. // if s.OnChannelUpdate != nil {
  344. // s.OnChannelUpdate(s, st)
  345. // }
  346. // }
  347. // if s.OnChannelUpdate != nil {
  348. // return
  349. // }
  350. // case "CHANNEL_DELETE":
  351. // if !s.StateEnabled && s.OnChannelDelete == nil {
  352. // break
  353. // }
  354. // var st *Channel
  355. // if err = unmarshalEvent(e, &st); err == nil {
  356. // if s.StateEnabled {
  357. // err := s.State.ChannelRemove(st)
  358. // if err != nil {
  359. // fmt.Println("error :", err)
  360. // }
  361. // }
  362. // if s.OnChannelDelete != nil {
  363. // s.OnChannelDelete(s, st)
  364. // }
  365. // }
  366. // if s.OnChannelDelete != nil {
  367. // return
  368. // }
  369. // case "GUILD_CREATE":
  370. // if !s.StateEnabled && s.OnGuildCreate == nil {
  371. // break
  372. // }
  373. // var st *Guild
  374. // if err = unmarshalEvent(e, &st); err == nil {
  375. // if s.StateEnabled {
  376. // err := s.State.GuildAdd(st)
  377. // if err != nil {
  378. // fmt.Println("error :", err)
  379. // }
  380. // }
  381. // if s.OnGuildCreate != nil {
  382. // s.OnGuildCreate(s, st)
  383. // }
  384. // }
  385. // if s.OnGuildCreate != nil {
  386. // return
  387. // }
  388. // case "GUILD_UPDATE":
  389. // if !s.StateEnabled && s.OnGuildUpdate == nil {
  390. // break
  391. // }
  392. // var st *Guild
  393. // if err = unmarshalEvent(e, &st); err == nil {
  394. // if s.StateEnabled {
  395. // err := s.State.GuildAdd(st)
  396. // if err != nil {
  397. // fmt.Println("error :", err)
  398. // }
  399. // }
  400. // if s.OnGuildCreate != nil {
  401. // s.OnGuildUpdate(s, st)
  402. // }
  403. // }
  404. // if s.OnGuildUpdate != nil {
  405. // return
  406. // }
  407. // case "GUILD_DELETE":
  408. // if !s.StateEnabled && s.OnGuildDelete == nil {
  409. // break
  410. // }
  411. // var st *Guild
  412. // if err = unmarshalEvent(e, &st); err == nil {
  413. // if s.StateEnabled {
  414. // err := s.State.GuildRemove(st)
  415. // if err != nil {
  416. // fmt.Println("error :", err)
  417. // }
  418. // }
  419. // if s.OnGuildDelete != nil {
  420. // s.OnGuildDelete(s, st)
  421. // }
  422. // }
  423. // if s.OnGuildDelete != nil {
  424. // return
  425. // }
  426. // case "GUILD_MEMBER_ADD":
  427. // if !s.StateEnabled && s.OnGuildMemberAdd == nil {
  428. // break
  429. // }
  430. // var st *Member
  431. // if err = unmarshalEvent(e, &st); err == nil {
  432. // if s.StateEnabled {
  433. // err := s.State.MemberAdd(st)
  434. // if err != nil {
  435. // fmt.Println("error :", err)
  436. // }
  437. // }
  438. // if s.OnGuildMemberAdd != nil {
  439. // s.OnGuildMemberAdd(s, st)
  440. // }
  441. // }
  442. // if s.OnGuildMemberAdd != nil {
  443. // return
  444. // }
  445. // case "GUILD_MEMBER_REMOVE":
  446. // if !s.StateEnabled && s.OnGuildMemberRemove == nil {
  447. // break
  448. // }
  449. // var st *Member
  450. // if err = unmarshalEvent(e, &st); err == nil {
  451. // if s.StateEnabled {
  452. // err := s.State.MemberRemove(st)
  453. // if err != nil {
  454. // fmt.Println("error :", err)
  455. // }
  456. // }
  457. // if s.OnGuildMemberRemove != nil {
  458. // s.OnGuildMemberRemove(s, st)
  459. // }
  460. // }
  461. // if s.OnGuildMemberRemove != nil {
  462. // return
  463. // }
  464. // case "GUILD_MEMBER_UPDATE":
  465. // if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
  466. // break
  467. // }
  468. // var st *Member
  469. // if err = unmarshalEvent(e, &st); err == nil {
  470. // if s.StateEnabled {
  471. // err := s.State.MemberAdd(st)
  472. // if err != nil {
  473. // fmt.Println("error :", err)
  474. // }
  475. // }
  476. // if s.OnGuildMemberUpdate != nil {
  477. // s.OnGuildMemberUpdate(s, st)
  478. // }
  479. // }
  480. // if s.OnGuildMemberUpdate != nil {
  481. // return
  482. // }
  483. // case "GUILD_ROLE_CREATE":
  484. // if s.OnGuildRoleCreate != nil {
  485. // var st *GuildRole
  486. // if err = unmarshalEvent(e, &st); err == nil {
  487. // s.OnGuildRoleCreate(s, st)
  488. // }
  489. // return
  490. // }
  491. // case "GUILD_ROLE_UPDATE":
  492. // if s.OnGuildRoleUpdate != nil {
  493. // var st *GuildRole
  494. // if err = unmarshalEvent(e, &st); err == nil {
  495. // s.OnGuildRoleUpdate(s, st)
  496. // }
  497. // return
  498. // }
  499. // case "GUILD_ROLE_DELETE":
  500. // if s.OnGuildRoleDelete != nil {
  501. // var st *GuildRoleDelete
  502. // if err = unmarshalEvent(e, &st); err == nil {
  503. // s.OnGuildRoleDelete(s, st)
  504. // }
  505. // return
  506. // }
  507. // case "GUILD_INTEGRATIONS_UPDATE":
  508. // if s.OnGuildIntegrationsUpdate != nil {
  509. // var st *GuildIntegrationsUpdate
  510. // if err = unmarshalEvent(e, &st); err == nil {
  511. // s.OnGuildIntegrationsUpdate(s, st)
  512. // }
  513. // return
  514. // }
  515. // case "GUILD_BAN_ADD":
  516. // if s.OnGuildBanAdd != nil {
  517. // var st *GuildBan
  518. // if err = unmarshalEvent(e, &st); err == nil {
  519. // s.OnGuildBanAdd(s, st)
  520. // }
  521. // return
  522. // }
  523. // case "GUILD_BAN_REMOVE":
  524. // if s.OnGuildBanRemove != nil {
  525. // var st *GuildBan
  526. // if err = unmarshalEvent(e, &st); err == nil {
  527. // s.OnGuildBanRemove(s, st)
  528. // }
  529. // return
  530. // }
  531. // case "GUILD_EMOJIS_UPDATE":
  532. // if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
  533. // break
  534. // }
  535. // var st *GuildEmojisUpdate
  536. // if err = unmarshalEvent(e, &st); err == nil {
  537. // if s.StateEnabled {
  538. // err := s.State.EmojisAdd(st.GuildID, st.Emojis)
  539. // if err != nil {
  540. // fmt.Println("error :", err)
  541. // }
  542. // }
  543. // if s.OnGuildEmojisUpdate != nil {
  544. // s.OnGuildEmojisUpdate(s, st)
  545. // }
  546. // }
  547. // if s.OnGuildEmojisUpdate != nil {
  548. // return
  549. // }
  550. // case "USER_SETTINGS_UPDATE":
  551. // if s.OnUserSettingsUpdate != nil {
  552. // var st map[string]interface{}
  553. // if err = unmarshalEvent(e, &st); err == nil {
  554. // s.OnUserSettingsUpdate(s, st)
  555. // }
  556. // return
  557. // }
  558. // default:
  559. // fmt.Println("Unknown Event.")
  560. // printEvent(e)
  561. // }
  562. // Attempt to unmarshal our event.
  563. // If there is an error (eg. we don't know how to handle it) we should handle the event itself.
  564. if err = unmarshal(e.RawData, i); err != nil {
  565. fmt.Println("Unable to unmarshal event data.")
  566. printEvent(e)
  567. i = e
  568. }
  569. if !s.Handle(i) {
  570. if i != e {
  571. // If there was not a handler for the struct, handle the event, as long as it wasn't the
  572. // event we were trying to handle.
  573. s.Handle(e)
  574. }
  575. }
  576. return
  577. }
  578. // ------------------------------------------------------------------------------------------------
  579. // Code related to voice connections that initiate over the data websocket
  580. // ------------------------------------------------------------------------------------------------
  581. // A VoiceServerUpdate stores the data received during the Voice Server Update
  582. // data websocket event. This data is used during the initial Voice Channel
  583. // join handshaking.
  584. type VoiceServerUpdate struct {
  585. Token string `json:"token"`
  586. GuildID string `json:"guild_id"`
  587. Endpoint string `json:"endpoint"`
  588. }
  589. type voiceChannelJoinData struct {
  590. GuildID string `json:"guild_id"`
  591. ChannelID string `json:"channel_id"`
  592. SelfMute bool `json:"self_mute"`
  593. SelfDeaf bool `json:"self_deaf"`
  594. }
  595. type voiceChannelJoinOp struct {
  596. Op int `json:"op"`
  597. Data voiceChannelJoinData `json:"d"`
  598. }
  599. // ChannelVoiceJoin joins the session user to a voice channel. After calling
  600. // this func please monitor the Session.Voice.Ready bool to determine when
  601. // it is ready and able to send/receive audio, that should happen quickly.
  602. //
  603. // gID : Guild ID of the channel to join.
  604. // cID : Channel ID of the channel to join.
  605. // mute : If true, you will be set to muted upon joining.
  606. // deaf : If true, you will be set to deafened upon joining.
  607. func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (err error) {
  608. if s.wsConn == nil {
  609. return fmt.Errorf("no websocket connection exists")
  610. }
  611. // Create new voice{} struct if one does not exist.
  612. // If you create this prior to calling this func then you can manually
  613. // set some variables if needed, such as to enable debugging.
  614. if s.Voice == nil {
  615. s.Voice = &Voice{}
  616. }
  617. // TODO : Determine how to properly change channels and change guild
  618. // and channel when you are already connected to an existing channel.
  619. // Send the request to Discord that we want to join the voice channel
  620. data := voiceChannelJoinOp{4, voiceChannelJoinData{gID, cID, mute, deaf}}
  621. err = s.wsConn.WriteJSON(data)
  622. if err != nil {
  623. return
  624. }
  625. // Store gID and cID for later use
  626. s.Voice.guildID = gID
  627. s.Voice.channelID = cID
  628. return
  629. }
  630. // onVoiceStateUpdate handles Voice State Update events on the data
  631. // websocket. This comes immediately after the call to VoiceChannelJoin
  632. // for the session user.
  633. func (s *Session) onVoiceStateUpdate(st *VoiceState) {
  634. // Need to have this happen at login and store it in the Session
  635. // TODO : This should be done upon connecting to Discord, or
  636. // be moved to a small helper function
  637. self, err := s.User("@me") // TODO: move to Login/New
  638. if err != nil {
  639. fmt.Println(err)
  640. return
  641. }
  642. // This event comes for all users, if it's not for the session
  643. // user just ignore it.
  644. // TODO Move this IF to the event() func
  645. if st.UserID != self.ID {
  646. return
  647. }
  648. // Store the SessionID for later use.
  649. s.Voice.userID = self.ID // TODO: Review
  650. s.Voice.sessionID = st.SessionID
  651. }
  652. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  653. // This event tells us the information needed to open a voice websocket
  654. // connection and should happen after the VOICE_STATE event.
  655. func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
  656. // Store values for later use
  657. s.Voice.token = st.Token
  658. s.Voice.endpoint = st.Endpoint
  659. s.Voice.guildID = st.GuildID
  660. // We now have enough information to open a voice websocket conenction
  661. // so, that's what the next call does.
  662. err := s.Voice.Open()
  663. if err != nil {
  664. fmt.Println("onVoiceServerUpdate Voice.Open error: ", err)
  665. // TODO better logging
  666. }
  667. }