wsapi.go 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758
  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, "", "", ""}, true}})
  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. s.Close()
  112. // Attempt to reconnect, with expenonential backoff up to 10 minutes.
  113. if s.ShouldReconnectOnError {
  114. wait := time.Duration(1)
  115. for {
  116. if s.Open() == nil {
  117. return
  118. }
  119. <-time.After(wait * time.Second)
  120. wait *= 2
  121. if wait > 600 {
  122. wait = 600
  123. }
  124. }
  125. }
  126. }
  127. return
  128. }
  129. select {
  130. case <-listening:
  131. return
  132. default:
  133. go s.event(messageType, message)
  134. }
  135. }
  136. return
  137. }
  138. type heartbeatOp struct {
  139. Op int `json:"op"`
  140. Data int `json:"d"`
  141. }
  142. func (s *Session) sendHeartbeat(wsConn *websocket.Conn) error {
  143. return wsConn.WriteJSON(heartbeatOp{1, int(time.Now().Unix())})
  144. }
  145. // heartbeat sends regular heartbeats to Discord so it knows the client
  146. // is still connected. If you do not send these heartbeats Discord will
  147. // disconnect the websocket connection after a few seconds.
  148. func (s *Session) heartbeat(wsConn *websocket.Conn, listening <-chan interface{}, i time.Duration) {
  149. if listening == nil || wsConn == nil {
  150. return
  151. }
  152. s.Lock()
  153. s.DataReady = true
  154. s.Unlock()
  155. // Send first heartbeat immediately because lag could put the
  156. // first heartbeat outside the required heartbeat interval window.
  157. err := s.sendHeartbeat(wsConn)
  158. if err != nil {
  159. fmt.Println("Error sending initial heartbeat:", err)
  160. return
  161. }
  162. ticker := time.NewTicker(i * time.Millisecond)
  163. for {
  164. select {
  165. case <-ticker.C:
  166. err := s.sendHeartbeat(wsConn)
  167. if err != nil {
  168. fmt.Println("Error sending heartbeat:", err)
  169. return
  170. }
  171. case <-listening:
  172. return
  173. }
  174. }
  175. }
  176. type updateStatusGame struct {
  177. Name string `json:"name"`
  178. }
  179. type updateStatusData struct {
  180. IdleSince *int `json:"idle_since"`
  181. Game *updateStatusGame `json:"game"`
  182. }
  183. type updateStatusOp struct {
  184. Op int `json:"op"`
  185. Data updateStatusData `json:"d"`
  186. }
  187. // UpdateStatus is used to update the authenticated user's status.
  188. // If idle>0 then set status to idle. If game>0 then set game.
  189. // if otherwise, set status to active, and no game.
  190. func (s *Session) UpdateStatus(idle int, game string) (err error) {
  191. s.RLock()
  192. defer s.RUnlock()
  193. if s.wsConn == nil {
  194. return errors.New("No websocket connection exists.")
  195. }
  196. var usd updateStatusData
  197. if idle > 0 {
  198. usd.IdleSince = &idle
  199. }
  200. if game != "" {
  201. usd.Game = &updateStatusGame{game}
  202. }
  203. err = s.wsConn.WriteJSON(updateStatusOp{3, usd})
  204. return
  205. }
  206. // Not sure how needed this is and where it would be best to call it.
  207. // somewhere.
  208. func unmarshalEvent(event *Event, i interface{}) (err error) {
  209. if err = unmarshal(event.RawData, i); err != nil {
  210. fmt.Println("Unable to unmarshal event data.")
  211. printEvent(event)
  212. }
  213. return
  214. }
  215. // Front line handler for all Websocket Events. Determines the
  216. // event type and passes the message along to the next handler.
  217. // event is the front line handler for all events. This needs to be
  218. // broken up into smaller functions to be more idiomatic Go.
  219. // Events will be handled by any implemented handler in Session.
  220. // All unhandled events will then be handled by OnEvent.
  221. func (s *Session) event(messageType int, message []byte) (err error) {
  222. var reader io.Reader
  223. reader = bytes.NewBuffer(message)
  224. if messageType == 2 {
  225. z, err1 := zlib.NewReader(reader)
  226. if err1 != nil {
  227. err = err1
  228. fmt.Println(err)
  229. return
  230. }
  231. defer z.Close()
  232. reader = z
  233. }
  234. var e *Event
  235. decoder := json.NewDecoder(reader)
  236. if err = decoder.Decode(&e); err != nil {
  237. fmt.Println(err)
  238. return
  239. }
  240. if s.Debug {
  241. printEvent(e)
  242. }
  243. switch e.Type {
  244. case "READY":
  245. var st *Ready
  246. if err = unmarshalEvent(e, &st); err == nil {
  247. go s.heartbeat(s.wsConn, s.listening, st.HeartbeatInterval)
  248. if s.StateEnabled {
  249. s.State.OnReady(st)
  250. }
  251. if s.OnReady != nil {
  252. s.OnReady(s, st)
  253. }
  254. }
  255. if s.OnReady != nil {
  256. return
  257. }
  258. case "VOICE_SERVER_UPDATE":
  259. // TEMP CODE FOR TESTING VOICE
  260. var st *VoiceServerUpdate
  261. if err = unmarshalEvent(e, &st); err == nil {
  262. s.onVoiceServerUpdate(st)
  263. }
  264. return
  265. case "VOICE_STATE_UPDATE":
  266. // TEMP CODE FOR TESTING VOICE
  267. var st *VoiceState
  268. if err = unmarshalEvent(e, &st); err == nil {
  269. s.onVoiceStateUpdate(st)
  270. }
  271. return
  272. case "USER_UPDATE":
  273. if s.OnUserUpdate != nil {
  274. var st *User
  275. if err = unmarshalEvent(e, &st); err == nil {
  276. s.OnUserUpdate(s, st)
  277. }
  278. return
  279. }
  280. case "PRESENCE_UPDATE":
  281. if s.OnPresenceUpdate != nil {
  282. var st *PresenceUpdate
  283. if err = unmarshalEvent(e, &st); err == nil {
  284. s.OnPresenceUpdate(s, st)
  285. }
  286. return
  287. }
  288. case "TYPING_START":
  289. if s.OnTypingStart != nil {
  290. var st *TypingStart
  291. if err = unmarshalEvent(e, &st); err == nil {
  292. s.OnTypingStart(s, st)
  293. }
  294. return
  295. }
  296. /* Never seen this come in but saw it in another Library.
  297. case "MESSAGE_ACK":
  298. if s.OnMessageAck != nil {
  299. }
  300. */
  301. case "MESSAGE_CREATE":
  302. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  303. if !stateEnabled && s.OnMessageCreate == nil {
  304. break
  305. }
  306. var st *Message
  307. if err = unmarshalEvent(e, &st); err == nil {
  308. if stateEnabled {
  309. s.State.MessageAdd(st)
  310. }
  311. if s.OnMessageCreate != nil {
  312. s.OnMessageCreate(s, st)
  313. }
  314. }
  315. if s.OnMessageCreate != nil {
  316. return
  317. }
  318. case "MESSAGE_UPDATE":
  319. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  320. if !stateEnabled && s.OnMessageUpdate == nil {
  321. break
  322. }
  323. var st *Message
  324. if err = unmarshalEvent(e, &st); err == nil {
  325. if stateEnabled {
  326. s.State.MessageAdd(st)
  327. }
  328. if s.OnMessageUpdate != nil {
  329. s.OnMessageUpdate(s, st)
  330. }
  331. }
  332. return
  333. if s.OnMessageUpdate != nil {
  334. return
  335. }
  336. case "MESSAGE_DELETE":
  337. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  338. if !stateEnabled && s.OnMessageDelete == nil {
  339. break
  340. }
  341. var st *Message
  342. if err = unmarshalEvent(e, &st); err == nil {
  343. if stateEnabled {
  344. s.State.MessageRemove(st)
  345. }
  346. if s.OnMessageDelete != nil {
  347. s.OnMessageDelete(s, st)
  348. }
  349. }
  350. return
  351. if s.OnMessageDelete != nil {
  352. return
  353. }
  354. case "MESSAGE_ACK":
  355. if s.OnMessageAck != nil {
  356. var st *MessageAck
  357. if err = unmarshalEvent(e, &st); err == nil {
  358. s.OnMessageAck(s, st)
  359. }
  360. return
  361. }
  362. case "CHANNEL_CREATE":
  363. if !s.StateEnabled && s.OnChannelCreate == nil {
  364. break
  365. }
  366. var st *Channel
  367. if err = unmarshalEvent(e, &st); err == nil {
  368. if s.StateEnabled {
  369. s.State.ChannelAdd(st)
  370. }
  371. if s.OnChannelCreate != nil {
  372. s.OnChannelCreate(s, st)
  373. }
  374. }
  375. if s.OnChannelCreate != nil {
  376. return
  377. }
  378. case "CHANNEL_UPDATE":
  379. if !s.StateEnabled && s.OnChannelUpdate == nil {
  380. break
  381. }
  382. var st *Channel
  383. if err = unmarshalEvent(e, &st); err == nil {
  384. if s.StateEnabled {
  385. s.State.ChannelAdd(st)
  386. }
  387. if s.OnChannelUpdate != nil {
  388. s.OnChannelUpdate(s, st)
  389. }
  390. }
  391. if s.OnChannelUpdate != nil {
  392. return
  393. }
  394. case "CHANNEL_DELETE":
  395. if !s.StateEnabled && s.OnChannelDelete == nil {
  396. break
  397. }
  398. var st *Channel
  399. if err = unmarshalEvent(e, &st); err == nil {
  400. if s.StateEnabled {
  401. s.State.ChannelRemove(st)
  402. }
  403. if s.OnChannelDelete != nil {
  404. s.OnChannelDelete(s, st)
  405. }
  406. }
  407. if s.OnChannelDelete != nil {
  408. return
  409. }
  410. case "GUILD_CREATE":
  411. if !s.StateEnabled && s.OnGuildCreate == nil {
  412. break
  413. }
  414. var st *Guild
  415. if err = unmarshalEvent(e, &st); err == nil {
  416. if s.StateEnabled {
  417. s.State.GuildAdd(st)
  418. }
  419. if s.OnGuildCreate != nil {
  420. s.OnGuildCreate(s, st)
  421. }
  422. }
  423. if s.OnGuildCreate != nil {
  424. return
  425. }
  426. case "GUILD_UPDATE":
  427. if !s.StateEnabled && s.OnGuildUpdate == nil {
  428. break
  429. }
  430. var st *Guild
  431. if err = unmarshalEvent(e, &st); err == nil {
  432. if s.StateEnabled {
  433. s.State.GuildAdd(st)
  434. }
  435. if s.OnGuildCreate != nil {
  436. s.OnGuildUpdate(s, st)
  437. }
  438. }
  439. if s.OnGuildUpdate != nil {
  440. return
  441. }
  442. case "GUILD_DELETE":
  443. if !s.StateEnabled && s.OnGuildDelete == nil {
  444. break
  445. }
  446. var st *Guild
  447. if err = unmarshalEvent(e, &st); err == nil {
  448. if s.StateEnabled {
  449. s.State.GuildRemove(st)
  450. }
  451. if s.OnGuildDelete != nil {
  452. s.OnGuildDelete(s, st)
  453. }
  454. }
  455. if s.OnGuildDelete != nil {
  456. return
  457. }
  458. case "GUILD_MEMBER_ADD":
  459. if !s.StateEnabled && s.OnGuildMemberAdd == nil {
  460. break
  461. }
  462. var st *Member
  463. if err = unmarshalEvent(e, &st); err == nil {
  464. if s.StateEnabled {
  465. s.State.MemberAdd(st)
  466. }
  467. if s.OnGuildMemberAdd != nil {
  468. s.OnGuildMemberAdd(s, st)
  469. }
  470. }
  471. if s.OnGuildMemberAdd != nil {
  472. return
  473. }
  474. case "GUILD_MEMBER_REMOVE":
  475. if !s.StateEnabled && s.OnGuildMemberRemove == nil {
  476. break
  477. }
  478. var st *Member
  479. if err = unmarshalEvent(e, &st); err == nil {
  480. if s.StateEnabled {
  481. s.State.MemberRemove(st)
  482. }
  483. if s.OnGuildMemberRemove != nil {
  484. s.OnGuildMemberRemove(s, st)
  485. }
  486. }
  487. if s.OnGuildMemberRemove != nil {
  488. return
  489. }
  490. case "GUILD_MEMBER_UPDATE":
  491. if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
  492. break
  493. }
  494. var st *Member
  495. if err = unmarshalEvent(e, &st); err == nil {
  496. if s.StateEnabled {
  497. s.State.MemberAdd(st)
  498. }
  499. if s.OnGuildMemberUpdate != nil {
  500. s.OnGuildMemberUpdate(s, st)
  501. }
  502. }
  503. if s.OnGuildMemberUpdate != nil {
  504. return
  505. }
  506. case "GUILD_ROLE_CREATE":
  507. if s.OnGuildRoleCreate != nil {
  508. var st *GuildRole
  509. if err = unmarshalEvent(e, &st); err == nil {
  510. s.OnGuildRoleCreate(s, st)
  511. }
  512. return
  513. }
  514. case "GUILD_ROLE_UPDATE":
  515. if s.OnGuildRoleUpdate != nil {
  516. var st *GuildRole
  517. if err = unmarshalEvent(e, &st); err == nil {
  518. s.OnGuildRoleUpdate(s, st)
  519. }
  520. return
  521. }
  522. case "GUILD_ROLE_DELETE":
  523. if s.OnGuildRoleDelete != nil {
  524. var st *GuildRoleDelete
  525. if err = unmarshalEvent(e, &st); err == nil {
  526. s.OnGuildRoleDelete(s, st)
  527. }
  528. return
  529. }
  530. case "GUILD_INTEGRATIONS_UPDATE":
  531. if s.OnGuildIntegrationsUpdate != nil {
  532. var st *GuildIntegrationsUpdate
  533. if err = unmarshalEvent(e, &st); err == nil {
  534. s.OnGuildIntegrationsUpdate(s, st)
  535. }
  536. return
  537. }
  538. case "GUILD_BAN_ADD":
  539. if s.OnGuildBanAdd != nil {
  540. var st *GuildBan
  541. if err = unmarshalEvent(e, &st); err == nil {
  542. s.OnGuildBanAdd(s, st)
  543. }
  544. return
  545. }
  546. case "GUILD_BAN_REMOVE":
  547. if s.OnGuildBanRemove != nil {
  548. var st *GuildBan
  549. if err = unmarshalEvent(e, &st); err == nil {
  550. s.OnGuildBanRemove(s, st)
  551. }
  552. return
  553. }
  554. case "GUILD_EMOJIS_UPDATE":
  555. if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
  556. break
  557. }
  558. var st *GuildEmojisUpdate
  559. if err = unmarshalEvent(e, &st); err == nil {
  560. if s.StateEnabled {
  561. s.State.EmojisAdd(st.GuildID, st.Emojis)
  562. }
  563. if s.OnGuildEmojisUpdate != nil {
  564. s.OnGuildEmojisUpdate(s, st)
  565. }
  566. }
  567. if s.OnGuildEmojisUpdate != nil {
  568. return
  569. }
  570. case "USER_SETTINGS_UPDATE":
  571. if s.OnUserSettingsUpdate != nil {
  572. var st map[string]interface{}
  573. if err = unmarshalEvent(e, &st); err == nil {
  574. s.OnUserSettingsUpdate(s, st)
  575. }
  576. return
  577. }
  578. default:
  579. fmt.Println("Unknown Event.")
  580. printEvent(e)
  581. }
  582. // if still here, send to generic OnEvent
  583. if s.OnEvent != nil {
  584. s.OnEvent(s, e)
  585. return
  586. }
  587. return
  588. }
  589. // ------------------------------------------------------------------------------------------------
  590. // Code related to voice connections that initiate over the data websocket
  591. // ------------------------------------------------------------------------------------------------
  592. // A VoiceServerUpdate stores the data received during the Voice Server Update
  593. // data websocket event. This data is used during the initial Voice Channel
  594. // join handshaking.
  595. type VoiceServerUpdate struct {
  596. Token string `json:"token"`
  597. GuildID string `json:"guild_id"`
  598. Endpoint string `json:"endpoint"`
  599. }
  600. type voiceChannelJoinData struct {
  601. GuildID string `json:"guild_id"`
  602. ChannelID string `json:"channel_id"`
  603. SelfMute bool `json:"self_mute"`
  604. SelfDeaf bool `json:"self_deaf"`
  605. }
  606. type voiceChannelJoinOp struct {
  607. Op int `json:"op"`
  608. Data voiceChannelJoinData `json:"d"`
  609. }
  610. // ChannelVoiceJoin joins the session user to a voice channel. After calling
  611. // this func please monitor the Session.Voice.Ready bool to determine when
  612. // it is ready and able to send/receive audio, that should happen quickly.
  613. //
  614. // gID : Guild ID of the channel to join.
  615. // cID : Channel ID of the channel to join.
  616. // mute : If true, you will be set to muted upon joining.
  617. // deaf : If true, you will be set to deafened upon joining.
  618. func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (err error) {
  619. if s.wsConn == nil {
  620. return fmt.Errorf("no websocket connection exists.")
  621. }
  622. // Create new voice{} struct if one does not exist.
  623. // If you create this prior to calling this func then you can manually
  624. // set some variables if needed, such as to enable debugging.
  625. if s.Voice == nil {
  626. s.Voice = &Voice{}
  627. }
  628. // TODO : Determine how to properly change channels and change guild
  629. // and channel when you are already connected to an existing channel.
  630. // Send the request to Discord that we want to join the voice channel
  631. data := voiceChannelJoinOp{4, voiceChannelJoinData{gID, cID, mute, deaf}}
  632. err = s.wsConn.WriteJSON(data)
  633. if err != nil {
  634. return
  635. }
  636. // Store gID and cID for later use
  637. s.Voice.guildID = gID
  638. s.Voice.channelID = cID
  639. return
  640. }
  641. // onVoiceStateUpdate handles Voice State Update events on the data
  642. // websocket. This comes immediately after the call to VoiceChannelJoin
  643. // for the session user.
  644. func (s *Session) onVoiceStateUpdate(st *VoiceState) {
  645. // If s.Voice is nil, we must not have even requested to join
  646. // a voice channel yet, so this shouldn't be processed.
  647. if s.Voice == nil {
  648. return
  649. }
  650. // Need to have this happen at login and store it in the Session
  651. // TODO : This should be done upon connecting to Discord, or
  652. // be moved to a small helper function
  653. self, err := s.User("@me") // TODO: move to Login/New
  654. if err != nil {
  655. fmt.Println(err)
  656. return
  657. }
  658. // This event comes for all users, if it's not for the session
  659. // user just ignore it.
  660. // TODO Move this IF to the event() func
  661. if st.UserID != self.ID {
  662. return
  663. }
  664. // Store the SessionID for later use.
  665. s.Voice.userID = self.ID // TODO: Review
  666. s.Voice.sessionID = st.SessionID
  667. }
  668. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  669. // This event tells us the information needed to open a voice websocket
  670. // connection and should happen after the VOICE_STATE event.
  671. func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
  672. // This shouldn't ever be the case, I don't think.
  673. if s.Voice == nil {
  674. return
  675. }
  676. // Store values for later use
  677. s.Voice.token = st.Token
  678. s.Voice.endpoint = st.Endpoint
  679. s.Voice.guildID = st.GuildID
  680. // We now have enough information to open a voice websocket conenction
  681. // so, that's what the next call does.
  682. err := s.Voice.Open()
  683. if err != nil {
  684. fmt.Println("onVoiceServerUpdate Voice.Open error: ", err)
  685. // TODO better logging
  686. }
  687. }