wsapi.go 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  1. // Discordgo - Discord bindings for Go
  2. // Available at https://github.com/bwmarrin/discordgo
  3. // Copyright 2015 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. "encoding/json"
  11. "fmt"
  12. "runtime"
  13. "time"
  14. "github.com/gorilla/websocket"
  15. )
  16. // Open opens a websocket connection to Discord.
  17. func (s *Session) Open() (err error) {
  18. // Get the gateway to use for the Websocket connection
  19. g, err := s.Gateway()
  20. // TODO: See if there's a use for the http response.
  21. // conn, response, err := websocket.DefaultDialer.Dial(session.Gateway, nil)
  22. s.wsConn, _, err = websocket.DefaultDialer.Dial(g, nil)
  23. return
  24. }
  25. type handshakeProperties struct {
  26. OS string `json:"$os"`
  27. Browser string `json:"$browser"`
  28. Device string `json:"$device"`
  29. Referer string `json:"$referer"`
  30. ReferringDomain string `json:"$referring_domain"`
  31. }
  32. type handshakeData struct {
  33. Version int `json:"v"`
  34. Token string `json:"token"`
  35. Properties handshakeProperties `json:"properties"`
  36. }
  37. type handshakeOp struct {
  38. Op int `json:"op"`
  39. Data handshakeData `json:"d"`
  40. }
  41. // Handshake sends the client data to Discord during websocket initial connection.
  42. func (s *Session) Handshake() (err error) {
  43. // maybe this is SendOrigin? not sure the right name here
  44. data := handshakeOp{2, handshakeData{3, s.Token, handshakeProperties{runtime.GOOS, "DiscordGo v" + VERSION, "", "", ""}}}
  45. err = s.wsConn.WriteJSON(data)
  46. return
  47. }
  48. type updateStatusData struct {
  49. IdleSince json.Token `json:"idle_since"`
  50. GameID json.Token `json:"game_id"`
  51. }
  52. type updateStatusOp struct {
  53. Op int `json:"op"`
  54. Data updateStatusData `json:"d"`
  55. }
  56. // UpdateStatus is used to update the authenticated user's status.
  57. // If idle>0 then set status to idle. If game>0 then set game.
  58. // if otherwise, set status to active, and no game.
  59. func (s *Session) UpdateStatus(idle int, gameID int) (err error) {
  60. var usd updateStatusData
  61. if idle > 0 {
  62. usd.IdleSince = idle
  63. } else {
  64. usd.IdleSince = nil
  65. }
  66. if gameID >= 0 {
  67. usd.GameID = gameID
  68. } else {
  69. usd.GameID = nil
  70. }
  71. data := updateStatusOp{3, usd}
  72. err = s.wsConn.WriteJSON(data)
  73. return
  74. }
  75. // Listen starts listening to the websocket connection for events.
  76. func (s *Session) Listen() (err error) {
  77. // TODO: need a channel or something to communicate
  78. // to this so I can tell it to stop listening
  79. if s.wsConn == nil {
  80. fmt.Println("No websocket connection exists.")
  81. return // TODO need to return an error.
  82. }
  83. for {
  84. messageType, message, err := s.wsConn.ReadMessage()
  85. if err != nil {
  86. fmt.Println("Websocket Listen Error", err)
  87. // TODO Log error
  88. break
  89. }
  90. go s.event(messageType, message)
  91. }
  92. return
  93. }
  94. // Not sure how needed this is and where it would be best to call it.
  95. // somewhere.
  96. // Close closes the connection to the websocket.
  97. func (s *Session) Close() {
  98. s.wsConn.Close()
  99. }
  100. // Front line handler for all Websocket Events. Determines the
  101. // event type and passes the message along to the next handler.
  102. // event is the front line handler for all events. This needs to be
  103. // broken up into smaller functions to be more idiomatic Go.
  104. func (s *Session) event(messageType int, message []byte) (err error) {
  105. if s.Debug {
  106. printJSON(message)
  107. }
  108. var e Event
  109. if err := json.Unmarshal(message, &e); err != nil {
  110. fmt.Println(err)
  111. return err
  112. }
  113. switch e.Type {
  114. case "READY":
  115. var st Ready
  116. if err := json.Unmarshal(e.RawData, &st); err != nil {
  117. fmt.Println(e.Type, err)
  118. printJSON(e.RawData) // TODO: Better error logging
  119. return err
  120. }
  121. if s.OnReady != nil {
  122. s.OnReady(s, st)
  123. return
  124. }
  125. go s.Heartbeat(st.HeartbeatInterval)
  126. case "VOICE_SERVER_UPDATE":
  127. // TEMP CODE FOR TESTING VOICE
  128. var st VoiceServerUpdate
  129. if err := json.Unmarshal(e.RawData, &st); err != nil {
  130. fmt.Println(e.Type, err)
  131. printJSON(e.RawData) // TODO: Better error logging
  132. return err
  133. }
  134. s.onVoiceServerUpdate(st)
  135. return
  136. case "VOICE_STATE_UPDATE":
  137. // TEMP CODE FOR TESTING VOICE
  138. var st VoiceState
  139. if err := json.Unmarshal(e.RawData, &st); err != nil {
  140. fmt.Println(e.Type, err)
  141. printJSON(e.RawData) // TODO: Better error logging
  142. return err
  143. }
  144. s.onVoiceStateUpdate(st)
  145. return
  146. case "PRESENCE_UPDATE":
  147. if s.OnPresenceUpdate != nil {
  148. var st PresenceUpdate
  149. if err := json.Unmarshal(e.RawData, &st); err != nil {
  150. fmt.Println(e.Type, err)
  151. printJSON(e.RawData) // TODO: Better error logging
  152. return err
  153. }
  154. s.OnPresenceUpdate(s, st)
  155. return
  156. }
  157. case "TYPING_START":
  158. if s.OnTypingStart != nil {
  159. var st TypingStart
  160. if err := json.Unmarshal(e.RawData, &st); err != nil {
  161. fmt.Println(e.Type, err)
  162. printJSON(e.RawData) // TODO: Better error logging
  163. return err
  164. }
  165. s.OnTypingStart(s, st)
  166. return
  167. }
  168. /* // Never seen this come in but saw it in another Library.
  169. case "MESSAGE_ACK":
  170. if s.OnMessageAck != nil {
  171. }
  172. */
  173. case "MESSAGE_CREATE":
  174. if s.OnMessageCreate != nil {
  175. var st Message
  176. if err := json.Unmarshal(e.RawData, &st); err != nil {
  177. fmt.Println(e.Type, err)
  178. printJSON(e.RawData) // TODO: Better error logging
  179. return err
  180. }
  181. s.OnMessageCreate(s, st)
  182. return
  183. }
  184. case "MESSAGE_UPDATE":
  185. if s.OnMessageUpdate != nil {
  186. var st Message
  187. if err := json.Unmarshal(e.RawData, &st); err != nil {
  188. fmt.Println(e.Type, err)
  189. printJSON(e.RawData) // TODO: Better error logging
  190. return err
  191. }
  192. s.OnMessageUpdate(s, st)
  193. return
  194. }
  195. case "MESSAGE_DELETE":
  196. if s.OnMessageDelete != nil {
  197. var st MessageDelete
  198. if err := json.Unmarshal(e.RawData, &st); err != nil {
  199. fmt.Println(e.Type, err)
  200. printJSON(e.RawData) // TODO: Better error logging
  201. return err
  202. }
  203. s.OnMessageDelete(s, st)
  204. return
  205. }
  206. case "MESSAGE_ACK":
  207. if s.OnMessageAck != nil {
  208. var st MessageAck
  209. if err := json.Unmarshal(e.RawData, &st); err != nil {
  210. fmt.Println(e.Type, err)
  211. printJSON(e.RawData) // TODO: Better error logging
  212. return err
  213. }
  214. s.OnMessageAck(s, st)
  215. return
  216. }
  217. case "CHANNEL_CREATE":
  218. if s.OnChannelCreate != nil {
  219. var st Channel
  220. if err := json.Unmarshal(e.RawData, &st); err != nil {
  221. fmt.Println(e.Type, err)
  222. printJSON(e.RawData) // TODO: Better error logginEventg
  223. return err
  224. }
  225. s.OnChannelCreate(s, st)
  226. return
  227. }
  228. case "CHANNEL_UPDATE":
  229. if s.OnChannelUpdate != nil {
  230. var st Channel
  231. if err := json.Unmarshal(e.RawData, &st); err != nil {
  232. fmt.Println(e.Type, err)
  233. printJSON(e.RawData) // TODO: Better error logginEventg
  234. return err
  235. }
  236. s.OnChannelUpdate(s, st)
  237. return
  238. }
  239. case "CHANNEL_DELETE":
  240. if s.OnChannelDelete != nil {
  241. var st Channel
  242. if err := json.Unmarshal(e.RawData, &st); err != nil {
  243. fmt.Println(e.Type, err)
  244. printJSON(e.RawData) // TODO: Better error logginEventg
  245. return err
  246. }
  247. s.OnChannelDelete(s, st)
  248. return
  249. }
  250. case "GUILD_CREATE":
  251. if s.OnGuildCreate != nil {
  252. var st Guild
  253. if err := json.Unmarshal(e.RawData, &st); err != nil {
  254. fmt.Println(e.Type, err)
  255. printJSON(e.RawData) // TODO: Better error logginEventg
  256. return err
  257. }
  258. s.OnGuildCreate(s, st)
  259. return
  260. }
  261. case "GUILD_UPDATE":
  262. if s.OnGuildCreate != nil {
  263. var st Guild
  264. if err := json.Unmarshal(e.RawData, &st); err != nil {
  265. fmt.Println(e.Type, err)
  266. printJSON(e.RawData) // TODO: Better error logginEventg
  267. return err
  268. }
  269. s.OnGuildUpdate(s, st)
  270. return
  271. }
  272. case "GUILD_DELETE":
  273. if s.OnGuildDelete != nil {
  274. var st Guild
  275. if err := json.Unmarshal(e.RawData, &st); err != nil {
  276. fmt.Println(e.Type, err)
  277. printJSON(e.RawData) // TODO: Better error logginEventg
  278. return err
  279. }
  280. s.OnGuildDelete(s, st)
  281. return
  282. }
  283. case "GUILD_MEMBER_ADD":
  284. if s.OnGuildMemberAdd != nil {
  285. var st Member
  286. if err := json.Unmarshal(e.RawData, &st); err != nil {
  287. fmt.Println(e.Type, err)
  288. printJSON(e.RawData) // TODO: Better error logginEventg
  289. return err
  290. }
  291. s.OnGuildMemberAdd(s, st)
  292. return
  293. }
  294. case "GUILD_MEMBER_REMOVE":
  295. if s.OnGuildMemberRemove != nil {
  296. var st Member
  297. if err := json.Unmarshal(e.RawData, &st); err != nil {
  298. fmt.Println(e.Type, err)
  299. printJSON(e.RawData) // TODO: Better error logginEventg
  300. return err
  301. }
  302. s.OnGuildMemberRemove(s, st)
  303. return
  304. }
  305. case "GUILD_MEMBER_UPDATE":
  306. if s.OnGuildMemberUpdate != nil {
  307. var st Member
  308. if err := json.Unmarshal(e.RawData, &st); err != nil {
  309. fmt.Println(e.Type, err)
  310. printJSON(e.RawData) // TODO: Better error logginEventg
  311. return err
  312. }
  313. s.OnGuildMemberUpdate(s, st)
  314. return
  315. }
  316. case "GUILD_ROLE_CREATE":
  317. if s.OnGuildRoleCreate != nil {
  318. var st GuildRole
  319. if err := json.Unmarshal(e.RawData, &st); err != nil {
  320. fmt.Println(e.Type, err)
  321. printJSON(e.RawData) // TODO: Better error logginEventg
  322. return err
  323. }
  324. s.OnGuildRoleCreate(s, st)
  325. return
  326. }
  327. case "GUILD_ROLE_UPDATE":
  328. if s.OnGuildRoleUpdate != nil {
  329. var st GuildRole
  330. if err := json.Unmarshal(e.RawData, &st); err != nil {
  331. fmt.Println(e.Type, err)
  332. printJSON(e.RawData) // TODO: Better error logginEventg
  333. return err
  334. }
  335. s.OnGuildRoleUpdate(s, st)
  336. return
  337. }
  338. case "GUILD_ROLE_DELETE":
  339. if s.OnGuildRoleDelete != nil {
  340. var st GuildRoleDelete
  341. if err := json.Unmarshal(e.RawData, &st); err != nil {
  342. fmt.Println(e.Type, err)
  343. printJSON(e.RawData) // TODO: Better error logginEventg
  344. return err
  345. }
  346. s.OnGuildRoleDelete(s, st)
  347. return
  348. }
  349. case "GUILD_INTEGRATIONS_UPDATE":
  350. if s.OnGuildIntegrationsUpdate != nil {
  351. var st GuildIntegrationsUpdate
  352. if err := json.Unmarshal(e.RawData, &st); err != nil {
  353. fmt.Println(e.Type, err)
  354. printJSON(e.RawData) // TODO: Better error logginEventg
  355. return err
  356. }
  357. s.OnGuildIntegrationsUpdate(s, st)
  358. return
  359. }
  360. default:
  361. fmt.Println("UNKNOWN EVENT: ", e.Type)
  362. // learn the log package
  363. // log.print type and JSON data
  364. }
  365. // if still here, send to generic OnEvent
  366. if s.OnEvent != nil {
  367. s.OnEvent(s, e)
  368. return
  369. }
  370. return
  371. }
  372. // This heartbeat is sent to keep the Websocket conenction
  373. // to Discord alive. If not sent, Discord will close the
  374. // connection.
  375. // Heartbeat sends regular heartbeats to Discord so it knows the client
  376. // is still connected. If you do not send these heartbeats Discord will
  377. // disconnect the websocket connection after a few seconds.
  378. func (s *Session) Heartbeat(i time.Duration) {
  379. if s.wsConn == nil {
  380. fmt.Println("No websocket connection exists.")
  381. return // TODO need to return an error.
  382. }
  383. // send first heartbeat immediately because lag could put the
  384. // first heartbeat outside the required heartbeat interval window
  385. ticker := time.NewTicker(i * time.Millisecond)
  386. for {
  387. timestamp := int(time.Now().Unix())
  388. err := s.wsConn.WriteJSON(map[string]int{
  389. "op": 1,
  390. "d": timestamp,
  391. })
  392. if err != nil {
  393. fmt.Println("error sending data heartbeat:", err)
  394. s.DataReady = false
  395. return // TODO log error?
  396. }
  397. s.DataReady = true
  398. <-ticker.C
  399. }
  400. }
  401. // Everything below is experimental Voice support code
  402. // all of it will get changed and moved around.
  403. // A VoiceServerUpdate stores the data received during the Voice Server Update
  404. // data websocket event. This data is used during the initial Voice Channel
  405. // join handshaking.
  406. type VoiceServerUpdate struct {
  407. Token string `json:"token"`
  408. GuildID string `json:"guild_id"`
  409. Endpoint string `json:"endpoint"`
  410. }
  411. // VoiceChannelJoin joins the authenticated session user to
  412. // a voice channel. All the voice magic starts with this.
  413. func (s *Session) VoiceChannelJoin(guildID, channelID string) {
  414. if s.wsConn == nil {
  415. fmt.Println("error: no websocket connection exists.")
  416. return // TODO return error
  417. }
  418. // Odd, but.. it works. map interface caused odd unknown opcode error
  419. // Later I'll test with a struct
  420. json := []byte(fmt.Sprintf(`{"op":4,"d":{"guild_id":"%s","channel_id":"%s","self_mute":false,"self_deaf":false}}`,
  421. guildID, channelID))
  422. err := s.wsConn.WriteMessage(websocket.TextMessage, json)
  423. if err != nil {
  424. fmt.Println("error:", err)
  425. return
  426. }
  427. // Probably will be removed later.
  428. s.VGuildID = guildID
  429. s.VChannelID = channelID
  430. }
  431. // onVoiceStateUpdate handles Voice State Update events on the data
  432. // websocket. This comes immediately after the call to VoiceChannelJoin
  433. // for the authenticated session user. This block is experimental
  434. // code and will be chaned in the future.
  435. func (s *Session) onVoiceStateUpdate(st VoiceState) {
  436. // Need to have this happen at login and store it in the Session
  437. self, err := s.User("@me")
  438. if err != nil {
  439. fmt.Println(err)
  440. return
  441. }
  442. // This event comes for all users, if it's not for the session
  443. // user just ignore it.
  444. if st.UserID != self.ID {
  445. return
  446. }
  447. // Store the SessionID. Used later.
  448. s.VSessionID = st.SessionID
  449. }
  450. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  451. // This will later be exposed but is only for experimental use now.
  452. func (s *Session) onVoiceServerUpdate(st VoiceServerUpdate) {
  453. // Store all the values. They are used later.
  454. // GuildID is probably not needed and may be dropped.
  455. s.VToken = st.Token
  456. s.VEndpoint = st.Endpoint
  457. s.VGuildID = st.GuildID
  458. // We now have enough information to open a voice websocket conenction
  459. // so, that's what the next call does.
  460. s.VoiceOpenWS()
  461. }