wsapi.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751
  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. 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. fmt.Println(err1)
  228. return err1
  229. }
  230. defer z.Close()
  231. reader = z
  232. }
  233. var e *Event
  234. decoder := json.NewDecoder(reader)
  235. if err = decoder.Decode(&e); err != nil {
  236. fmt.Println(err)
  237. return
  238. }
  239. if s.Debug {
  240. printEvent(e)
  241. }
  242. switch e.Type {
  243. case "READY":
  244. var st *Ready
  245. if err = unmarshalEvent(e, &st); err == nil {
  246. go s.heartbeat(s.wsConn, s.listening, st.HeartbeatInterval)
  247. if s.StateEnabled {
  248. s.State.OnReady(st)
  249. }
  250. if s.OnReady != nil {
  251. s.OnReady(s, st)
  252. }
  253. }
  254. if s.OnReady != nil {
  255. return
  256. }
  257. case "VOICE_SERVER_UPDATE":
  258. // TEMP CODE FOR TESTING VOICE
  259. var st *VoiceServerUpdate
  260. if err = unmarshalEvent(e, &st); err == nil {
  261. s.onVoiceServerUpdate(st)
  262. }
  263. return
  264. case "VOICE_STATE_UPDATE":
  265. // TEMP CODE FOR TESTING VOICE
  266. var st *VoiceState
  267. if err = unmarshalEvent(e, &st); err == nil {
  268. s.onVoiceStateUpdate(st)
  269. }
  270. return
  271. case "USER_UPDATE":
  272. if s.OnUserUpdate != nil {
  273. var st *User
  274. if err = unmarshalEvent(e, &st); err == nil {
  275. s.OnUserUpdate(s, st)
  276. }
  277. return
  278. }
  279. case "PRESENCE_UPDATE":
  280. if s.OnPresenceUpdate != nil {
  281. var st *PresenceUpdate
  282. if err = unmarshalEvent(e, &st); err == nil {
  283. s.OnPresenceUpdate(s, st)
  284. }
  285. return
  286. }
  287. case "TYPING_START":
  288. if s.OnTypingStart != nil {
  289. var st *TypingStart
  290. if err = unmarshalEvent(e, &st); err == nil {
  291. s.OnTypingStart(s, st)
  292. }
  293. return
  294. }
  295. /* Never seen this come in but saw it in another Library.
  296. case "MESSAGE_ACK":
  297. if s.OnMessageAck != nil {
  298. }
  299. */
  300. case "MESSAGE_CREATE":
  301. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  302. if !stateEnabled && s.OnMessageCreate == nil {
  303. break
  304. }
  305. var st *Message
  306. if err = unmarshalEvent(e, &st); err == nil {
  307. if stateEnabled {
  308. s.State.MessageAdd(st)
  309. }
  310. if s.OnMessageCreate != nil {
  311. s.OnMessageCreate(s, st)
  312. }
  313. }
  314. if s.OnMessageCreate != nil {
  315. return
  316. }
  317. case "MESSAGE_UPDATE":
  318. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  319. if !stateEnabled && s.OnMessageUpdate == nil {
  320. break
  321. }
  322. var st *Message
  323. if err = unmarshalEvent(e, &st); err == nil {
  324. if stateEnabled {
  325. s.State.MessageAdd(st)
  326. }
  327. if s.OnMessageUpdate != nil {
  328. s.OnMessageUpdate(s, st)
  329. }
  330. }
  331. return
  332. case "MESSAGE_DELETE":
  333. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  334. if !stateEnabled && s.OnMessageDelete == nil {
  335. break
  336. }
  337. var st *Message
  338. if err = unmarshalEvent(e, &st); err == nil {
  339. if stateEnabled {
  340. s.State.MessageRemove(st)
  341. }
  342. if s.OnMessageDelete != nil {
  343. s.OnMessageDelete(s, st)
  344. }
  345. }
  346. return
  347. case "MESSAGE_ACK":
  348. if s.OnMessageAck != nil {
  349. var st *MessageAck
  350. if err = unmarshalEvent(e, &st); err == nil {
  351. s.OnMessageAck(s, st)
  352. }
  353. return
  354. }
  355. case "CHANNEL_CREATE":
  356. if !s.StateEnabled && s.OnChannelCreate == nil {
  357. break
  358. }
  359. var st *Channel
  360. if err = unmarshalEvent(e, &st); err == nil {
  361. if s.StateEnabled {
  362. s.State.ChannelAdd(st)
  363. }
  364. if s.OnChannelCreate != nil {
  365. s.OnChannelCreate(s, st)
  366. }
  367. }
  368. if s.OnChannelCreate != nil {
  369. return
  370. }
  371. case "CHANNEL_UPDATE":
  372. if !s.StateEnabled && s.OnChannelUpdate == nil {
  373. break
  374. }
  375. var st *Channel
  376. if err = unmarshalEvent(e, &st); err == nil {
  377. if s.StateEnabled {
  378. s.State.ChannelAdd(st)
  379. }
  380. if s.OnChannelUpdate != nil {
  381. s.OnChannelUpdate(s, st)
  382. }
  383. }
  384. if s.OnChannelUpdate != nil {
  385. return
  386. }
  387. case "CHANNEL_DELETE":
  388. if !s.StateEnabled && s.OnChannelDelete == nil {
  389. break
  390. }
  391. var st *Channel
  392. if err = unmarshalEvent(e, &st); err == nil {
  393. if s.StateEnabled {
  394. s.State.ChannelRemove(st)
  395. }
  396. if s.OnChannelDelete != nil {
  397. s.OnChannelDelete(s, st)
  398. }
  399. }
  400. if s.OnChannelDelete != nil {
  401. return
  402. }
  403. case "GUILD_CREATE":
  404. if !s.StateEnabled && s.OnGuildCreate == nil {
  405. break
  406. }
  407. var st *Guild
  408. if err = unmarshalEvent(e, &st); err == nil {
  409. if s.StateEnabled {
  410. s.State.GuildAdd(st)
  411. }
  412. if s.OnGuildCreate != nil {
  413. s.OnGuildCreate(s, st)
  414. }
  415. }
  416. if s.OnGuildCreate != nil {
  417. return
  418. }
  419. case "GUILD_UPDATE":
  420. if !s.StateEnabled && s.OnGuildUpdate == nil {
  421. break
  422. }
  423. var st *Guild
  424. if err = unmarshalEvent(e, &st); err == nil {
  425. if s.StateEnabled {
  426. s.State.GuildAdd(st)
  427. }
  428. if s.OnGuildCreate != nil {
  429. s.OnGuildUpdate(s, st)
  430. }
  431. }
  432. if s.OnGuildUpdate != nil {
  433. return
  434. }
  435. case "GUILD_DELETE":
  436. if !s.StateEnabled && s.OnGuildDelete == nil {
  437. break
  438. }
  439. var st *Guild
  440. if err = unmarshalEvent(e, &st); err == nil {
  441. if s.StateEnabled {
  442. s.State.GuildRemove(st)
  443. }
  444. if s.OnGuildDelete != nil {
  445. s.OnGuildDelete(s, st)
  446. }
  447. }
  448. if s.OnGuildDelete != nil {
  449. return
  450. }
  451. case "GUILD_MEMBER_ADD":
  452. if !s.StateEnabled && s.OnGuildMemberAdd == nil {
  453. break
  454. }
  455. var st *Member
  456. if err = unmarshalEvent(e, &st); err == nil {
  457. if s.StateEnabled {
  458. s.State.MemberAdd(st)
  459. }
  460. if s.OnGuildMemberAdd != nil {
  461. s.OnGuildMemberAdd(s, st)
  462. }
  463. }
  464. if s.OnGuildMemberAdd != nil {
  465. return
  466. }
  467. case "GUILD_MEMBER_REMOVE":
  468. if !s.StateEnabled && s.OnGuildMemberRemove == nil {
  469. break
  470. }
  471. var st *Member
  472. if err = unmarshalEvent(e, &st); err == nil {
  473. if s.StateEnabled {
  474. s.State.MemberRemove(st)
  475. }
  476. if s.OnGuildMemberRemove != nil {
  477. s.OnGuildMemberRemove(s, st)
  478. }
  479. }
  480. if s.OnGuildMemberRemove != nil {
  481. return
  482. }
  483. case "GUILD_MEMBER_UPDATE":
  484. if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
  485. break
  486. }
  487. var st *Member
  488. if err = unmarshalEvent(e, &st); err == nil {
  489. if s.StateEnabled {
  490. s.State.MemberAdd(st)
  491. }
  492. if s.OnGuildMemberUpdate != nil {
  493. s.OnGuildMemberUpdate(s, st)
  494. }
  495. }
  496. if s.OnGuildMemberUpdate != nil {
  497. return
  498. }
  499. case "GUILD_ROLE_CREATE":
  500. if s.OnGuildRoleCreate != nil {
  501. var st *GuildRole
  502. if err = unmarshalEvent(e, &st); err == nil {
  503. s.OnGuildRoleCreate(s, st)
  504. }
  505. return
  506. }
  507. case "GUILD_ROLE_UPDATE":
  508. if s.OnGuildRoleUpdate != nil {
  509. var st *GuildRole
  510. if err = unmarshalEvent(e, &st); err == nil {
  511. s.OnGuildRoleUpdate(s, st)
  512. }
  513. return
  514. }
  515. case "GUILD_ROLE_DELETE":
  516. if s.OnGuildRoleDelete != nil {
  517. var st *GuildRoleDelete
  518. if err = unmarshalEvent(e, &st); err == nil {
  519. s.OnGuildRoleDelete(s, st)
  520. }
  521. return
  522. }
  523. case "GUILD_INTEGRATIONS_UPDATE":
  524. if s.OnGuildIntegrationsUpdate != nil {
  525. var st *GuildIntegrationsUpdate
  526. if err = unmarshalEvent(e, &st); err == nil {
  527. s.OnGuildIntegrationsUpdate(s, st)
  528. }
  529. return
  530. }
  531. case "GUILD_BAN_ADD":
  532. if s.OnGuildBanAdd != nil {
  533. var st *GuildBan
  534. if err = unmarshalEvent(e, &st); err == nil {
  535. s.OnGuildBanAdd(s, st)
  536. }
  537. return
  538. }
  539. case "GUILD_BAN_REMOVE":
  540. if s.OnGuildBanRemove != nil {
  541. var st *GuildBan
  542. if err = unmarshalEvent(e, &st); err == nil {
  543. s.OnGuildBanRemove(s, st)
  544. }
  545. return
  546. }
  547. case "GUILD_EMOJIS_UPDATE":
  548. if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
  549. break
  550. }
  551. var st *GuildEmojisUpdate
  552. if err = unmarshalEvent(e, &st); err == nil {
  553. if s.StateEnabled {
  554. s.State.EmojisAdd(st.GuildID, st.Emojis)
  555. }
  556. if s.OnGuildEmojisUpdate != nil {
  557. s.OnGuildEmojisUpdate(s, st)
  558. }
  559. }
  560. if s.OnGuildEmojisUpdate != nil {
  561. return
  562. }
  563. case "USER_SETTINGS_UPDATE":
  564. if s.OnUserSettingsUpdate != nil {
  565. var st map[string]interface{}
  566. if err = unmarshalEvent(e, &st); err == nil {
  567. s.OnUserSettingsUpdate(s, st)
  568. }
  569. return
  570. }
  571. default:
  572. fmt.Println("Unknown Event.")
  573. printEvent(e)
  574. }
  575. // if still here, send to generic OnEvent
  576. if s.OnEvent != nil {
  577. s.OnEvent(s, e)
  578. return
  579. }
  580. return
  581. }
  582. // ------------------------------------------------------------------------------------------------
  583. // Code related to voice connections that initiate over the data websocket
  584. // ------------------------------------------------------------------------------------------------
  585. // A VoiceServerUpdate stores the data received during the Voice Server Update
  586. // data websocket event. This data is used during the initial Voice Channel
  587. // join handshaking.
  588. type VoiceServerUpdate struct {
  589. Token string `json:"token"`
  590. GuildID string `json:"guild_id"`
  591. Endpoint string `json:"endpoint"`
  592. }
  593. type voiceChannelJoinData struct {
  594. GuildID string `json:"guild_id"`
  595. ChannelID string `json:"channel_id"`
  596. SelfMute bool `json:"self_mute"`
  597. SelfDeaf bool `json:"self_deaf"`
  598. }
  599. type voiceChannelJoinOp struct {
  600. Op int `json:"op"`
  601. Data voiceChannelJoinData `json:"d"`
  602. }
  603. // ChannelVoiceJoin joins the session user to a voice channel. After calling
  604. // this func please monitor the Session.Voice.Ready bool to determine when
  605. // it is ready and able to send/receive audio, that should happen quickly.
  606. //
  607. // gID : Guild ID of the channel to join.
  608. // cID : Channel ID of the channel to join.
  609. // mute : If true, you will be set to muted upon joining.
  610. // deaf : If true, you will be set to deafened upon joining.
  611. func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (err error) {
  612. if s.wsConn == nil {
  613. return fmt.Errorf("no websocket connection exists.")
  614. }
  615. // Create new voice{} struct if one does not exist.
  616. // If you create this prior to calling this func then you can manually
  617. // set some variables if needed, such as to enable debugging.
  618. if s.Voice == nil {
  619. s.Voice = &Voice{}
  620. }
  621. // TODO : Determine how to properly change channels and change guild
  622. // and channel when you are already connected to an existing channel.
  623. // Send the request to Discord that we want to join the voice channel
  624. data := voiceChannelJoinOp{4, voiceChannelJoinData{gID, cID, mute, deaf}}
  625. err = s.wsConn.WriteJSON(data)
  626. if err != nil {
  627. return
  628. }
  629. // Store gID and cID for later use
  630. s.Voice.guildID = gID
  631. s.Voice.channelID = cID
  632. return
  633. }
  634. // onVoiceStateUpdate handles Voice State Update events on the data
  635. // websocket. This comes immediately after the call to VoiceChannelJoin
  636. // for the session user.
  637. func (s *Session) onVoiceStateUpdate(st *VoiceState) {
  638. // If s.Voice is nil, we must not have even requested to join
  639. // a voice channel yet, so this shouldn't be processed.
  640. if s.Voice == nil {
  641. return
  642. }
  643. // Need to have this happen at login and store it in the Session
  644. // TODO : This should be done upon connecting to Discord, or
  645. // be moved to a small helper function
  646. self, err := s.User("@me") // TODO: move to Login/New
  647. if err != nil {
  648. fmt.Println(err)
  649. return
  650. }
  651. // This event comes for all users, if it's not for the session
  652. // user just ignore it.
  653. // TODO Move this IF to the event() func
  654. if st.UserID != self.ID {
  655. return
  656. }
  657. // Store the SessionID for later use.
  658. s.Voice.userID = self.ID // TODO: Review
  659. s.Voice.sessionID = st.SessionID
  660. }
  661. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  662. // This event tells us the information needed to open a voice websocket
  663. // connection and should happen after the VOICE_STATE event.
  664. func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
  665. // This shouldn't ever be the case, I don't think.
  666. if s.Voice == nil {
  667. return
  668. }
  669. // Store values for later use
  670. s.Voice.token = st.Token
  671. s.Voice.endpoint = st.Endpoint
  672. s.Voice.guildID = st.GuildID
  673. // We now have enough information to open a voice websocket conenction
  674. // so, that's what the next call does.
  675. err := s.Voice.Open()
  676. if err != nil {
  677. fmt.Println("onVoiceServerUpdate Voice.Open error: ", err)
  678. // TODO better logging
  679. }
  680. }