wsapi.go 13 KB

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