wsapi.go 14 KB

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