wsapi.go 13 KB

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